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