misc/shell.c

   1 /*
   2  *                              Shell Library Functions
   3  *
   4  *  1998 Marcus Meissner
   5  */
   6 #include <assert.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <unistd.h>
  10 #include <ctype.h>
  11 #include "wine/winuser16.h"
  12 #include "wine/winbase16.h"
  13 #include "wine/shell16.h"
  14 #include "winerror.h"
  15 #include "file.h"
  16 #include "heap.h"
  17 #include "module.h"
  18 #include "neexe.h"
  19 #include "dlgs.h"
  20 #include "win.h"
  21 #include "cursoricon.h"
  22 #include "sysmetrics.h"
  23 #include "shellapi.h"
  24 #include "shlobj.h"
  25 #include "debug.h"
  26 #include "winreg.h"
  27 #include "imagelist.h"
  28
  29 /* .ICO file ICONDIR definitions */
  30
  31 #pragma pack(1)
  32
  33 typedef struct
  34 {
  35     BYTE        bWidth;          /* Width, in pixels, of the image      */
  36     BYTE        bHeight;         /* Height, in pixels, of the image     */
  37     BYTE        bColorCount;     /* Number of colors in image (0 if >=8bpp) */
  38     BYTE        bReserved;       /* Reserved ( must be 0)               */
  39     WORD        wPlanes;         /* Color Planes                        */
  40     WORD        wBitCount;       /* Bits per pixel                      */
  41     DWORD       dwBytesInRes;    /* How many bytes in this resource?    */
  42     DWORD       dwImageOffset;   /* Where in the file is this image?    */
  43 } icoICONDIRENTRY, *LPicoICONDIRENTRY;
  44
  45 typedef struct
  46 {
  47     WORD            idReserved;   /* Reserved (must be 0)               */
  48     WORD            idType;       /* Resource Type (1 for icons)        */
  49     WORD            idCount;      /* How many images?                   */
  50     icoICONDIRENTRY idEntries[1]; /* An entry for each image (idCount of 'em) */
  51 } icoICONDIR, *LPicoICONDIR;
  52
  53 #pragma pack(4)
  54
  55 static const char*      lpstrMsgWndCreated = "OTHERWINDOWCREATED";
  56 static const char*      lpstrMsgWndDestroyed = "OTHERWINDOWDESTROYED";
  57 static const char*      lpstrMsgShellActivate = "ACTIVATESHELLWINDOW";
  58
  59 static HWND16   SHELL_hWnd = 0;
  60 static HHOOK    SHELL_hHook = 0;
  61 static UINT16   uMsgWndCreated = 0;
  62 static UINT16   uMsgWndDestroyed = 0;
  63 static UINT16   uMsgShellActivate = 0;
  64
  65 /*************************************************************************
  66  *                              DragAcceptFiles32               [SHELL32.54]
  67  */
  68 void WINAPI DragAcceptFiles32(HWND32 hWnd, BOOL32 b)
  69 {
  70   WND* wnd = WIN_FindWndPtr(hWnd);
  71
  72   if( wnd )
  73     wnd->dwExStyle = b? wnd->dwExStyle | WS_EX_ACCEPTFILES
  74                       : wnd->dwExStyle & ~WS_EX_ACCEPTFILES;
  75 }
  76
  77 /*************************************************************************
  78  *                              DragAcceptFiles16               [SHELL.9]
  79  */
  80 void WINAPI DragAcceptFiles16(HWND16 hWnd, BOOL16 b)
  81 {
  82   DragAcceptFiles32(hWnd, b);
  83 }
  84
  85 /*************************************************************************
  86  *                              SHELL_DragQueryFile     [internal]
  87  *
  88  */
  89 static UINT32 SHELL_DragQueryFile(LPSTR lpDrop, LPWSTR lpwDrop, UINT32 lFile,
  90                                   LPSTR lpszFile, LPWSTR lpszwFile, UINT32 lLength)
  91 {
  92     UINT32 i;
  93
  94     i = 0;
  95     if (lpDrop) {
  96     while (i++ < lFile) {
  97         while (*lpDrop++); /* skip filename */
  98         if (!*lpDrop)
  99           return (lFile == 0xFFFFFFFF) ? i : 0;
 100       }
 101     }
 102     if (lpwDrop) {
 103       while (i++ < lFile) {
 104         while (*lpwDrop++); /* skip filename */
 105         if (!*lpwDrop)
 106           return (lFile == 0xFFFFFFFF) ? i : 0;
 107       }
 108     }
 109
 110     if (lpDrop)  i = lstrlen32A(lpDrop);
 111     if (lpwDrop) i = lstrlen32W(lpwDrop);
 112     i++;
 113     if (!lpszFile && !lpszwFile) {
 114       return i;   /* needed buffer size */
 115     }
 116     i = (lLength > i) ? i : lLength;
 117     if (lpszFile) {
 118       if (lpDrop) lstrcpyn32A (lpszFile,  lpDrop,  i);
 119       else        lstrcpynWtoA(lpszFile,  lpwDrop, i);
 120     } else {
 121       if (lpDrop) lstrcpynAtoW(lpszwFile, lpDrop,  i);
 122       else        lstrcpyn32W (lpszwFile, lpwDrop, i);
 123     }
 124     return i;
 125 }
 126
 127 /*************************************************************************
 128  *                              DragQueryFile32A        [SHELL32.81] [shell32.82]
 129  */
 130 UINT32 WINAPI DragQueryFile32A(HDROP32 hDrop, UINT32 lFile, LPSTR lpszFile,
 131                               UINT32 lLength)
 132 { /* hDrop is a global memory block allocated with GMEM_SHARE
 133      * with DROPFILESTRUCT as a header and filenames following
 134      * it, zero length filename is in the end */
 135
 136     LPDROPFILESTRUCT32 lpDropFileStruct;
 137     LPSTR lpCurrent;
 138     UINT32 i;
 139
 140     TRACE(shell,"(%08x, %x, %p, %u)\n", hDrop,lFile,lpszFile,lLength);
 141
 142     lpDropFileStruct = (LPDROPFILESTRUCT32) GlobalLock32(hDrop);
 143     if(!lpDropFileStruct)
 144       return 0;
 145
 146     lpCurrent = (LPSTR) lpDropFileStruct + lpDropFileStruct->lSize;
 147     i = SHELL_DragQueryFile(lpCurrent, NULL, lFile, lpszFile, NULL, lLength);
 148     GlobalUnlock32(hDrop);
 149     return i;
 150 }
 151
 152 /*************************************************************************
 153  *                              DragQueryFile32W        [shell32.133]
 154  */
 155 UINT32 WINAPI DragQueryFile32W(HDROP32 hDrop, UINT32 lFile, LPWSTR lpszwFile,
 156                               UINT32 lLength)
 157 {
 158     LPDROPFILESTRUCT32 lpDropFileStruct;
 159     LPWSTR lpwCurrent;
 160     UINT32 i;
 161
 162     TRACE(shell,"(%08x, %x, %p, %u)\n", hDrop,lFile,lpszwFile,lLength);
 163
 164     lpDropFileStruct = (LPDROPFILESTRUCT32) GlobalLock32(hDrop);
 165     if(!lpDropFileStruct)
 166       return 0;
 167
 168     lpwCurrent = (LPWSTR) lpDropFileStruct + lpDropFileStruct->lSize;
 169     i = SHELL_DragQueryFile(NULL, lpwCurrent, lFile, NULL, lpszwFile,lLength);
 170     GlobalUnlock32(hDrop);
 171     return i;
 172 }
 173 /*************************************************************************
 174  *                              DragQueryFile16         [SHELL.11]
 175  */
 176 UINT16 WINAPI DragQueryFile16(HDROP16 hDrop, WORD wFile, LPSTR lpszFile,
 177                             WORD wLength)
 178 { /* hDrop is a global memory block allocated with GMEM_SHARE
 179      * with DROPFILESTRUCT as a header and filenames following
 180      * it, zero length filename is in the end */
 181
 182     LPDROPFILESTRUCT16 lpDropFileStruct;
 183     LPSTR lpCurrent;
 184     WORD  i;
 185
 186     TRACE(shell,"(%04x, %x, %p, %u)\n", hDrop,wFile,lpszFile,wLength);
 187
 188     lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop);
 189     if(!lpDropFileStruct)
 190       return 0;
 191
 192     lpCurrent = (LPSTR) lpDropFileStruct + lpDropFileStruct->wSize;
 193
 194     i = (WORD)SHELL_DragQueryFile(lpCurrent, NULL, wFile==0xffff?0xffffffff:wFile,
 195                                   lpszFile, NULL, wLength);
 196     GlobalUnlock16(hDrop);
 197     return i;
 198 }
 199
 200
 201
 202 /*************************************************************************
 203  *                              DragFinish32            [SHELL32.80]
 204  */
 205 void WINAPI DragFinish32(HDROP32 h)
 206 { TRACE(shell,"\n");
 207     GlobalFree32((HGLOBAL32)h);
 208 }
 209
 210 /*************************************************************************
 211  *                              DragFinish16            [SHELL.12]
 212  */
 213 void WINAPI DragFinish16(HDROP16 h)
 214 { TRACE(shell,"\n");
 215     GlobalFree16((HGLOBAL16)h);
 216 }
 217
 218
 219 /*************************************************************************
 220  *                              DragQueryPoint32                [SHELL32.135]
 221  */
 222 BOOL32 WINAPI DragQueryPoint32(HDROP32 hDrop, POINT32 *p)
 223 {
 224   LPDROPFILESTRUCT32 lpDropFileStruct;
 225   BOOL32             bRet;
 226   TRACE(shell,"\n");
 227   lpDropFileStruct = (LPDROPFILESTRUCT32) GlobalLock32(hDrop);
 228
 229   memcpy(p,&lpDropFileStruct->ptMousePos,sizeof(POINT32));
 230   bRet = lpDropFileStruct->fInNonClientArea;
 231
 232   GlobalUnlock32(hDrop);
 233   return bRet;
 234 }
 235
 236 /*************************************************************************
 237  *                              DragQueryPoint16                [SHELL.13]
 238  */
 239 BOOL16 WINAPI DragQueryPoint16(HDROP16 hDrop, POINT16 *p)
 240 {
 241   LPDROPFILESTRUCT16 lpDropFileStruct;
 242   BOOL16           bRet;
 243   TRACE(shell,"\n");
 244   lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop);
 245
 246   memcpy(p,&lpDropFileStruct->ptMousePos,sizeof(POINT16));
 247   bRet = lpDropFileStruct->fInNonClientArea;
 248
 249   GlobalUnlock16(hDrop);
 250   return bRet;
 251 }
 252
 253 /*************************************************************************
 254  *      SHELL_FindExecutable [Internal]
 255  *
 256  * Utility for code sharing between FindExecutable and ShellExecute
 257  */
 258 HINSTANCE32 SHELL_FindExecutable( LPCSTR lpFile,
 259                                          LPCSTR lpOperation,
 260                                          LPSTR lpResult)
 261 { char *extension = NULL; /* pointer to file extension */
 262     char tmpext[5];         /* local copy to mung as we please */
 263     char filetype[256];     /* registry name for this filetype */
 264     LONG filetypelen=256;   /* length of above */
 265     char command[256];      /* command from registry */
 266     LONG commandlen=256;    /* This is the most DOS can handle :) */
 267     char buffer[256];       /* Used to GetProfileString */
 268     HINSTANCE32 retval=31;  /* default - 'No association was found' */
 269     char *tok;              /* token pointer */
 270     int i;                  /* random counter */
 271     char xlpFile[256];      /* result of SearchPath */
 272
 273   TRACE(shell, "%s\n", (lpFile != NULL?lpFile:"-") );
 274
 275     lpResult[0]='\0'; /* Start off with an empty return string */
 276
 277     /* trap NULL parameters on entry */
 278     if (( lpFile == NULL ) || ( lpResult == NULL ) || ( lpOperation == NULL ))
 279   { WARN(exec, "(lpFile=%s,lpResult=%s,lpOperation=%s): NULL parameter\n",
 280            lpFile, lpOperation, lpResult);
 281         return 2; /* File not found. Close enough, I guess. */
 282     }
 283
 284     if (SearchPath32A( NULL, lpFile,".exe",sizeof(xlpFile),xlpFile,NULL))
 285   { TRACE(shell, "SearchPath32A returned non-zero\n");
 286         lpFile = xlpFile;
 287     }
 288
 289     /* First thing we need is the file's extension */
 290     extension = strrchr( xlpFile, '.' ); /* Assume last "." is the one; */
 291                                         /* File->Run in progman uses */
 292                                         /* .\FILE.EXE :( */
 293   TRACE(shell, "xlpFile=%s,extension=%s\n", xlpFile, extension);
 294
 295     if ((extension == NULL) || (extension == &xlpFile[strlen(xlpFile)]))
 296   { WARN(shell, "Returning 31 - No association\n");
 297         return 31; /* no association */
 298     }
 299
 300     /* Make local copy & lowercase it for reg & 'programs=' lookup */
 301     lstrcpyn32A( tmpext, extension, 5 );
 302     CharLower32A( tmpext );
 303   TRACE(shell, "%s file\n", tmpext);
 304
 305     /* Three places to check: */
 306     /* 1. win.ini, [windows], programs (NB no leading '.') */
 307     /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */
 308     /* 3. win.ini, [extensions], extension (NB no leading '.' */
 309     /* All I know of the order is that registry is checked before */
 310     /* extensions; however, it'd make sense to check the programs */
 311     /* section first, so that's what happens here. */
 312
 313     /* See if it's a program - if GetProfileString fails, we skip this
 314      * section. Actually, if GetProfileString fails, we've probably
 315      * got a lot more to worry about than running a program... */
 316     if ( GetProfileString32A("windows", "programs", "exe pif bat com",
 317                                                   buffer, sizeof(buffer)) > 0 )
 318   { for (i=0;i<strlen(buffer); i++) buffer[i]=tolower(buffer[i]);
 319
 320                 tok = strtok(buffer, " \t"); /* ? */
 321                 while( tok!= NULL)
 322                   {
 323                         if (strcmp(tok, &tmpext[1])==0) /* have to skip the leading "." */
 324                           {
 325                                 strcpy(lpResult, xlpFile);
 326                                 /* Need to perhaps check that the file has a path
 327                                  * attached */
 328         TRACE(shell, "found %s\n", lpResult);
 329                                 return 33;
 330
 331                 /* Greater than 32 to indicate success FIXME According to the
 332                  * docs, I should be returning a handle for the
 333                  * executable. Does this mean I'm supposed to open the
 334                  * executable file or something? More RTFM, I guess... */
 335                           }
 336                         tok=strtok(NULL, " \t");
 337                   }
 338           }
 339
 340     /* Check registry */
 341     if (RegQueryValue16( HKEY_CLASSES_ROOT, tmpext, filetype,
 342                          &filetypelen ) == ERROR_SUCCESS )
 343     {
 344         filetype[filetypelen]='\0';
 345   TRACE(shell, "File type: %s\n", filetype);
 346
 347         /* Looking for ...buffer\shell\lpOperation\command */
 348         strcat( filetype, "\\shell\\" );
 349         strcat( filetype, lpOperation );
 350         strcat( filetype, "\\command" );
 351
 352         if (RegQueryValue16( HKEY_CLASSES_ROOT, filetype, command,
 353                              &commandlen ) == ERROR_SUCCESS )
 354         {
 355             /* Is there a replace() function anywhere? */
 356             command[commandlen]='\0';
 357             strcpy( lpResult, command );
 358             tok=strstr( lpResult, "%1" );
 359             if (tok != NULL)
 360             {
 361                 tok[0]='\0'; /* truncate string at the percent */
 362                 strcat( lpResult, xlpFile ); /* what if no dir in xlpFile? */
 363                 tok=strstr( command, "%1" );
 364                 if ((tok!=NULL) && (strlen(tok)>2))
 365                 {
 366                     strcat( lpResult, &tok[2] );
 367                 }
 368             }
 369             retval=33; /* FIXME see above */
 370         }
 371     }
 372     else /* Check win.ini */
 373     {
 374         /* Toss the leading dot */
 375         extension++;
 376         if ( GetProfileString32A( "extensions", extension, "", command,
 377                                   sizeof(command)) > 0)
 378           {
 379                 if (strlen(command)!=0)
 380                   {
 381                         strcpy( lpResult, command );
 382                         tok=strstr( lpResult, "^" ); /* should be ^.extension? */
 383                         if (tok != NULL)
 384                           {
 385                                 tok[0]='\0';
 386                                 strcat( lpResult, xlpFile ); /* what if no dir in xlpFile? */
 387                                 tok=strstr( command, "^" ); /* see above */
 388                                 if ((tok != NULL) && (strlen(tok)>5))
 389                                   {
 390                                         strcat( lpResult, &tok[5]);
 391                                   }
 392                           }
 393                         retval=33; /* FIXME - see above */
 394                   }
 395           }
 396         }
 397
 398     TRACE(shell, "returning %s\n", lpResult);
 399     return retval;
 400 }
 401
 402 /*************************************************************************
 403  *                              ShellExecute16          [SHELL.20]
 404  */
 405 HINSTANCE16 WINAPI ShellExecute16( HWND16 hWnd, LPCSTR lpOperation,
 406                                    LPCSTR lpFile, LPCSTR lpParameters,
 407                                    LPCSTR lpDirectory, INT16 iShowCmd )
 408 {   HINSTANCE16 retval=31;
 409     char old_dir[1024];
 410     char cmd[256];
 411
 412     TRACE(shell, "(%04x,'%s','%s','%s','%s',%x)\n",
 413                 hWnd, lpOperation ? lpOperation:"<null>", lpFile ? lpFile:"<null>",
 414                 lpParameters ? lpParameters : "<null>",
 415                 lpDirectory ? lpDirectory : "<null>", iShowCmd);
 416
 417     if (lpFile==NULL) return 0; /* should not happen */
 418     if (lpOperation==NULL) /* default is open */
 419       lpOperation="open";
 420
 421     if (lpDirectory)
 422     { GetCurrentDirectory32A( sizeof(old_dir), old_dir );
 423         SetCurrentDirectory32A( lpDirectory );
 424     }
 425
 426     retval = SHELL_FindExecutable( lpFile, lpOperation, cmd );
 427
 428     if (retval > 32)  /* Found */
 429     { if (lpParameters)
 430       { strcat(cmd," ");
 431             strcat(cmd,lpParameters);
 432         }
 433
 434       TRACE(shell,"starting %s\n",cmd);
 435         retval = WinExec32( cmd, iShowCmd );
 436     }
 437     if (lpDirectory)
 438       SetCurrentDirectory32A( old_dir );
 439     return retval;
 440 }
 441
 442 /*************************************************************************
 443  *             FindExecutable16   (SHELL.21)
 444  */
 445 HINSTANCE16 WINAPI FindExecutable16( LPCSTR lpFile, LPCSTR lpDirectory,
 446                                      LPSTR lpResult )
 447 { return (HINSTANCE16)FindExecutable32A( lpFile, lpDirectory, lpResult );
 448 }
 449
 450
 451 /*************************************************************************
 452  *             AboutDlgProc16   (SHELL.33)
 453  */
 454 BOOL16 WINAPI AboutDlgProc16( HWND16 hWnd, UINT16 msg, WPARAM16 wParam,
 455                                LPARAM lParam )
 456 { return AboutDlgProc32( hWnd, msg, wParam, lParam );
 457 }
 458
 459
 460 /*************************************************************************
 461  *             ShellAbout16   (SHELL.22)
 462  */
 463 BOOL16 WINAPI ShellAbout16( HWND16 hWnd, LPCSTR szApp, LPCSTR szOtherStuff,
 464                             HICON16 hIcon )
 465 { return ShellAbout32A( hWnd, szApp, szOtherStuff, hIcon );
 466 }
 467
 468 /*************************************************************************
 469  *                              SHELL_GetResourceTable
 470  */
 471 static DWORD SHELL_GetResourceTable(HFILE32 hFile,LPBYTE *retptr)
 472 {       IMAGE_DOS_HEADER        mz_header;
 473         char                    magic[4];
 474         int                     size;
 475
 476         TRACE(shell,"\n");
 477
 478         *retptr = NULL;
 479         _llseek32( hFile, 0, SEEK_SET );
 480         if ((_lread32(hFile,&mz_header,sizeof(mz_header)) != sizeof(mz_header)) || (mz_header.e_magic != IMAGE_DOS_SIGNATURE))
 481         { /* .ICO file ? */
 482           if (mz_header.e_cblp == 1)
 483           { /* ICONHEADER.idType, must be 1 */
 484             *retptr = (LPBYTE)-1;
 485             return 1;
 486           }
 487           else
 488             return 0; /* failed */
 489         }
 490         _llseek32( hFile, mz_header.e_lfanew, SEEK_SET );
 491
 492         if (_lread32( hFile, magic, sizeof(magic) ) != sizeof(magic))
 493           return 0;
 494
 495         _llseek32( hFile, mz_header.e_lfanew, SEEK_SET);
 496
 497         if (*(DWORD*)magic  == IMAGE_NT_SIGNATURE)
 498           return IMAGE_NT_SIGNATURE;
 499
 500         if (*(WORD*)magic == IMAGE_OS2_SIGNATURE)
 501         { IMAGE_OS2_HEADER      ne_header;
 502           LPBYTE                pTypeInfo = (LPBYTE)-1;
 503
 504           if (_lread32(hFile,&ne_header,sizeof(ne_header))!=sizeof(ne_header))
 505             return 0;
 506
 507           if (ne_header.ne_magic != IMAGE_OS2_SIGNATURE)
 508             return 0;
 509
 510           size = ne_header.rname_tab_offset - ne_header.resource_tab_offset;
 511
 512           if( size > sizeof(NE_TYPEINFO) )
 513           { pTypeInfo = (BYTE*)HeapAlloc( GetProcessHeap(), 0, size);
 514             if( pTypeInfo )
 515             { _llseek32(hFile, mz_header.e_lfanew+ne_header.resource_tab_offset, SEEK_SET);
 516               if( _lread32( hFile, (char*)pTypeInfo, size) != size )
 517               { HeapFree( GetProcessHeap(), 0, pTypeInfo);
 518                 pTypeInfo = NULL;
 519               }
 520             }
 521           }
 522           *retptr = pTypeInfo;
 523           return IMAGE_OS2_SIGNATURE;
 524         }
 525         return 0; /* failed */
 526 }
 527
 528 /*************************************************************************
 529  *                      SHELL_LoadResource
 530  */
 531 static HGLOBAL16 SHELL_LoadResource(HINSTANCE16 hInst, HFILE32 hFile, NE_NAMEINFO* pNInfo, WORD sizeShift)
 532 {       BYTE*  ptr;
 533         HGLOBAL16 handle = DirectResAlloc( hInst, 0x10, (DWORD)pNInfo->length << sizeShift);
 534
 535         TRACE(shell,"\n");
 536
 537         if( (ptr = (BYTE*)GlobalLock16( handle )) )
 538         { _llseek32( hFile, (DWORD)pNInfo->offset << sizeShift, SEEK_SET);
 539           _lread32( hFile, (char*)ptr, pNInfo->length << sizeShift);
 540           return handle;
 541         }
 542         return 0;
 543 }
 544
 545 /*************************************************************************
 546  *                      ICO_LoadIcon
 547  */
 548 static HGLOBAL16 ICO_LoadIcon(HINSTANCE16 hInst, HFILE32 hFile, LPicoICONDIRENTRY lpiIDE)
 549 {       BYTE*  ptr;
 550         HGLOBAL16 handle = DirectResAlloc( hInst, 0x10, lpiIDE->dwBytesInRes);
 551         TRACE(shell,"\n");
 552         if( (ptr = (BYTE*)GlobalLock16( handle )) )
 553         { _llseek32( hFile, lpiIDE->dwImageOffset, SEEK_SET);
 554           _lread32( hFile, (char*)ptr, lpiIDE->dwBytesInRes);
 555           return handle;
 556         }
 557         return 0;
 558 }
 559
 560 /*************************************************************************
 561  *                      ICO_GetIconDirectory
 562  *
 563  *  Read .ico file and build phony ICONDIR struct for GetIconID
 564  */
 565 static HGLOBAL16 ICO_GetIconDirectory(HINSTANCE16 hInst, HFILE32 hFile, LPicoICONDIR* lplpiID )
 566 { WORD    id[3];  /* idReserved, idType, idCount */
 567   LPicoICONDIR  lpiID;
 568   int           i;
 569
 570   TRACE(shell,"\n");
 571   _llseek32( hFile, 0, SEEK_SET );
 572   if( _lread32(hFile,(char*)id,sizeof(id)) != sizeof(id) ) return 0;
 573
 574   /* check .ICO header
 575    *
 576    * - see http://www.microsoft.com/win32dev/ui/icons.htm
 577    */
 578
 579   if( id[0] || id[1] != 1 || !id[2] ) return 0;
 580
 581   i = id[2]*sizeof(icoICONDIRENTRY) + sizeof(id);
 582
 583   lpiID = (LPicoICONDIR)HeapAlloc( GetProcessHeap(), 0, i);
 584
 585   if( _lread32(hFile,(char*)lpiID->idEntries,i) == i )
 586   { HGLOBAL16 handle = DirectResAlloc( hInst, 0x10,
 587                                      id[2]*sizeof(ICONDIRENTRY) + sizeof(id) );
 588      if( handle )
 589     { CURSORICONDIR*     lpID = (CURSORICONDIR*)GlobalLock16( handle );
 590        lpID->idReserved = lpiID->idReserved = id[0];
 591        lpID->idType = lpiID->idType = id[1];
 592        lpID->idCount = lpiID->idCount = id[2];
 593        for( i=0; i < lpiID->idCount; i++ )
 594       { memcpy((void*)(lpID->idEntries + i),
 595                    (void*)(lpiID->idEntries + i), sizeof(ICONDIRENTRY) - 2);
 596             lpID->idEntries[i].icon.wResId = i;
 597          }
 598       *lplpiID = lpiID;
 599        return handle;
 600      }
 601   }
 602   /* fail */
 603
 604   HeapFree( GetProcessHeap(), 0, lpiID);
 605   return 0;
 606 }
 607
 608 /*************************************************************************
 609  *                      InternalExtractIcon             [SHELL.39]
 610  *
 611  * This abortion is called directly by Progman
 612  */
 613 HGLOBAL16 WINAPI InternalExtractIcon(HINSTANCE16 hInstance,
 614                                      LPCSTR lpszExeFileName, UINT16 nIconIndex, WORD n )
 615 {       HGLOBAL16       hRet = 0;
 616         HGLOBAL16*      RetPtr = NULL;
 617         LPBYTE          pData;
 618         OFSTRUCT        ofs;
 619         DWORD           sig;
 620         HFILE32         hFile = OpenFile32( lpszExeFileName, &ofs, OF_READ );
 621         UINT16          iconDirCount = 0,iconCount = 0;
 622         LPBYTE          peimage;
 623         HANDLE32        fmapping;
 624
 625         TRACE(shell,"(%04x,file %s,start %d,extract %d\n",
 626                        hInstance, lpszExeFileName, nIconIndex, n);
 627
 628         if( hFile == HFILE_ERROR32 || !n )
 629           return 0;
 630
 631         hRet = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, sizeof(HICON16)*n);
 632         RetPtr = (HICON16*)GlobalLock16(hRet);
 633
 634         *RetPtr = (n == 0xFFFF)? 0: 1;  /* error return values */
 635
 636         sig = SHELL_GetResourceTable(hFile,&pData);
 637
 638         if( sig==IMAGE_OS2_SIGNATURE || sig==1 ) /* .ICO file */
 639         { HICON16        hIcon = 0;
 640           NE_TYPEINFO* pTInfo = (NE_TYPEINFO*)(pData + 2);
 641           NE_NAMEINFO* pIconStorage = NULL;
 642           NE_NAMEINFO* pIconDir = NULL;
 643           LPicoICONDIR lpiID = NULL;
 644
 645           if( pData == (BYTE*)-1 )
 646           { hIcon = ICO_GetIconDirectory(hInstance, hFile, &lpiID);     /* check for .ICO file */
 647             if( hIcon )
 648             { iconDirCount = 1; iconCount = lpiID->idCount;
 649             }
 650           }
 651           else while( pTInfo->type_id && !(pIconStorage && pIconDir) )
 652           { if( pTInfo->type_id == NE_RSCTYPE_GROUP_ICON )      /* find icon directory and icon repository */
 653             { iconDirCount = pTInfo->count;
 654               pIconDir = ((NE_NAMEINFO*)(pTInfo + 1));
 655               TRACE(shell,"\tfound directory - %i icon families\n", iconDirCount);
 656             }
 657             if( pTInfo->type_id == NE_RSCTYPE_ICON )
 658             { iconCount = pTInfo->count;
 659               pIconStorage = ((NE_NAMEINFO*)(pTInfo + 1));
 660               TRACE(shell,"\ttotal icons - %i\n", iconCount);
 661             }
 662             pTInfo = (NE_TYPEINFO *)((char*)(pTInfo+1)+pTInfo->count*sizeof(NE_NAMEINFO));
 663           }
 664
 665           /* load resources and create icons */
 666
 667           if( (pIconStorage && pIconDir) || lpiID )
 668           { if( nIconIndex == (UINT16)-1 )
 669             { RetPtr[0] = iconDirCount;
 670             }
 671             else if( nIconIndex < iconDirCount )
 672             { UINT16   i, icon;
 673               if( n > iconDirCount - nIconIndex )
 674                 n = iconDirCount - nIconIndex;
 675
 676               for( i = nIconIndex; i < nIconIndex + n; i++ )
 677               { /* .ICO files have only one icon directory */
 678
 679                 if( lpiID == NULL )
 680                   hIcon = SHELL_LoadResource( hInstance, hFile, pIconDir + i, *(WORD*)pData );
 681                 RetPtr[i-nIconIndex] = GetIconID( hIcon, 3 );
 682                 GlobalFree16(hIcon);
 683               }
 684
 685               for( icon = nIconIndex; icon < nIconIndex + n; icon++ )
 686               { hIcon = 0;
 687                 if( lpiID )
 688                 { hIcon = ICO_LoadIcon( hInstance, hFile, lpiID->idEntries + RetPtr[icon-nIconIndex]);
 689                 }
 690                 else
 691                 { for( i = 0; i < iconCount; i++ )
 692                   { if( pIconStorage[i].id == (RetPtr[icon-nIconIndex] | 0x8000) )
 693                     { hIcon = SHELL_LoadResource( hInstance, hFile, pIconStorage + i,*(WORD*)pData );
 694                     }
 695                   }
 696                 }
 697                 if( hIcon )
 698                 { RetPtr[icon-nIconIndex] = LoadIconHandler( hIcon, TRUE );
 699                   FarSetOwner( RetPtr[icon-nIconIndex], GetExePtr(hInstance) );
 700                 }
 701                 else
 702                 { RetPtr[icon-nIconIndex] = 0;
 703                 }
 704               }
 705             }
 706           }
 707           if( lpiID )
 708             HeapFree( GetProcessHeap(), 0, lpiID);
 709           else
 710             HeapFree( GetProcessHeap(), 0, pData);
 711         }
 712
 713         if( sig == IMAGE_NT_SIGNATURE)
 714         { LPBYTE                idata,igdata;
 715           PIMAGE_DOS_HEADER     dheader;
 716           PIMAGE_NT_HEADERS     pe_header;
 717           PIMAGE_SECTION_HEADER pe_sections;
 718           PIMAGE_RESOURCE_DIRECTORY     rootresdir,iconresdir,icongroupresdir;
 719           PIMAGE_RESOURCE_DATA_ENTRY    idataent,igdataent;
 720           int                   i,j;
 721           PIMAGE_RESOURCE_DIRECTORY_ENTRY       xresent;
 722           CURSORICONDIR         **cids;
 723
 724           fmapping = CreateFileMapping32A(hFile,NULL,PAGE_READONLY|SEC_COMMIT,0,0,NULL);
 725           if (fmapping == 0)
 726           { /* FIXME, INVALID_HANDLE_VALUE? */
 727             WARN(shell,"failed to create filemap.\n");
 728             hRet = 0;
 729             goto end_2; /* failure */
 730           }
 731           peimage = MapViewOfFile(fmapping,FILE_MAP_READ,0,0,0);
 732           if (!peimage)
 733           { WARN(shell,"failed to mmap filemap.\n");
 734             hRet = 0;
 735             goto end_2; /* failure */
 736           }
 737           dheader = (PIMAGE_DOS_HEADER)peimage;
 738
 739           /* it is a pe header, SHELL_GetResourceTable checked that */
 740           pe_header = (PIMAGE_NT_HEADERS)(peimage+dheader->e_lfanew);
 741
 742           /* probably makes problems with short PE headers... but I haven't seen
 743           * one yet...
 744           */
 745           pe_sections = (PIMAGE_SECTION_HEADER)(((char*)pe_header)+sizeof(*pe_header));
 746           rootresdir = NULL;
 747
 748           for (i=0;i<pe_header->FileHeader.NumberOfSections;i++)
 749           { if (pe_sections[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
 750               continue;
 751             /* FIXME: doesn't work when the resources are not in a seperate section */
 752             if (pe_sections[i].VirtualAddress == pe_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress)
 753             { rootresdir = (PIMAGE_RESOURCE_DIRECTORY)((char*)peimage+pe_sections[i].PointerToRawData);
 754               break;
 755             }
 756           }
 757
 758           if (!rootresdir)
 759           { WARN(shell,"haven't found section for resource directory.\n");
 760             goto end_4; /* failure */
 761           }
 762
 763           icongroupresdir = GetResDirEntryW(rootresdir,RT_GROUP_ICON32W, (DWORD)rootresdir,FALSE);
 764
 765           if (!icongroupresdir)
 766           { WARN(shell,"No Icongroupresourcedirectory!\n");
 767             goto end_4; /* failure */
 768           }
 769
 770           iconDirCount = icongroupresdir->NumberOfNamedEntries+icongroupresdir->NumberOfIdEntries;
 771
 772           if( nIconIndex == (UINT16)-1 )
 773           { RetPtr[0] = iconDirCount;
 774             goto end_3; /* success */
 775           }
 776
 777           if (nIconIndex >= iconDirCount)
 778           { WARN(shell,"nIconIndex %d is larger than iconDirCount %d\n",nIconIndex,iconDirCount);
 779             GlobalFree16(hRet);
 780             goto end_4; /* failure */
 781           }
 782
 783           cids = (CURSORICONDIR**)HeapAlloc(GetProcessHeap(),0,n*sizeof(CURSORICONDIR*));
 784
 785           /* caller just wanted the number of entries */
 786           xresent = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(icongroupresdir+1);
 787
 788           /* assure we don't get too much ... */
 789           if( n > iconDirCount - nIconIndex )
 790           { n = iconDirCount - nIconIndex;
 791           }
 792
 793           /* starting from specified index ... */
 794           xresent = xresent+nIconIndex;
 795
 796           for (i=0;i<n;i++,xresent++)
 797           { CURSORICONDIR       *cid;
 798             PIMAGE_RESOURCE_DIRECTORY   resdir;
 799
 800             /* go down this resource entry, name */
 801             resdir = (PIMAGE_RESOURCE_DIRECTORY)((DWORD)rootresdir+(xresent->u2.s.OffsetToDirectory));
 802
 803             /* default language (0) */
 804             resdir = GetResDirEntryW(resdir,(LPWSTR)0,(DWORD)rootresdir,TRUE);
 805             igdataent = (PIMAGE_RESOURCE_DATA_ENTRY)resdir;
 806
 807             /* lookup address in mapped image for virtual address */
 808             igdata = NULL;
 809
 810             for (j=0;j<pe_header->FileHeader.NumberOfSections;j++)
 811             { if (igdataent->OffsetToData < pe_sections[j].VirtualAddress)
 812                 continue;
 813               if (igdataent->OffsetToData+igdataent->Size > pe_sections[j].VirtualAddress+pe_sections[j].SizeOfRawData)
 814                 continue;
 815               igdata = peimage+(igdataent->OffsetToData-pe_sections[j].VirtualAddress+pe_sections[j].PointerToRawData);
 816             }
 817
 818             if (!igdata)
 819             { WARN(shell,"no matching real address for icongroup!\n");
 820               goto end_4;       /* failure */
 821             }
 822             /* found */
 823             cid = (CURSORICONDIR*)igdata;
 824             cids[i] = cid;
 825             RetPtr[i] = LookupIconIdFromDirectoryEx32(igdata,TRUE,SYSMETRICS_CXICON,SYSMETRICS_CYICON,0);
 826           }
 827
 828           iconresdir=GetResDirEntryW(rootresdir,RT_ICON32W,(DWORD)rootresdir,FALSE);
 829
 830           if (!iconresdir)
 831           { WARN(shell,"No Iconresourcedirectory!\n");
 832             goto end_4; /* failure */
 833           }
 834
 835           for (i=0;i<n;i++)
 836           { PIMAGE_RESOURCE_DIRECTORY   xresdir;
 837             xresdir = GetResDirEntryW(iconresdir,(LPWSTR)(DWORD)RetPtr[i],(DWORD)rootresdir,FALSE);
 838             xresdir = GetResDirEntryW(xresdir,(LPWSTR)0,(DWORD)rootresdir,TRUE);
 839             idataent = (PIMAGE_RESOURCE_DATA_ENTRY)xresdir;
 840             idata = NULL;
 841
 842             /* map virtual to address in image */
 843             for (j=0;j<pe_header->FileHeader.NumberOfSections;j++)
 844             { if (idataent->OffsetToData < pe_sections[j].VirtualAddress)
 845                 continue;
 846               if (idataent->OffsetToData+idataent->Size > pe_sections[j].VirtualAddress+pe_sections[j].SizeOfRawData)
 847                 continue;
 848               idata = peimage+(idataent->OffsetToData-pe_sections[j].VirtualAddress+pe_sections[j].PointerToRawData);
 849             }
 850             if (!idata)
 851             { WARN(shell,"no matching real address found for icondata!\n");
 852               RetPtr[i]=0;
 853               continue;
 854             }
 855             RetPtr[i] = CreateIconFromResourceEx32(idata,idataent->Size,TRUE,0x00030000,SYSMETRICS_CXICON,SYSMETRICS_CYICON,0);
 856           }
 857           goto end_3;   /* sucess */
 858         }
 859         goto end_1;     /* return array with icon handles */
 860
 861 /* cleaning up (try & catch would be nicer) */
 862 end_4:  hRet = 0;       /* failure */
 863 end_3:  UnmapViewOfFile(peimage);       /* success */
 864 end_2:  CloseHandle(fmapping);
 865 end_1:  _lclose32( hFile);
 866         return hRet;
 867 }
 868
 869 /*************************************************************************
 870  *             ExtractIcon16   (SHELL.34)
 871  */
 872 HICON16 WINAPI ExtractIcon16( HINSTANCE16 hInstance, LPCSTR lpszExeFileName,
 873         UINT16 nIconIndex )
 874 {   TRACE(shell,"\n");
 875     return ExtractIcon32A( hInstance, lpszExeFileName, nIconIndex );
 876 }
 877
 878 /*************************************************************************
 879  *             ExtractIconEx16   (SHELL.40)
 880  */
 881 HICON16 WINAPI ExtractIconEx16(
 882         LPCSTR lpszFile, INT16 nIconIndex, HICON16 *phiconLarge,
 883         HICON16 *phiconSmall, UINT16 nIcons
 884 ) {
 885     HICON32     *ilarge,*ismall;
 886     UINT16      ret;
 887     int         i;
 888
 889     if (phiconLarge)
 890         ilarge = (HICON32*)HeapAlloc(GetProcessHeap(),0,nIcons*sizeof(HICON32));
 891     else
 892         ilarge = NULL;
 893     if (phiconSmall)
 894         ismall = (HICON32*)HeapAlloc(GetProcessHeap(),0,nIcons*sizeof(HICON32));
 895     else
 896         ismall = NULL;
 897     ret = ExtractIconEx32A(lpszFile,nIconIndex,ilarge,ismall,nIcons);
 898     if (ilarge) {
 899         for (i=0;i<nIcons;i++)
 900             phiconLarge[i]=ilarge[i];
 901         HeapFree(GetProcessHeap(),0,ilarge);
 902     }
 903     if (ismall) {
 904         for (i=0;i<nIcons;i++)
 905             phiconSmall[i]=ismall[i];
 906         HeapFree(GetProcessHeap(),0,ismall);
 907     }
 908     return ret;
 909 }
 910
 911 /*************************************************************************
 912  *                              ExtractAssociatedIcon   [SHELL.36]
 913  *
 914  * Return icon for given file (either from file itself or from associated
 915  * executable) and patch parameters if needed.
 916  */
 917 HICON32 WINAPI ExtractAssociatedIcon32A(HINSTANCE32 hInst, LPSTR lpIconPath, LPWORD lpiIcon)
 918 {       TRACE(shell,"\n");
 919         return ExtractAssociatedIcon16(hInst,lpIconPath,lpiIcon);
 920 }
 921
 922 HICON16 WINAPI ExtractAssociatedIcon16(HINSTANCE16 hInst, LPSTR lpIconPath, LPWORD lpiIcon)
 923 {       HICON16 hIcon;
 924
 925         TRACE(shell,"\n");
 926
 927         hIcon = ExtractIcon16(hInst, lpIconPath, *lpiIcon);
 928
 929         if( hIcon < 2 )
 930         { if( hIcon == 1 ) /* no icons found in given file */
 931           { char  tempPath[0x80];
 932             UINT16  uRet = FindExecutable16(lpIconPath,NULL,tempPath);
 933
 934             if( uRet > 32 && tempPath[0] )
 935             { strcpy(lpIconPath,tempPath);
 936               hIcon = ExtractIcon16(hInst, lpIconPath, *lpiIcon);
 937               if( hIcon > 2 )
 938                 return hIcon;
 939             }
 940             else hIcon = 0;
 941           }
 942
 943           if( hIcon == 1 )
 944             *lpiIcon = 2;   /* MSDOS icon - we found .exe but no icons in it */
 945           else
 946             *lpiIcon = 6;   /* generic icon - found nothing */
 947
 948           GetModuleFileName16(hInst, lpIconPath, 0x80);
 949           hIcon = LoadIcon16( hInst, MAKEINTRESOURCE16(*lpiIcon));
 950         }
 951         return hIcon;
 952 }
 953
 954 /*************************************************************************
 955  *                              FindEnvironmentString   [SHELL.38]
 956  *
 957  * Returns a pointer into the DOS environment... Ugh.
 958  */
 959 LPSTR SHELL_FindString(LPSTR lpEnv, LPCSTR entry)
 960 { UINT16 l;
 961
 962   TRACE(shell,"\n");
 963
 964   l = strlen(entry);
 965   for( ; *lpEnv ; lpEnv+=strlen(lpEnv)+1 )
 966   { if( lstrncmpi32A(lpEnv, entry, l) )
 967       continue;
 968         if( !*(lpEnv+l) )
 969             return (lpEnv + l);                 /* empty entry */
 970         else if ( *(lpEnv+l)== '=' )
 971             return (lpEnv + l + 1);
 972     }
 973     return NULL;
 974 }
 975
 976 SEGPTR WINAPI FindEnvironmentString(LPSTR str)
 977 { SEGPTR  spEnv;
 978   LPSTR lpEnv,lpString;
 979   TRACE(shell,"\n");
 980
 981   spEnv = GetDOSEnvironment();
 982
 983   lpEnv = (LPSTR)PTR_SEG_TO_LIN(spEnv);
 984   lpString = (spEnv)?SHELL_FindString(lpEnv, str):NULL;
 985
 986     if( lpString )              /*  offset should be small enough */
 987         return spEnv + (lpString - lpEnv);
 988     return (SEGPTR)NULL;
 989 }
 990
 991 /*************************************************************************
 992  *                              DoEnvironmentSubst      [SHELL.37]
 993  *
 994  * Replace %KEYWORD% in the str with the value of variable KEYWORD
 995  * from "DOS" environment.
 996  */
 997 DWORD WINAPI DoEnvironmentSubst(LPSTR str,WORD length)
 998 {
 999   LPSTR   lpEnv = (LPSTR)PTR_SEG_TO_LIN(GetDOSEnvironment());
1000   LPSTR   lpBuffer = (LPSTR)HeapAlloc( GetProcessHeap(), 0, length);
1001   LPSTR   lpstr = str;
1002   LPSTR   lpbstr = lpBuffer;
1003
1004   CharToOem32A(str,str);
1005
1006   TRACE(shell,"accept %s\n", str);
1007
1008   while( *lpstr && lpbstr - lpBuffer < length )
1009    {
1010      LPSTR lpend = lpstr;
1011
1012      if( *lpstr == '%' )
1013        {
1014           do { lpend++; } while( *lpend && *lpend != '%' );
1015           if( *lpend == '%' && lpend - lpstr > 1 )      /* found key */
1016             {
1017                LPSTR lpKey;
1018               *lpend = '\0';
1019                lpKey = SHELL_FindString(lpEnv, lpstr+1);
1020                if( lpKey )                              /* found key value */
1021                  {
1022                    int l = strlen(lpKey);
1023
1024                    if( l > length - (lpbstr - lpBuffer) - 1 )
1025                      {
1026            WARN(shell,"-- Env subst aborted - string too short\n");
1027                       *lpend = '%';
1028                        break;
1029                      }
1030                    strcpy(lpbstr, lpKey);
1031                    lpbstr += l;
1032                  }
1033                else break;
1034               *lpend = '%';
1035                lpstr = lpend + 1;
1036             }
1037           else break;                                   /* back off and whine */
1038
1039           continue;
1040        }
1041
1042      *lpbstr++ = *lpstr++;
1043    }
1044
1045  *lpbstr = '\0';
1046   if( lpstr - str == strlen(str) )
1047     {
1048       strncpy(str, lpBuffer, length);
1049       length = 1;
1050     }
1051   else
1052       length = 0;
1053
1054   TRACE(shell,"-- return %s\n", str);
1055
1056   OemToChar32A(str,str);
1057   HeapFree( GetProcessHeap(), 0, lpBuffer);
1058
1059   /*  Return str length in the LOWORD
1060    *  and 1 in HIWORD if subst was successful.
1061    */
1062  return (DWORD)MAKELONG(strlen(str), length);
1063 }
1064
1065 /*************************************************************************
1066  *                              ShellHookProc           [SHELL.103]
1067  * System-wide WH_SHELL hook.
1068  */
1069 LRESULT WINAPI ShellHookProc(INT16 code, WPARAM16 wParam, LPARAM lParam)
1070 {
1071     TRACE(shell,"%i, %04x, %08x\n", code, wParam,
1072                                                       (unsigned)lParam );
1073     if( SHELL_hHook && SHELL_hWnd )
1074     {
1075         UINT16  uMsg = 0;
1076         switch( code )
1077         {
1078             case HSHELL_WINDOWCREATED:          uMsg = uMsgWndCreated;   break;
1079             case HSHELL_WINDOWDESTROYED:        uMsg = uMsgWndDestroyed; break;
1080             case HSHELL_ACTIVATESHELLWINDOW:    uMsg = uMsgShellActivate;
1081         }
1082         PostMessage16( SHELL_hWnd, uMsg, wParam, 0 );
1083     }
1084     return CallNextHookEx16( WH_SHELL, code, wParam, lParam );
1085 }
1086
1087 /*************************************************************************
1088  *                              RegisterShellHook       [SHELL.102]
1089  */
1090 BOOL32 WINAPI RegisterShellHook(HWND16 hWnd, UINT16 uAction)
1091 { TRACE(shell,"%04x [%u]\n", hWnd, uAction );
1092
1093     switch( uAction )
1094   { case 2:  /* register hWnd as a shell window */
1095              if( !SHELL_hHook )
1096       { HMODULE16 hShell = GetModuleHandle16( "SHELL" );
1097         SHELL_hHook = SetWindowsHookEx16( WH_SHELL, ShellHookProc, hShell, 0 );
1098                 if( SHELL_hHook )
1099         { uMsgWndCreated = RegisterWindowMessage32A( lpstrMsgWndCreated );
1100                     uMsgWndDestroyed = RegisterWindowMessage32A( lpstrMsgWndDestroyed );
1101                     uMsgShellActivate = RegisterWindowMessage32A( lpstrMsgShellActivate );
1102                 }
1103         else
1104           WARN(shell,"-- unable to install ShellHookProc()!\n");
1105              }
1106
1107       if( SHELL_hHook )
1108         return ((SHELL_hWnd = hWnd) != 0);
1109              break;
1110
1111         default:
1112     WARN(shell, "-- unknown code %i\n", uAction );
1113              /* just in case */
1114              SHELL_hWnd = 0;
1115     }
1116     return FALSE;
1117 }