programs/winemenubuilder/winemenubuilder.c

   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  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  *
  23  *  This program will read a Windows shortcut file using the IShellLink
  24  * interface, then invoke wineshelllink with the appropriate arguments
  25  * to create a KDE/Gnome menu entry for the shortcut.
  26  *
  27  *  winemenubuilder [ -r ] <shortcut.lnk>
  28  *
  29  *  If the -r parameter is passed, and the shortcut cannot be created,
  30  * this program will add RunOnce entry to invoke itself at the next
  31  * reboot.  This covers the case when a ShortCut is created before the
  32  * executable containing its icon.
  33  *
  34  */
  35
  36 #include "config.h"
  37 #include "wine/port.h"
  38
  39 #include <ctype.h>
  40 #include <stdio.h>
  41 #ifdef HAVE_STRING_H
  42 #include <string.h>
  43 #endif
  44 #ifdef HAVE_UNISTD_H
  45 #include <unistd.h>
  46 #endif
  47 #include <errno.h>
  48 #include <stdarg.h>
  49
  50 #include <windows.h>
  51 #include <shlobj.h>
  52 #include <objidl.h>
  53 #include <shlguid.h>
  54
  55 #include "wine/debug.h"
  56 #include "wine.xpm"
  57
  58 WINE_DEFAULT_DEBUG_CHANNEL(menubuilder);
  59
  60 /* link file formats */
  61
  62 #include "pshpack1.h"
  63
  64 typedef struct
  65 {
  66     BYTE bWidth;
  67     BYTE bHeight;
  68     BYTE bColorCount;
  69     BYTE bReserved;
  70     WORD wPlanes;
  71     WORD wBitCount;
  72     DWORD dwBytesInRes;
  73     WORD nID;
  74 } GRPICONDIRENTRY;
  75
  76 typedef struct
  77 {
  78     WORD idReserved;
  79     WORD idType;
  80     WORD idCount;
  81     GRPICONDIRENTRY idEntries[1];
  82 } GRPICONDIR;
  83
  84 typedef struct
  85 {
  86     BYTE bWidth;
  87     BYTE bHeight;
  88     BYTE bColorCount;
  89     BYTE bReserved;
  90     WORD wPlanes;
  91     WORD wBitCount;
  92     DWORD dwBytesInRes;
  93     DWORD dwImageOffset;
  94 } ICONDIRENTRY;
  95
  96 typedef struct
  97 {
  98     WORD idReserved;
  99     WORD idType;
 100     WORD idCount;
 101 } ICONDIR;
 102
 103
 104 #include "poppack.h"
 105
 106 typedef struct
 107 {
 108         HRSRC *pResInfo;
 109         int   nIndex;
 110 } ENUMRESSTRUCT;
 111
 112
 113 /* Icon extraction routines
 114  *
 115  * FIXME: should use PrivateExtractIcons and friends
 116  * FIXME: should not use stdio
 117  */
 118
 119 static BOOL SaveIconResAsXPM(const BITMAPINFO *pIcon, const char *szXPMFileName, const char *comment)
 120 {
 121     FILE *fXPMFile;
 122     int nHeight;
 123     int nXORWidthBytes;
 124     int nANDWidthBytes;
 125     BOOL b8BitColors;
 126     int nColors;
 127     BYTE *pXOR;
 128     BYTE *pAND;
 129     BOOL aColorUsed[256] = {0};
 130     int nColorsUsed = 0;
 131     int i,j;
 132
 133     if (!((pIcon->bmiHeader.biBitCount == 4) || (pIcon->bmiHeader.biBitCount == 8)))
 134         return FALSE;
 135
 136     if (!(fXPMFile = fopen(szXPMFileName, "w")))
 137         return FALSE;
 138
 139     nHeight = pIcon->bmiHeader.biHeight / 2;
 140     nXORWidthBytes = 4 * ((pIcon->bmiHeader.biWidth * pIcon->bmiHeader.biBitCount / 32)
 141                           + ((pIcon->bmiHeader.biWidth * pIcon->bmiHeader.biBitCount % 32) > 0));
 142     nANDWidthBytes = 4 * ((pIcon->bmiHeader.biWidth / 32)
 143                           + ((pIcon->bmiHeader.biWidth % 32) > 0));
 144     b8BitColors = pIcon->bmiHeader.biBitCount == 8;
 145     nColors = pIcon->bmiHeader.biClrUsed ? pIcon->bmiHeader.biClrUsed
 146         : 1 << pIcon->bmiHeader.biBitCount;
 147     pXOR = (BYTE*) pIcon + sizeof (BITMAPINFOHEADER) + (nColors * sizeof (RGBQUAD));
 148     pAND = pXOR + nHeight * nXORWidthBytes;
 149
 150 #define MASK(x,y) (pAND[(x) / 8 + (nHeight - (y) - 1) * nANDWidthBytes] & (1 << (7 - (x) % 8)))
 151 #define COLOR(x,y) (b8BitColors ? pXOR[(x) + (nHeight - (y) - 1) * nXORWidthBytes] : (x) % 2 ? pXOR[(x) / 2 + (nHeight - (y) - 1) * nXORWidthBytes] & 0xF : (pXOR[(x) / 2 + (nHeight - (y) - 1) * nXORWidthBytes] & 0xF0) >> 4)
 152
 153     for (i = 0; i < nHeight; i++) {
 154         for (j = 0; j < pIcon->bmiHeader.biWidth; j++) {
 155             if (!aColorUsed[COLOR(j,i)] && !MASK(j,i))
 156             {
 157                 aColorUsed[COLOR(j,i)] = TRUE;
 158                 nColorsUsed++;
 159             }
 160         }
 161     }
 162
 163     if (fprintf(fXPMFile, "/* XPM */\n/* %s */\nstatic char *icon[] = {\n", comment) <= 0)
 164         goto error;
 165     if (fprintf(fXPMFile, "\"%d %d %d %d\",\n",
 166                 (int) pIcon->bmiHeader.biWidth, nHeight, nColorsUsed + 1, 2) <=0)
 167         goto error;
 168
 169     for (i = 0; i < nColors; i++) {
 170         if (aColorUsed[i])
 171             if (fprintf(fXPMFile, "\"%.2X c #%.2X%.2X%.2X\",\n", i, pIcon->bmiColors[i].rgbRed,
 172                         pIcon->bmiColors[i].rgbGreen, pIcon->bmiColors[i].rgbBlue) <= 0)
 173                 goto error;
 174     }
 175     if (fprintf(fXPMFile, "\"   c None\"") <= 0)
 176         goto error;
 177
 178     for (i = 0; i < nHeight; i++)
 179     {
 180         if (fprintf(fXPMFile, ",\n\"") <= 0)
 181             goto error;
 182         for (j = 0; j < pIcon->bmiHeader.biWidth; j++)
 183         {
 184             if MASK(j,i)
 185                 {
 186                     if (fprintf(fXPMFile, "  ") <= 0)
 187                         goto error;
 188                 }
 189             else
 190                 if (fprintf(fXPMFile, "%.2X", COLOR(j,i)) <= 0)
 191                     goto error;
 192         }
 193         if (fprintf(fXPMFile, "\"") <= 0)
 194             goto error;
 195     }
 196     if (fprintf(fXPMFile, "};\n") <= 0)
 197         goto error;
 198
 199 #undef MASK
 200 #undef COLOR
 201
 202     fclose(fXPMFile);
 203     return TRUE;
 204
 205  error:
 206     fclose(fXPMFile);
 207     unlink( szXPMFileName );
 208     return FALSE;
 209 }
 210
 211 static BOOL CALLBACK EnumResNameProc(HMODULE hModule, LPCSTR lpszType, LPSTR lpszName, LONG lParam)
 212 {
 213     ENUMRESSTRUCT *sEnumRes = (ENUMRESSTRUCT *) lParam;
 214
 215     if (!sEnumRes->nIndex--)
 216     {
 217       *sEnumRes->pResInfo = FindResourceA(hModule, lpszName, (LPSTR)RT_GROUP_ICON);
 218       return FALSE;
 219     }
 220     else
 221       return TRUE;
 222 }
 223
 224 static BOOL ExtractFromEXEDLL(const char *szFileName, int nIndex, const char *szXPMFileName)
 225 {
 226     HMODULE hModule;
 227     HRSRC hResInfo;
 228     char *lpName = NULL;
 229     HGLOBAL hResData;
 230     GRPICONDIR *pIconDir;
 231     BITMAPINFO *pIcon;
 232     ENUMRESSTRUCT sEnumRes;
 233     int nMax = 0;
 234     int nMaxBits = 0;
 235     int i;
 236
 237     if (!(hModule = LoadLibraryExA(szFileName, 0, LOAD_LIBRARY_AS_DATAFILE)))
 238     {
 239         WINE_ERR("LoadLibraryExA (%s) failed, error %ld\n", szFileName, GetLastError());
 240         goto error1;
 241     }
 242
 243     if (nIndex < 0)
 244     {
 245         hResInfo = FindResourceA(hModule, MAKEINTRESOURCEA(-nIndex), (LPSTR)RT_GROUP_ICON);
 246         WINE_ERR("FindResourceA (%s) called, return %p, error %ld\n", szFileName, hResInfo, GetLastError());
 247     }
 248     else
 249     {
 250         hResInfo=NULL;
 251         sEnumRes.pResInfo = &hResInfo;
 252         sEnumRes.nIndex = nIndex;
 253         EnumResourceNamesA(hModule, (LPSTR)RT_GROUP_ICON, &EnumResNameProc, (LONG) &sEnumRes);
 254     }
 255
 256     if (!hResInfo)
 257     {
 258         WINE_ERR("ExtractFromEXEDLL failed, error %ld\n", GetLastError());
 259         goto error2;
 260     }
 261
 262     if (!(hResData = LoadResource(hModule, hResInfo)))
 263     {
 264         WINE_ERR("LoadResource failed, error %ld\n", GetLastError());
 265         goto error2;
 266     }
 267     if (!(pIconDir = LockResource(hResData)))
 268     {
 269         WINE_ERR("LockResource failed, error %ld\n", GetLastError());
 270         goto error3;
 271     }
 272
 273     for (i = 0; i < pIconDir->idCount; i++)
 274         if ((pIconDir->idEntries[i].wBitCount >= nMaxBits) && (pIconDir->idEntries[i].wBitCount <= 8))
 275         {
 276           if (pIconDir->idEntries[i].wBitCount > nMaxBits)
 277           {
 278               nMaxBits = pIconDir->idEntries[i].wBitCount;
 279               nMax = 0;
 280           }
 281           if ((pIconDir->idEntries[i].bHeight * pIconDir->idEntries[i].bWidth) > nMax)
 282           {
 283               lpName = MAKEINTRESOURCEA(pIconDir->idEntries[i].nID);
 284               nMax = pIconDir->idEntries[i].bHeight * pIconDir->idEntries[i].bWidth;
 285           }
 286         }
 287
 288     FreeResource(hResData);
 289
 290     if (!(hResInfo = FindResourceA(hModule, lpName, (LPSTR)RT_ICON)))
 291     {
 292         WINE_ERR("Second FindResourceA failed, error %ld\n", GetLastError());
 293         goto error2;
 294     }
 295     if (!(hResData = LoadResource(hModule, hResInfo)))
 296     {
 297         WINE_ERR("Second LoadResource failed, error %ld\n", GetLastError());
 298         goto error2;
 299     }
 300     if (!(pIcon = LockResource(hResData)))
 301     {
 302         WINE_ERR("Second LockResource failed, error %ld\n", GetLastError());
 303         goto error3;
 304     }
 305
 306     if(!SaveIconResAsXPM(pIcon, szXPMFileName, szFileName))
 307     {
 308         WINE_ERR("Failed saving icon as XPM, error %ld\n", GetLastError());
 309         goto error3;
 310     }
 311
 312     FreeResource(hResData);
 313     FreeLibrary(hModule);
 314
 315     return TRUE;
 316
 317  error3:
 318     FreeResource(hResData);
 319  error2:
 320     FreeLibrary(hModule);
 321  error1:
 322     return FALSE;
 323 }
 324
 325 /* get the Unix file name for a given path, allocating the string */
 326 inline static char *get_unix_file_name( const char *dos )
 327 {
 328     WCHAR dosW[MAX_PATH];
 329
 330     MultiByteToWideChar(CP_ACP, 0, dos, -1, dosW, MAX_PATH);
 331     return wine_get_unix_file_name( dosW );
 332 }
 333
 334 static int ExtractFromICO(const char *szFileName, const char *szXPMFileName)
 335 {
 336     FILE *fICOFile;
 337     ICONDIR iconDir;
 338     ICONDIRENTRY *pIconDirEntry;
 339     int nMax = 0;
 340     int nIndex = 0;
 341     void *pIcon;
 342     int i;
 343     char *filename;
 344
 345     filename = get_unix_file_name(szFileName);
 346     if (!(fICOFile = fopen(filename, "r")))
 347         goto error1;
 348
 349     if (fread(&iconDir, sizeof (ICONDIR), 1, fICOFile) != 1)
 350         goto error2;
 351     if ((iconDir.idReserved != 0) || (iconDir.idType != 1))
 352         goto error2;
 353
 354     if ((pIconDirEntry = malloc(iconDir.idCount * sizeof (ICONDIRENTRY))) == NULL)
 355         goto error2;
 356     if (fread(pIconDirEntry, sizeof (ICONDIRENTRY), iconDir.idCount, fICOFile) != iconDir.idCount)
 357         goto error3;
 358
 359     for (i = 0; i < iconDir.idCount; i++)
 360         if ((pIconDirEntry[i].bHeight * pIconDirEntry[i].bWidth) > nMax)
 361         {
 362             nIndex = i;
 363             nMax = pIconDirEntry[i].bHeight * pIconDirEntry[i].bWidth;
 364         }
 365     if ((pIcon = malloc(pIconDirEntry[nIndex].dwBytesInRes)) == NULL)
 366         goto error3;
 367     if (fseek(fICOFile, pIconDirEntry[nIndex].dwImageOffset, SEEK_SET))
 368         goto error4;
 369     if (fread(pIcon, pIconDirEntry[nIndex].dwBytesInRes, 1, fICOFile) != 1)
 370         goto error4;
 371
 372     if(!SaveIconResAsXPM(pIcon, szXPMFileName, szFileName))
 373         goto error4;
 374
 375     free(pIcon);
 376     free(pIconDirEntry);
 377     fclose(fICOFile);
 378
 379     return 1;
 380
 381  error4:
 382     free(pIcon);
 383  error3:
 384     free(pIconDirEntry);
 385  error2:
 386     fclose(fICOFile);
 387  error1:
 388     HeapFree(GetProcessHeap(), 0, filename);
 389     return 0;
 390 }
 391
 392 static BOOL create_default_icon( const char *filename, const char* comment )
 393 {
 394     FILE *fXPM;
 395     int i;
 396
 397     if (!(fXPM = fopen(filename, "w"))) return FALSE;
 398     if (fprintf(fXPM, "/* XPM */\n/* %s */\nstatic char * icon[] = {", comment) <= 0)
 399         goto error;
 400     for (i = 0; i < sizeof(wine_xpm)/sizeof(wine_xpm[0]); i++) {
 401         if (fprintf( fXPM, "\n\"%s\",", wine_xpm[i]) <= 0)
 402             goto error;
 403     }
 404     if (fprintf( fXPM, "};\n" ) <=0)
 405         goto error;
 406     fclose( fXPM );
 407     return TRUE;
 408  error:
 409     fclose( fXPM );
 410     unlink( filename );
 411     return FALSE;
 412
 413 }
 414
 415 static unsigned short crc16(const char* string)
 416 {
 417     unsigned short crc = 0;
 418     int i, j, xor_poly;
 419
 420     for (i = 0; string[i] != 0; i++)
 421     {
 422         char c = string[i];
 423         for (j = 0; j < 8; c >>= 1, j++)
 424         {
 425             xor_poly = (c ^ crc) & 1;
 426             crc >>= 1;
 427             if (xor_poly)
 428                 crc ^= 0xa001;
 429         }
 430     }
 431     return crc;
 432 }
 433
 434 /* extract an icon from an exe or icon file; helper for IPersistFile_fnSave */
 435 static char *extract_icon( const char *path, int index)
 436 {
 437     int nodefault = 1;
 438     unsigned short crc;
 439     char *iconsdir, *ico_path, *ico_name, *xpm_path;
 440     char* s;
 441     HKEY hkey;
 442
 443     /* Where should we save the icon? */
 444     WINE_TRACE("path=[%s] index=%d\n",path,index);
 445     iconsdir=NULL;  /* Default is no icon */
 446     if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\Wine", &hkey ))
 447     {
 448         DWORD size = 0;
 449         if (RegQueryValueExA(hkey, "IconsDir", 0, NULL, NULL, &size)==0) {
 450             iconsdir = HeapAlloc(GetProcessHeap(), 0, size);
 451             RegQueryValueExA(hkey, "IconsDir", 0, NULL, iconsdir, &size);
 452
 453             s=get_unix_file_name(iconsdir);
 454             if (s) {
 455                 HeapFree(GetProcessHeap(), 0, iconsdir);
 456                 iconsdir=s;
 457             }
 458         }
 459         RegCloseKey( hkey );
 460     }
 461     if (iconsdir==NULL || *iconsdir=='\0')
 462     {
 463         if (iconsdir)
 464             HeapFree(GetProcessHeap(), 0, iconsdir);
 465         return NULL;  /* No icon created */
 466     }
 467
 468     /* If icon path begins with a '*' then this is a deferred call */
 469     if (path[0] == '*')
 470     {
 471         path++;
 472         nodefault = 0;
 473     }
 474
 475     /* Determine the icon base name */
 476     ico_path=HeapAlloc(GetProcessHeap(), 0, lstrlenA(path)+1);
 477     strcpy(ico_path, path);
 478     s=ico_name=ico_path;
 479     while (*s!='\0') {
 480         if (*s=='/' || *s=='\\') {
 481             *s='\\';
 482             ico_name=s;
 483         } else {
 484             *s=tolower(*s);
 485         }
 486         s++;
 487     }
 488     if (*ico_name=='\\') *ico_name++='\0';
 489     s=strrchr(ico_name,'.');
 490     if (s) *s='\0';
 491
 492     /* Compute the source-path hash */
 493     crc=crc16(ico_path);
 494
 495     /* Try to treat the source file as an exe */
 496     xpm_path=HeapAlloc(GetProcessHeap(), 0, strlen(iconsdir)+1+4+1+strlen(ico_name)+1+12+1+3);
 497     sprintf(xpm_path,"%s/%04x_%s.%d.xpm",iconsdir,crc,ico_name,index);
 498     if (ExtractFromEXEDLL( path, index, xpm_path ))
 499         goto end;
 500
 501     /* Must be something else, ignore the index in that case */
 502     sprintf(xpm_path,"%s/%04x_%s.xpm",iconsdir,crc,ico_name);
 503     if (ExtractFromICO( path, xpm_path))
 504         goto end;
 505     if (!nodefault)
 506         if (create_default_icon( xpm_path, path ))
 507             goto end;
 508
 509     HeapFree( GetProcessHeap(), 0, xpm_path );
 510     xpm_path=NULL;
 511
 512  end:
 513     HeapFree( GetProcessHeap(), 0, ico_path );
 514     return xpm_path;
 515 }
 516
 517 static BOOL DeferToRunOnce(LPWSTR link)
 518 {
 519     HKEY hkey;
 520     LONG r, len;
 521     static const WCHAR szRunOnce[] = {
 522         'S','o','f','t','w','a','r','e','\\',
 523         'M','i','c','r','o','s','o','f','t','\\',
 524         'W','i','n','d','o','w','s','\\',
 525         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 526         'R','u','n','O','n','c','e',0
 527     };
 528     static const WCHAR szFormat[] = { '%','s',' ','"','%','s','"',0 };
 529     LPWSTR buffer;
 530     WCHAR szExecutable[MAX_PATH];
 531
 532     WINE_TRACE( "Deferring icon creation to reboot.\n");
 533
 534     if( !GetModuleFileNameW( 0, szExecutable, MAX_PATH ) )
 535         return FALSE;
 536
 537     len = ( lstrlenW( link ) + lstrlenW( szExecutable ) + 4)*sizeof(WCHAR);
 538     buffer = HeapAlloc( GetProcessHeap(), 0, len );
 539     if( !buffer )
 540         return FALSE;
 541
 542     wsprintfW( buffer, szFormat, szExecutable, link );
 543
 544     r = RegCreateKeyExW(HKEY_LOCAL_MACHINE, szRunOnce, 0,
 545               NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
 546     if ( r == ERROR_SUCCESS )
 547     {
 548         r = RegSetValueExW(hkey, link, 0, REG_SZ,
 549                    (LPBYTE) buffer, (lstrlenW(buffer) + 1)*sizeof(WCHAR));
 550         RegCloseKey(hkey);
 551     }
 552     HeapFree(GetProcessHeap(), 0, buffer);
 553
 554     return ! r;
 555 }
 556
 557 /* This escapes \ in filenames */
 558 static LPSTR
 559 escape(LPCSTR arg) {
 560     LPSTR      narg, x;
 561
 562     narg = HeapAlloc(GetProcessHeap(),0,2*strlen(arg)+2);
 563     x = narg;
 564     while (*arg) {
 565         *x++ = *arg;
 566         if (*arg == '\\')
 567             *x++='\\'; /* escape \ */
 568         arg++;
 569     }
 570     *x = 0;
 571     return narg;
 572 }
 573
 574 static int fork_and_wait( char *linker, char *link_name, char *path,
 575                           int desktop, char *args, char *icon_name,
 576                           char *workdir, char *description )
 577 {
 578     int pos = 0;
 579     const char *argv[20];
 580     int retcode;
 581
 582     WINE_TRACE( "linker app='%s' link='%s' mode=%s "
 583         "path='%s' args='%s' icon='%s' workdir='%s' descr='%s'\n",
 584         linker, link_name, desktop ? "desktop" : "menu",
 585         path, args, icon_name, workdir, description  );
 586
 587     argv[pos++] = linker ;
 588     argv[pos++] = "--link";
 589     argv[pos++] = link_name;
 590     argv[pos++] = "--path";
 591     argv[pos++] = path;
 592     argv[pos++] = desktop ? "--desktop" : "--menu";
 593     if (args && strlen(args))
 594     {
 595         argv[pos++] = "--args";
 596         argv[pos++] = args;
 597     }
 598     if (icon_name)
 599     {
 600         argv[pos++] = "--icon";
 601         argv[pos++] = icon_name;
 602     }
 603     if (workdir && strlen(workdir))
 604     {
 605         argv[pos++] = "--workdir";
 606         argv[pos++] = workdir;
 607     }
 608     if (description && strlen(description))
 609     {
 610         argv[pos++] = "--descr";
 611         argv[pos++] = description;
 612     }
 613     argv[pos] = NULL;
 614
 615     retcode=spawnvp( _P_WAIT, linker, argv );
 616     if (retcode!=0)
 617         WINE_ERR("%s returned %d\n",linker,retcode);
 618     return retcode;
 619 }
 620
 621 /* write the name of the ShellLinker into the buffer provided */
 622 static BOOL GetLinkerName( LPSTR szLinker, DWORD max )
 623 {
 624     LONG r;
 625     DWORD type = 0;
 626     HKEY hkey;
 627
 628     szLinker[0] = 0;
 629     r = RegOpenKeyExA( HKEY_LOCAL_MACHINE,
 630                         "Software\\Wine\\Wine\\Config\\Wine",
 631                         0, KEY_ALL_ACCESS, &hkey );
 632     if( r )
 633         return FALSE;
 634     r = RegQueryValueExA( hkey, "ShellLinker", 0, &type, szLinker, &max );
 635     RegCloseKey( hkey );
 636     if( r || ( type != REG_SZ ) )
 637         return FALSE;
 638
 639     return TRUE ;
 640 }
 641
 642 static char *cleanup_link( LPCWSTR link )
 643 {
 644     char  *p, *link_name;
 645     int len;
 646
 647     /* make link name a Unix name -
 648        strip leading slashes & remove extension */
 649     while ( (*link == '\\') || (*link == '/' ) )
 650         link++;
 651     len = WideCharToMultiByte( CP_ACP, 0, link, -1, NULL, 0, NULL, NULL);
 652     link_name = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
 653     if( ! link_name )
 654         return link_name;
 655     len = WideCharToMultiByte( CP_ACP, 0, link, -1, link_name, len, NULL, NULL);
 656     for (p = link_name; *p; p++)
 657         if (*p == '\\')
 658              *p = '/';
 659     p = strrchr( link_name, '.' );
 660     if (p)
 661         *p = 0;
 662     return link_name;
 663 }
 664
 665 /***********************************************************************
 666  *
 667  *           GetLinkLocation
 668  *
 669  * returns TRUE if successful
 670  * *loc will contain CS_DESKTOPDIRECTORY, CS_STARTMENU, CS_STARTUP
 671  */
 672 static BOOL GetLinkLocation( LPCWSTR linkfile, DWORD *ofs, DWORD *loc )
 673 {
 674     WCHAR ch, filename[MAX_PATH], buffer[MAX_PATH];
 675     DWORD len, i, r;
 676     const DWORD locations[] = {
 677         CSIDL_STARTUP, CSIDL_DESKTOPDIRECTORY, CSIDL_STARTMENU };
 678
 679     if( !GetFullPathNameW( linkfile, MAX_PATH, filename, NULL ))
 680         return FALSE;
 681
 682     for( i=0; i<sizeof(locations)/sizeof(locations[0]); i++ )
 683     {
 684         if (!SHGetSpecialFolderPathW( 0, buffer, locations[i], FALSE ))
 685             continue;
 686
 687         len = lstrlenW(buffer);
 688         if( len >= MAX_PATH )
 689             continue;
 690
 691         /* do a lstrcmpinW */
 692         ch = filename[len];
 693         filename[len] = 0;
 694         r = lstrcmpiW( filename, buffer );
 695         filename[len] = ch;
 696
 697         if ( r )
 698             continue;
 699
 700         /* return the remainder of the string and link type */
 701         *ofs = len;
 702         *loc = locations[i];
 703         return TRUE;
 704     }
 705
 706     return FALSE;
 707 }
 708
 709 static BOOL InvokeShellLinker( IShellLinkA *sl, LPCWSTR link )
 710 {
 711     char *link_name, *p, *icon_name = NULL, *work_dir = NULL;
 712     char *escaped_path = NULL, *escaped_args = NULL;
 713     CHAR szDescription[MAX_PATH], szPath[MAX_PATH], szWorkDir[MAX_PATH];
 714     CHAR szArgs[MAX_PATH], szIconPath[MAX_PATH], szLinker[MAX_PATH];
 715     int iIconId = 0, r;
 716     DWORD ofs=0, csidl= -1;
 717
 718     if ( !link )
 719     {
 720         WINE_ERR("Link name is null\n");
 721         return FALSE;
 722     }
 723
 724     if( !GetLinkerName( szLinker, MAX_PATH ) )
 725     {
 726         WINE_ERR("Can't find the name of the linker script\n");
 727         return FALSE;
 728     }
 729
 730     if( !GetLinkLocation( link, &ofs, &csidl ) )
 731     {
 732         WINE_WARN("Unknown link location (%08lx). Ignoring\n", csidl);
 733         return TRUE;
 734     }
 735     if( (csidl != CSIDL_DESKTOPDIRECTORY) && (csidl != CSIDL_STARTMENU) )
 736     {
 737         WINE_WARN("Not under desktop or start menu. Ignoring.\n");
 738         return TRUE;
 739     }
 740
 741     szWorkDir[0]=0;
 742     IShellLinkA_GetWorkingDirectory( sl, szWorkDir, sizeof(szWorkDir));
 743     WINE_TRACE("workdir    : %s\n", szWorkDir);
 744
 745     szDescription[0] = 0;
 746     IShellLinkA_GetDescription( sl, szDescription, sizeof(szDescription));
 747     WINE_TRACE("description: %s\n", szDescription);
 748
 749     szPath[0] = 0;
 750     IShellLinkA_GetPath( sl, szPath, sizeof(szPath), NULL, SLGP_RAWPATH );
 751     WINE_TRACE("path       : %s\n", szPath);
 752
 753     szArgs[0] = 0;
 754     IShellLinkA_GetArguments( sl, szArgs, sizeof(szArgs) );
 755     WINE_TRACE("args       : %s\n", szArgs);
 756
 757     szIconPath[0] = 0;
 758     IShellLinkA_GetIconLocation( sl, szIconPath,
 759                         sizeof(szIconPath), &iIconId );
 760     WINE_TRACE("icon file  : %s\n", szIconPath );
 761
 762     if( !szPath[0] )
 763     {
 764         LPITEMIDLIST pidl = NULL;
 765         IShellLinkA_GetIDList( sl, &pidl );
 766         if( pidl && SHGetPathFromIDListA( pidl, szPath ) );
 767             WINE_TRACE("pidl path  : %s\n", szPath );
 768     }
 769
 770     /* extract the icon */
 771     if( szIconPath[0] )
 772         icon_name = extract_icon( szIconPath , iIconId );
 773     else
 774         icon_name = extract_icon( szPath, iIconId );
 775
 776     /* fail - try once again at reboot time */
 777     if( !icon_name )
 778     {
 779         WINE_ERR("failed to extract icon.\n");
 780         return FALSE;
 781     }
 782
 783     /* check the path */
 784     if( szPath[0] )
 785     {
 786         /* check for .exe extension */
 787         if (!(p = strrchr( szPath, '.' ))) return FALSE;
 788         if (strchr( p, '\\' ) || strchr( p, '/' )) return FALSE;
 789         if (strcasecmp( p, ".exe" )) return FALSE;
 790
 791         /* convert app working dir */
 792         if (szWorkDir[0])
 793             work_dir = get_unix_file_name( szWorkDir );
 794     }
 795     else
 796     {
 797         /* if there's no path... try run the link itself */
 798         WideCharToMultiByte( CP_ACP, 0, link, -1, szArgs, MAX_PATH, NULL, NULL );
 799         strcpy(szPath, "C:\\Windows\\System\\start.exe");
 800     }
 801
 802     link_name = cleanup_link( &link[ofs] );
 803     if( !link_name )
 804     {
 805         WINE_ERR("Couldn't clean up link name\n");
 806         return FALSE;
 807     }
 808
 809     /* escape the path and parameters */
 810     escaped_path = escape(szPath);
 811     if (szArgs)
 812         escaped_args = escape(szArgs);
 813
 814     r = fork_and_wait(szLinker, link_name, escaped_path,
 815                   (csidl == CSIDL_DESKTOPDIRECTORY), escaped_args, icon_name,
 816                    work_dir ? work_dir : "", szDescription );
 817
 818     HeapFree( GetProcessHeap(), 0, icon_name );
 819     HeapFree( GetProcessHeap(), 0, work_dir );
 820     HeapFree( GetProcessHeap(), 0, link_name );
 821     if (escaped_args)
 822         HeapFree( GetProcessHeap(), 0, escaped_args );
 823     if (escaped_path)
 824         HeapFree( GetProcessHeap(), 0, escaped_path );
 825
 826     if (r)
 827     {
 828         WINE_ERR("failed to fork and exec %s\n", szLinker );
 829         return FALSE;
 830     }
 831
 832     return TRUE;
 833 }
 834
 835
 836 static BOOL Process_Link( LPWSTR linkname, BOOL bAgain )
 837 {
 838     IShellLinkA *sl;
 839     IPersistFile *pf;
 840     HRESULT r;
 841     WCHAR fullname[MAX_PATH];
 842
 843     if( !linkname[0] )
 844     {
 845         WINE_ERR("link name missing\n");
 846         return 1;
 847     }
 848
 849     if( !GetFullPathNameW( linkname, MAX_PATH, fullname, NULL ))
 850     {
 851         WINE_ERR("couldn't get full path of link file\n");
 852         return 1;
 853     }
 854
 855     r = CoInitialize( NULL );
 856     if( FAILED( r ) )
 857     {
 858         WINE_ERR("CoInitialize failed\n");
 859         return 1;
 860     }
 861
 862     r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
 863                       &IID_IShellLink, (LPVOID *) &sl );
 864     if( FAILED( r ) )
 865     {
 866         WINE_ERR("No IID_IShellLink\n");
 867         return 1;
 868     }
 869
 870     r = IShellLinkA_QueryInterface( sl, &IID_IPersistFile, (LPVOID*) &pf );
 871     if( FAILED( r ) )
 872     {
 873         WINE_ERR("No IID_IPersistFile\n");
 874         return 1;
 875     }
 876
 877     r = IPersistFile_Load( pf, fullname, STGM_READ );
 878     if( SUCCEEDED( r ) )
 879     {
 880         /* If we something fails (eg. Couldn't extract icon)
 881          * defer this menu entry to reboot via runonce
 882          */
 883         if( ! InvokeShellLinker( sl, fullname ) && bAgain )
 884             DeferToRunOnce( fullname );
 885         else
 886             WINE_TRACE("Success.\n");
 887     }
 888
 889     IPersistFile_Release( pf );
 890     IShellLinkA_Release( sl );
 891
 892     CoUninitialize();
 893
 894     return !r;
 895 }
 896
 897
 898 static CHAR *next_token( LPSTR *p )
 899 {
 900     LPSTR token = NULL, t = *p;
 901
 902     if( !t )
 903         return NULL;
 904
 905     while( t && !token )
 906     {
 907         switch( *t )
 908         {
 909         case ' ':
 910             t++;
 911             continue;
 912         case '"':
 913             /* unquote the token */
 914             token = ++t;
 915             t = strchr( token, '"' );
 916             if( t )
 917                  *t++ = 0;
 918             break;
 919         case 0:
 920             t = NULL;
 921             break;
 922         default:
 923             token = t;
 924             t = strchr( token, ' ' );
 925             if( t )
 926                  *t++ = 0;
 927             break;
 928         }
 929     }
 930     *p = t;
 931     return token;
 932 }
 933
 934 /***********************************************************************
 935  *
 936  *           WinMain
 937  */
 938 int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE prev, LPSTR cmdline, int show)
 939 {
 940     LPSTR token = NULL, p;
 941     BOOL bAgain = FALSE;
 942     HANDLE hsem = CreateSemaphoreA( NULL, 1, 1, "winemenubuilder_semaphore");
 943     int ret = 0;
 944
 945     /* running multiple instances of wineshelllink
 946        at the same time may be dangerous */
 947     if( WAIT_OBJECT_0 != WaitForSingleObject( hsem, INFINITE ) )
 948         return FALSE;
 949
 950     for( p = cmdline; p && *p; )
 951     {
 952         token = next_token( &p );
 953         if( !token )
 954             break;
 955         if( !lstrcmpA( token, "-r" ) )
 956             bAgain = TRUE;
 957         else if( token[0] == '-' )
 958         {
 959             WINE_ERR( "unknown option %s\n",token);
 960         }
 961         else
 962         {
 963             WCHAR link[MAX_PATH];
 964
 965             MultiByteToWideChar( CP_ACP, 0, token, -1, link, sizeof(link) );
 966             if( !Process_Link( link, bAgain ) )
 967             {
 968                 WINE_ERR( "failed to build menu item for %s\n",token);
 969                 ret = 1;
 970                 break;
 971             }
 972         }
 973     }
 974
 975     ReleaseSemaphore( hsem, 1, NULL );
 976     CloseHandle( hsem );
 977
 978     return ret;
 979 }