dlls/shell32/shlexec.c

   1 /*
   2  *                              Shell Library Functions
   3  *
   4  * Copyright 1998 Marcus Meissner
   5  * Copyright 2002 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #ifdef HAVE_UNISTD_H
  30 # include <unistd.h>
  31 #endif
  32 #include <ctype.h>
  33 #include <assert.h>
  34
  35 #define COBJMACROS
  36
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winerror.h"
  40 #include "winreg.h"
  41 #include "winuser.h"
  42 #include "shlwapi.h"
  43 #include "ddeml.h"
  44
  45 #include "shell32_main.h"
  46 #include "pidl.h"
  47 #include "shresdef.h"
  48
  49 #include "wine/debug.h"
  50
  51 WINE_DEFAULT_DEBUG_CHANNEL(exec);
  52
  53 static const WCHAR wszOpen[] = {'o','p','e','n',0};
  54 static const WCHAR wszExe[] = {'.','e','x','e',0};
  55 static const WCHAR wszILPtr[] = {':','%','p',0};
  56 static const WCHAR wszShell[] = {'\\','s','h','e','l','l','\\',0};
  57 static const WCHAR wszFolder[] = {'F','o','l','d','e','r',0};
  58 static const WCHAR wszEmpty[] = {0};
  59
  60 #define SEE_MASK_CLASSALL (SEE_MASK_CLASSNAME | SEE_MASK_CLASSKEY)
  61
  62 typedef UINT_PTR (*SHELL_ExecuteW32)(const WCHAR *lpCmd, WCHAR *env, BOOL shWait,
  63                             const SHELLEXECUTEINFOW *sei, LPSHELLEXECUTEINFOW sei_out);
  64
  65 static inline BOOL isSpace(WCHAR c)
  66 {
  67     return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v';
  68 }
  69
  70 /***********************************************************************
  71  *      SHELL_ArgifyW [Internal]
  72  *
  73  * this function is supposed to expand the escape sequences found in the registry
  74  * some diving reported that the following were used:
  75  * + %1, %2...  seem to report to parameter of index N in ShellExecute pmts
  76  *      %1 file
  77  *      %2 printer
  78  *      %3 driver
  79  *      %4 port
  80  * %I address of a global item ID (explorer switch /idlist)
  81  * %L seems to be %1 as long filename followed by the 8+3 variation
  82  * %S ???
  83  * %* all following parameters (see batfile)
  84  *
  85  */
  86 static BOOL SHELL_ArgifyW(WCHAR* out, int len, const WCHAR* fmt, const WCHAR* lpFile, LPITEMIDLIST pidl, LPCWSTR args, DWORD* out_len)
  87 {
  88     WCHAR   xlpFile[1024];
  89     BOOL    done = FALSE;
  90     BOOL    found_p1 = FALSE;
  91     PWSTR   res = out;
  92     PCWSTR  cmd;
  93     DWORD   used = 0;
  94
  95     TRACE("%p, %d, %s, %s, %p, %p\n", out, len, debugstr_w(fmt),
  96           debugstr_w(lpFile), pidl, args);
  97
  98     while (*fmt)
  99     {
 100         if (*fmt == '%')
 101         {
 102             switch (*++fmt)
 103             {
 104             case '\0':
 105             case '%':
 106                 used++;
 107                 if (used < len)
 108                     *res++ = '%';
 109                 break;
 110
 111             case '2':
 112             case '3':
 113             case '4':
 114             case '5':
 115             case '6':
 116             case '7':
 117             case '8':
 118             case '9':
 119             case '0':
 120             case '*':
 121                 if (args)
 122                 {
 123                     if (*fmt == '*')
 124                     {
 125                         used++;
 126                         if (used < len)
 127                             *res++ = '"';
 128                         while(*args)
 129                         {
 130                             used++;
 131                             if (used < len)
 132                                 *res++ = *args++;
 133                             else
 134                                 args++;
 135                         }
 136                         used++;
 137                         if (used < len)
 138                             *res++ = '"';
 139                     }
 140                     else
 141                     {
 142                         while(*args && !isSpace(*args))
 143                         {
 144                             used++;
 145                             if (used < len)
 146                                 *res++ = *args++;
 147                             else
 148                                 args++;
 149                         }
 150
 151                         while(isSpace(*args))
 152                             ++args;
 153                     }
 154                     break;
 155                 }
 156                 /* else fall through */
 157             case '1':
 158                 if (!done || (*fmt == '1'))
 159                 {
 160                     /*FIXME Is the call to SearchPathW() really needed? We already have separated out the parameter string in args. */
 161                     if (SearchPathW(NULL, lpFile, wszExe, ARRAY_SIZE(xlpFile), xlpFile, NULL))
 162                         cmd = xlpFile;
 163                     else
 164                         cmd = lpFile;
 165
 166                     used += strlenW(cmd);
 167                     if (used < len)
 168                     {
 169                         strcpyW(res, cmd);
 170                         res += strlenW(cmd);
 171                     }
 172                 }
 173                 found_p1 = TRUE;
 174                 break;
 175
 176             /*
 177              * IE uses this a lot for activating things such as windows media
 178              * player. This is not verified to be fully correct but it appears
 179              * to work just fine.
 180              */
 181             case 'l':
 182             case 'L':
 183                 if (lpFile) {
 184                     used += strlenW(lpFile);
 185                     if (used < len)
 186                     {
 187                         strcpyW(res, lpFile);
 188                         res += strlenW(lpFile);
 189                     }
 190                 }
 191                 found_p1 = TRUE;
 192                 break;
 193
 194             case 'i':
 195             case 'I':
 196                 if (pidl) {
 197                     INT chars = 0;
 198                     /* %p should not exceed 8, maybe 16 when looking forward to 64bit.
 199                      * allowing a buffer of 100 should more than exceed all needs */
 200                     WCHAR buf[100];
 201                     LPVOID  pv;
 202                     HGLOBAL hmem = SHAllocShared(pidl, ILGetSize(pidl), 0);
 203                     pv = SHLockShared(hmem, 0);
 204                     chars = sprintfW(buf, wszILPtr, pv);
 205                     if (chars >= ARRAY_SIZE(buf))
 206                         ERR("pidl format buffer too small!\n");
 207                     used += chars;
 208                     if (used < len)
 209                     {
 210                         strcpyW(res,buf);
 211                         res += chars;
 212                     }
 213                     SHUnlockShared(pv);
 214                 }
 215                 found_p1 = TRUE;
 216                 break;
 217
 218             default:
 219                 /*
 220                  * Check if this is an env-variable here...
 221                  */
 222
 223                 /* Make sure that we have at least one more %.*/
 224                 if (strchrW(fmt, '%'))
 225                 {
 226                     WCHAR   tmpBuffer[1024];
 227                     PWSTR   tmpB = tmpBuffer;
 228                     WCHAR   tmpEnvBuff[MAX_PATH];
 229                     DWORD   envRet;
 230
 231                     while (*fmt != '%')
 232                         *tmpB++ = *fmt++;
 233                     *tmpB++ = 0;
 234
 235                     TRACE("Checking %s to be an env-var\n", debugstr_w(tmpBuffer));
 236
 237                     envRet = GetEnvironmentVariableW(tmpBuffer, tmpEnvBuff, MAX_PATH);
 238                     if (envRet == 0 || envRet > MAX_PATH)
 239                     {
 240                         used += strlenW(tmpBuffer);
 241                         if (used < len)
 242                         {
 243                             strcpyW( res, tmpBuffer );
 244                             res += strlenW(tmpBuffer);
 245                         }
 246                     }
 247                     else
 248                     {
 249                         used += strlenW(tmpEnvBuff);
 250                         if (used < len)
 251                         {
 252                             strcpyW( res, tmpEnvBuff );
 253                             res += strlenW(tmpEnvBuff);
 254                         }
 255                     }
 256                 }
 257                 done = TRUE;
 258                 break;
 259             }
 260             /* Don't skip past terminator (catch a single '%' at the end) */
 261             if (*fmt != '\0')
 262             {
 263                 fmt++;
 264             }
 265         }
 266         else
 267         {
 268             used ++;
 269             if (used < len)
 270                 *res++ = *fmt++;
 271             else
 272                 fmt++;
 273         }
 274     }
 275
 276     used ++;
 277     if (res - out < len)
 278         *res = '\0';
 279     else
 280         out[len-1] = '\0';
 281
 282     TRACE("used %i of %i space\n",used,len);
 283     if (out_len)
 284         *out_len = used;
 285
 286     return found_p1;
 287 }
 288
 289 static HRESULT SHELL_GetPathFromIDListForExecuteW(LPCITEMIDLIST pidl, LPWSTR pszPath, UINT uOutSize)
 290 {
 291     STRRET strret;
 292     IShellFolder* desktop;
 293
 294     HRESULT hr = SHGetDesktopFolder(&desktop);
 295
 296     if (SUCCEEDED(hr)) {
 297         hr = IShellFolder_GetDisplayNameOf(desktop, pidl, SHGDN_FORPARSING, &strret);
 298
 299         if (SUCCEEDED(hr))
 300             StrRetToStrNW(pszPath, uOutSize, &strret, pidl);
 301
 302         IShellFolder_Release(desktop);
 303     }
 304
 305     return hr;
 306 }
 307
 308 /*************************************************************************
 309  *      SHELL_ExecuteW [Internal]
 310  *
 311  */
 312 static UINT_PTR SHELL_ExecuteW(const WCHAR *lpCmd, WCHAR *env, BOOL shWait,
 313                             const SHELLEXECUTEINFOW *psei, LPSHELLEXECUTEINFOW psei_out)
 314 {
 315     STARTUPINFOW  startup;
 316     PROCESS_INFORMATION info;
 317     UINT_PTR retval = SE_ERR_NOASSOC;
 318     UINT gcdret = 0;
 319     WCHAR curdir[MAX_PATH];
 320     DWORD dwCreationFlags;
 321     const WCHAR *lpDirectory = NULL;
 322
 323     TRACE("Execute %s from directory %s\n", debugstr_w(lpCmd), debugstr_w(psei->lpDirectory));
 324
 325     /* make sure we don't fail the CreateProcess if the calling app passes in
 326      * a bad working directory */
 327     if (psei->lpDirectory && psei->lpDirectory[0])
 328     {
 329         DWORD attr = GetFileAttributesW(psei->lpDirectory);
 330         if (attr != INVALID_FILE_ATTRIBUTES && attr & FILE_ATTRIBUTE_DIRECTORY)
 331             lpDirectory = psei->lpDirectory;
 332     }
 333
 334     /* ShellExecute specifies the command from psei->lpDirectory
 335      * if present. Not from the current dir as CreateProcess does */
 336     if( lpDirectory )
 337         if( ( gcdret = GetCurrentDirectoryW( MAX_PATH, curdir)))
 338             if( !SetCurrentDirectoryW( lpDirectory))
 339                 ERR("cannot set directory %s\n", debugstr_w(lpDirectory));
 340     ZeroMemory(&startup,sizeof(STARTUPINFOW));
 341     startup.cb = sizeof(STARTUPINFOW);
 342     startup.dwFlags = STARTF_USESHOWWINDOW;
 343     startup.wShowWindow = psei->nShow;
 344     dwCreationFlags = CREATE_UNICODE_ENVIRONMENT;
 345     if (!(psei->fMask & SEE_MASK_NO_CONSOLE))
 346         dwCreationFlags |= CREATE_NEW_CONSOLE;
 347     if (CreateProcessW(NULL, (LPWSTR)lpCmd, NULL, NULL, FALSE, dwCreationFlags, env,
 348                        lpDirectory, &startup, &info))
 349     {
 350         /* Give 30 seconds to the app to come up, if desired. Probably only needed
 351            when starting app immediately before making a DDE connection. */
 352         if (shWait)
 353             if (WaitForInputIdle( info.hProcess, 30000 ) == WAIT_FAILED)
 354                 WARN("WaitForInputIdle failed: Error %d\n", GetLastError() );
 355         retval = 33;
 356         if (psei->fMask & SEE_MASK_NOCLOSEPROCESS)
 357             psei_out->hProcess = info.hProcess;
 358         else
 359             CloseHandle( info.hProcess );
 360         CloseHandle( info.hThread );
 361     }
 362     else if ((retval = GetLastError()) >= 32)
 363     {
 364         TRACE("CreateProcess returned error %ld\n", retval);
 365         retval = ERROR_BAD_FORMAT;
 366     }
 367
 368     TRACE("returning %lu\n", retval);
 369
 370     psei_out->hInstApp = (HINSTANCE)retval;
 371     if( gcdret )
 372         if( !SetCurrentDirectoryW( curdir))
 373             ERR("cannot return to directory %s\n", debugstr_w(curdir));
 374
 375     return retval;
 376 }
 377
 378
 379 /***********************************************************************
 380  *           SHELL_BuildEnvW    [Internal]
 381  *
 382  * Build the environment for the new process, adding the specified
 383  * path to the PATH variable. Returned pointer must be freed by caller.
 384  */
 385 static void *SHELL_BuildEnvW( const WCHAR *path )
 386 {
 387     static const WCHAR wPath[] = {'P','A','T','H','=',0};
 388     WCHAR *strings, *new_env;
 389     WCHAR *p, *p2;
 390     int total = strlenW(path) + 1;
 391     BOOL got_path = FALSE;
 392
 393     if (!(strings = GetEnvironmentStringsW())) return NULL;
 394     p = strings;
 395     while (*p)
 396     {
 397         int len = strlenW(p) + 1;
 398         if (!strncmpiW( p, wPath, 5 )) got_path = TRUE;
 399         total += len;
 400         p += len;
 401     }
 402     if (!got_path) total += 5;  /* we need to create PATH */
 403     total++;  /* terminating null */
 404
 405     if (!(new_env = heap_alloc( total * sizeof(WCHAR) )))
 406     {
 407         FreeEnvironmentStringsW( strings );
 408         return NULL;
 409     }
 410     p = strings;
 411     p2 = new_env;
 412     while (*p)
 413     {
 414         int len = strlenW(p) + 1;
 415         memcpy( p2, p, len * sizeof(WCHAR) );
 416         if (!strncmpiW( p, wPath, 5 ))
 417         {
 418             p2[len - 1] = ';';
 419             strcpyW( p2 + len, path );
 420             p2 += strlenW(path) + 1;
 421         }
 422         p += len;
 423         p2 += len;
 424     }
 425     if (!got_path)
 426     {
 427         strcpyW( p2, wPath );
 428         strcatW( p2, path );
 429         p2 += strlenW(p2) + 1;
 430     }
 431     *p2 = 0;
 432     FreeEnvironmentStringsW( strings );
 433     return new_env;
 434 }
 435
 436
 437 /***********************************************************************
 438  *           SHELL_TryAppPathW  [Internal]
 439  *
 440  * Helper function for SHELL_FindExecutable
 441  * @param lpResult - pointer to a buffer of size MAX_PATH
 442  * On entry: szName is a filename (probably without path separators).
 443  * On exit: if szName found in "App Path", place full path in lpResult, and return true
 444  */
 445 static BOOL SHELL_TryAppPathW( LPCWSTR szName, LPWSTR lpResult, WCHAR **env)
 446 {
 447     static const WCHAR wszKeyAppPaths[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',
 448         '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','A','p','p',' ','P','a','t','h','s','\\',0};
 449     static const WCHAR wPath[] = {'P','a','t','h',0};
 450     HKEY hkApp = 0;
 451     WCHAR buffer[1024];
 452     LONG len;
 453     LONG res;
 454     BOOL found = FALSE;
 455
 456     if (env) *env = NULL;
 457     strcpyW(buffer, wszKeyAppPaths);
 458     strcatW(buffer, szName);
 459     res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, buffer, 0, KEY_READ, &hkApp);
 460     if (res) goto end;
 461
 462     len = MAX_PATH*sizeof(WCHAR);
 463     res = RegQueryValueW(hkApp, NULL, lpResult, &len);
 464     if (res) goto end;
 465     found = TRUE;
 466
 467     if (env)
 468     {
 469         DWORD count = sizeof(buffer);
 470         if (!RegQueryValueExW(hkApp, wPath, NULL, NULL, (LPBYTE)buffer, &count) && buffer[0])
 471             *env = SHELL_BuildEnvW( buffer );
 472     }
 473
 474 end:
 475     if (hkApp) RegCloseKey(hkApp);
 476     return found;
 477 }
 478
 479 /*************************************************************************
 480  *      SHELL_FindExecutableByVerb [Internal]
 481  *
 482  * called from SHELL_FindExecutable or SHELL_execute_class
 483  * in/out:
 484  *      classname a buffer, big enough, to get the key name to do actually the
 485  *              command   "WordPad.Document.1\\shell\\open\\command"
 486  *              passed as "WordPad.Document.1"
 487  * in:
 488  *      lpVerb the operation on it (open)
 489  *      commandlen the size of command buffer (in bytes)
 490  * out:
 491  *      command a buffer, to store the command to do the
 492  *              operation on the file
 493  *      key a buffer, big enough, to get the key name to do actually the
 494  *              command "WordPad.Document.1\\shell\\open\\command"
 495  *              Can be NULL
 496  */
 497 static UINT SHELL_FindExecutableByVerb(LPCWSTR lpVerb, LPWSTR key, LPWSTR classname, LPWSTR command, LONG commandlen)
 498 {
 499     static const WCHAR wCommand[] = {'\\','c','o','m','m','a','n','d',0};
 500     HKEY hkeyClass;
 501     WCHAR verb[MAX_PATH];
 502
 503     if (RegOpenKeyExW(HKEY_CLASSES_ROOT, classname, 0, 0x02000000, &hkeyClass))
 504         return SE_ERR_NOASSOC;
 505     if (!HCR_GetDefaultVerbW(hkeyClass, lpVerb, verb, ARRAY_SIZE(verb)))
 506         return SE_ERR_NOASSOC;
 507     RegCloseKey(hkeyClass);
 508
 509     /* Looking for ...buffer\shell\<verb>\command */
 510     strcatW(classname, wszShell);
 511     strcatW(classname, verb);
 512     strcatW(classname, wCommand);
 513
 514     if (RegQueryValueW(HKEY_CLASSES_ROOT, classname, command,
 515                        &commandlen) == ERROR_SUCCESS)
 516     {
 517         commandlen /= sizeof(WCHAR);
 518         if (key) strcpyW(key, classname);
 519 #if 0
 520         LPWSTR tmp;
 521         WCHAR param[256];
 522         LONG paramlen = sizeof(param);
 523         static const WCHAR wSpace[] = {' ',0};
 524
 525         /* FIXME: it seems all Windows version don't behave the same here.
 526          * the doc states that this ddeexec information can be found after
 527          * the exec names.
 528          * on Win98, it doesn't appear, but I think it does on Win2k
 529          */
 530         /* Get the parameters needed by the application
 531            from the associated ddeexec key */
 532         tmp = strstrW(classname, wCommand);
 533         tmp[0] = '\0';
 534         strcatW(classname, wDdeexec);
 535         if (RegQueryValueW(HKEY_CLASSES_ROOT, classname, param,
 536                                      &paramlen) == ERROR_SUCCESS)
 537         {
 538             paramlen /= sizeof(WCHAR);
 539             strcatW(command, wSpace);
 540             strcatW(command, param);
 541             commandlen += paramlen;
 542         }
 543 #endif
 544
 545         command[commandlen] = '\0';
 546
 547         return 33; /* FIXME see SHELL_FindExecutable() */
 548     }
 549
 550     return SE_ERR_NOASSOC;
 551 }
 552
 553 /*************************************************************************
 554  *      SHELL_FindExecutable [Internal]
 555  *
 556  * Utility for code sharing between FindExecutable and ShellExecute
 557  * in:
 558  *      lpFile the name of a file
 559  *      lpVerb the operation on it (open)
 560  * out:
 561  *      lpResult a buffer, big enough :-(, to store the command to do the
 562  *              operation on the file
 563  *      key a buffer, big enough, to get the key name to do actually the
 564  *              command (it'll be used afterwards for more information
 565  *              on the operation)
 566  */
 567 static UINT SHELL_FindExecutable(LPCWSTR lpPath, LPCWSTR lpFile, LPCWSTR lpVerb,
 568                                  LPWSTR lpResult, int resultLen, LPWSTR key, WCHAR **env, LPITEMIDLIST pidl, LPCWSTR args)
 569 {
 570     static const WCHAR wWindows[] = {'w','i','n','d','o','w','s',0};
 571     static const WCHAR wPrograms[] = {'p','r','o','g','r','a','m','s',0};
 572     static const WCHAR wExtensions[] = {'e','x','e',' ','p','i','f',' ','b','a','t',' ','c','m','d',' ','c','o','m',0};
 573     WCHAR *extension = NULL; /* pointer to file extension */
 574     WCHAR classname[256];     /* registry name for this file type */
 575     LONG  classnamelen = sizeof(classname); /* length of above */
 576     WCHAR command[1024];     /* command from registry */
 577     WCHAR wBuffer[256];      /* Used to GetProfileString */
 578     UINT  retval = SE_ERR_NOASSOC;
 579     WCHAR *tok;              /* token pointer */
 580     WCHAR xlpFile[256];      /* result of SearchPath */
 581     DWORD attribs;           /* file attributes */
 582
 583     TRACE("%s\n", debugstr_w(lpFile));
 584
 585     if (!lpResult)
 586         return ERROR_INVALID_PARAMETER;
 587
 588     xlpFile[0] = '\0';
 589     lpResult[0] = '\0'; /* Start off with an empty return string */
 590     if (key) *key = '\0';
 591
 592     /* trap NULL parameters on entry */
 593     if (!lpFile)
 594     {
 595         WARN("(lpFile=%s,lpResult=%s): NULL parameter\n",
 596              debugstr_w(lpFile), debugstr_w(lpResult));
 597         return ERROR_FILE_NOT_FOUND; /* File not found. Close enough, I guess. */
 598     }
 599
 600     if (SHELL_TryAppPathW( lpFile, lpResult, env ))
 601     {
 602         TRACE("found %s via App Paths\n", debugstr_w(lpResult));
 603         return 33;
 604     }
 605
 606     if (SearchPathW(lpPath, lpFile, wszExe, ARRAY_SIZE(xlpFile), xlpFile, NULL))
 607     {
 608         TRACE("SearchPathW returned non-zero\n");
 609         lpFile = xlpFile;
 610         /* The file was found in the application-supplied default directory (or the system search path) */
 611     }
 612     else if (lpPath && SearchPathW(NULL, lpFile, wszExe, ARRAY_SIZE(xlpFile), xlpFile, NULL))
 613     {
 614         TRACE("SearchPathW returned non-zero\n");
 615         lpFile = xlpFile;
 616         /* The file was found in one of the directories in the system-wide search path */
 617     }
 618
 619     attribs = GetFileAttributesW(lpFile);
 620     if (attribs!=INVALID_FILE_ATTRIBUTES && (attribs&FILE_ATTRIBUTE_DIRECTORY))
 621     {
 622        strcpyW(classname, wszFolder);
 623     }
 624     else
 625     {
 626         /* Did we get something? Anything? */
 627         if (xlpFile[0]==0)
 628         {
 629             TRACE("Returning SE_ERR_FNF\n");
 630             return SE_ERR_FNF;
 631         }
 632         /* First thing we need is the file's extension */
 633         extension = strrchrW(xlpFile, '.'); /* Assume last "." is the one; */
 634         /* File->Run in progman uses */
 635         /* .\FILE.EXE :( */
 636         TRACE("xlpFile=%s,extension=%s\n", debugstr_w(xlpFile), debugstr_w(extension));
 637
 638         if (extension == NULL || extension[1]==0)
 639         {
 640             WARN("Returning SE_ERR_NOASSOC\n");
 641             return SE_ERR_NOASSOC;
 642         }
 643
 644         /* Three places to check: */
 645         /* 1. win.ini, [windows], programs (NB no leading '.') */
 646         /* 2. Registry, HKEY_CLASS_ROOT\<classname>\shell\open\command */
 647         /* 3. win.ini, [extensions], extension (NB no leading '.' */
 648         /* All I know of the order is that registry is checked before */
 649         /* extensions; however, it'd make sense to check the programs */
 650         /* section first, so that's what happens here. */
 651
 652         /* See if it's a program - if GetProfileString fails, we skip this
 653          * section. Actually, if GetProfileString fails, we've probably
 654          * got a lot more to worry about than running a program... */
 655         if (GetProfileStringW(wWindows, wPrograms, wExtensions, wBuffer, ARRAY_SIZE(wBuffer)) > 0)
 656         {
 657             CharLowerW(wBuffer);
 658             tok = wBuffer;
 659             while (*tok)
 660             {
 661                 WCHAR *p = tok;
 662                 while (*p && *p != ' ' && *p != '\t') p++;
 663                 if (*p)
 664                 {
 665                     *p++ = 0;
 666                     while (*p == ' ' || *p == '\t') p++;
 667                 }
 668
 669                 if (strcmpiW(tok, &extension[1]) == 0) /* have to skip the leading "." */
 670                 {
 671                     strcpyW(lpResult, xlpFile);
 672                     /* Need to perhaps check that the file has a path
 673                      * attached */
 674                     TRACE("found %s\n", debugstr_w(lpResult));
 675                     return 33;
 676                     /* Greater than 32 to indicate success */
 677                 }
 678                 tok = p;
 679             }
 680         }
 681
 682         /* Check registry */
 683         if (RegQueryValueW(HKEY_CLASSES_ROOT, extension, classname,
 684                            &classnamelen) == ERROR_SUCCESS)
 685         {
 686             classnamelen /= sizeof(WCHAR);
 687             if (classnamelen == ARRAY_SIZE(classname))
 688                 classnamelen--;
 689             classname[classnamelen] = '\0';
 690             TRACE("File type: %s\n", debugstr_w(classname));
 691         }
 692         else
 693         {
 694             *classname = '\0';
 695         }
 696     }
 697
 698     if (*classname)
 699     {
 700         /* pass the verb string to SHELL_FindExecutableByVerb() */
 701         retval = SHELL_FindExecutableByVerb(lpVerb, key, classname, command, sizeof(command));
 702
 703         if (retval > 32)
 704         {
 705             DWORD finishedLen;
 706             SHELL_ArgifyW(lpResult, resultLen, command, xlpFile, pidl, args, &finishedLen);
 707             if (finishedLen > resultLen)
 708                 ERR("Argify buffer not large enough.. truncated\n");
 709
 710             /* Remove double quotation marks and command line arguments */
 711             if (*lpResult == '"')
 712             {
 713                 WCHAR *p = lpResult;
 714                 while (*(p + 1) != '"')
 715                 {
 716                     *p = *(p + 1);
 717                     p++;
 718                 }
 719                 *p = '\0';
 720             }
 721             else
 722             {
 723                 /* Truncate on first space */
 724                 WCHAR *p = lpResult;
 725                 while (*p != ' ' && *p != '\0')
 726                     p++;
 727                 *p='\0';
 728             }
 729         }
 730     }
 731     else /* Check win.ini */
 732     {
 733         static const WCHAR wExtensions[] = {'e','x','t','e','n','s','i','o','n','s',0};
 734
 735         /* Toss the leading dot */
 736         extension++;
 737         if (GetProfileStringW(wExtensions, extension, wszEmpty, command, ARRAY_SIZE(command)) > 0)
 738         {
 739             if (*command)
 740             {
 741                 strcpyW(lpResult, command);
 742                 tok = strchrW(lpResult, '^'); /* should be ^.extension? */
 743                 if (tok != NULL)
 744                 {
 745                     tok[0] = '\0';
 746                     strcatW(lpResult, xlpFile); /* what if no dir in xlpFile? */
 747                     tok = strchrW(command, '^'); /* see above */
 748                     if ((tok != NULL) && (strlenW(tok)>5))
 749                     {
 750                         strcatW(lpResult, &tok[5]);
 751                     }
 752                 }
 753                 retval = 33; /* FIXME - see above */
 754             }
 755         }
 756     }
 757
 758     TRACE("returning %s\n", debugstr_w(lpResult));
 759     return retval;
 760 }
 761
 762 /******************************************************************
 763  *              dde_cb
 764  *
 765  * callback for the DDE connection. not really useful
 766  */
 767 static HDDEDATA CALLBACK dde_cb(UINT uType, UINT uFmt, HCONV hConv,
 768                                 HSZ hsz1, HSZ hsz2, HDDEDATA hData,
 769                                 ULONG_PTR dwData1, ULONG_PTR dwData2)
 770 {
 771     TRACE("dde_cb: %04x, %04x, %p, %p, %p, %p, %08lx, %08lx\n",
 772            uType, uFmt, hConv, hsz1, hsz2, hData, dwData1, dwData2);
 773     return NULL;
 774 }
 775
 776 /******************************************************************
 777  *              dde_connect
 778  *
 779  * ShellExecute helper. Used to do an operation with a DDE connection
 780  *
 781  * Handles both the direct connection (try #1), and if it fails,
 782  * launching an application and trying (#2) to connect to it
 783  *
 784  */
 785 static unsigned dde_connect(const WCHAR* key, const WCHAR* start, WCHAR* ddeexec,
 786                             const WCHAR* lpFile, WCHAR *env,
 787                             LPCWSTR szCommandline, LPITEMIDLIST pidl, SHELL_ExecuteW32 execfunc,
 788                             const SHELLEXECUTEINFOW *psei, LPSHELLEXECUTEINFOW psei_out)
 789 {
 790     static const WCHAR wApplication[] = {'\\','a','p','p','l','i','c','a','t','i','o','n',0};
 791     static const WCHAR wTopic[] = {'\\','t','o','p','i','c',0};
 792     WCHAR       regkey[256];
 793     WCHAR *     endkey = regkey + strlenW(key);
 794     WCHAR       app[256], topic[256], ifexec[256], static_res[256];
 795     WCHAR *     dynamic_res=NULL;
 796     WCHAR *     res;
 797     LONG        applen, topiclen, ifexeclen;
 798     WCHAR *     exec;
 799     DWORD       ddeInst = 0;
 800     DWORD       tid;
 801     DWORD       resultLen, endkeyLen;
 802     HSZ         hszApp, hszTopic;
 803     HCONV       hConv;
 804     HDDEDATA    hDdeData;
 805     unsigned    ret = SE_ERR_NOASSOC;
 806     BOOL unicode = !(GetVersion() & 0x80000000);
 807
 808     if (strlenW(key) + 1 > ARRAY_SIZE(regkey))
 809     {
 810         FIXME("input parameter %s larger than buffer\n", debugstr_w(key));
 811         return 2;
 812     }
 813     strcpyW(regkey, key);
 814     endkeyLen = ARRAY_SIZE(regkey) - (endkey - regkey);
 815     if (strlenW(wApplication) + 1 > endkeyLen)
 816     {
 817         FIXME("endkey %s overruns buffer\n", debugstr_w(wApplication));
 818         return 2;
 819     }
 820     strcpyW(endkey, wApplication);
 821     applen = sizeof(app);
 822     if (RegQueryValueW(HKEY_CLASSES_ROOT, regkey, app, &applen) != ERROR_SUCCESS)
 823     {
 824         WCHAR command[1024], fullpath[MAX_PATH];
 825         static const WCHAR wSo[] = { '.','s','o',0 };
 826         int sizeSo = ARRAY_SIZE(wSo);
 827         LPWSTR ptr = NULL;
 828         DWORD ret = 0;
 829
 830         /* Get application command from start string and find filename of application */
 831         if (*start == '"')
 832         {
 833             if (strlenW(start + 1) + 1 > ARRAY_SIZE(command))
 834             {
 835                 FIXME("size of input parameter %s larger than buffer\n",
 836                       debugstr_w(start + 1));
 837                 return 2;
 838             }
 839             strcpyW(command, start+1);
 840             if ((ptr = strchrW(command, '"')))
 841                 *ptr = 0;
 842             ret = SearchPathW(NULL, command, wszExe, ARRAY_SIZE(fullpath), fullpath, &ptr);
 843         }
 844         else
 845         {
 846             LPCWSTR p;
 847             LPWSTR space;
 848             for (p=start; (space=strchrW(p, ' ')); p=space+1)
 849             {
 850                 int idx = space-start;
 851                 memcpy(command, start, idx*sizeof(WCHAR));
 852                 command[idx] = '\0';
 853                 if ((ret = SearchPathW(NULL, command, wszExe, ARRAY_SIZE(fullpath), fullpath, &ptr)))
 854                     break;
 855             }
 856             if (!ret)
 857                 ret = SearchPathW(NULL, start, wszExe, ARRAY_SIZE(fullpath), fullpath, &ptr);
 858         }
 859
 860         if (!ret)
 861         {
 862             ERR("Unable to find application path for command %s\n", debugstr_w(start));
 863             return ERROR_ACCESS_DENIED;
 864         }
 865         if (strlenW(ptr) + 1 > ARRAY_SIZE(app))
 866         {
 867             FIXME("size of found path %s larger than buffer\n", debugstr_w(ptr));
 868             return 2;
 869         }
 870         strcpyW(app, ptr);
 871
 872         /* Remove extensions (including .so) */
 873         ptr = app + strlenW(app) - (sizeSo-1);
 874         if (strlenW(app) >= sizeSo &&
 875             !strcmpW(ptr, wSo))
 876             *ptr = 0;
 877
 878         ptr = strrchrW(app, '.');
 879         assert(ptr);
 880         *ptr = 0;
 881     }
 882
 883     if (strlenW(wTopic) + 1 > endkeyLen)
 884     {
 885         FIXME("endkey %s overruns buffer\n", debugstr_w(wTopic));
 886         return 2;
 887     }
 888     strcpyW(endkey, wTopic);
 889     topiclen = sizeof(topic);
 890     if (RegQueryValueW(HKEY_CLASSES_ROOT, regkey, topic, &topiclen) != ERROR_SUCCESS)
 891     {
 892         static const WCHAR wSystem[] = {'S','y','s','t','e','m',0};
 893         strcpyW(topic, wSystem);
 894     }
 895
 896     if (unicode)
 897     {
 898         if (DdeInitializeW(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR)
 899             return 2;
 900     }
 901     else
 902     {
 903         if (DdeInitializeA(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR)
 904             return 2;
 905     }
 906
 907     hszApp = DdeCreateStringHandleW(ddeInst, app, CP_WINUNICODE);
 908     hszTopic = DdeCreateStringHandleW(ddeInst, topic, CP_WINUNICODE);
 909
 910     hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
 911     exec = ddeexec;
 912     if (!hConv)
 913     {
 914         static const WCHAR wIfexec[] = {'\\','i','f','e','x','e','c',0};
 915         TRACE("Launching %s\n", debugstr_w(start));
 916         ret = execfunc(start, env, TRUE, psei, psei_out);
 917         if (ret <= 32)
 918         {
 919             TRACE("Couldn't launch\n");
 920             goto error;
 921         }
 922         hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
 923         if (!hConv)
 924         {
 925             TRACE("Couldn't connect. ret=%d\n", ret);
 926             DdeUninitialize(ddeInst);
 927             SetLastError(ERROR_DDE_FAIL);
 928             return 30; /* whatever */
 929         }
 930         if (strlenW(wIfexec) + 1 > endkeyLen)
 931         {
 932             FIXME("endkey %s overruns buffer\n", debugstr_w(wIfexec));
 933             return 2;
 934         }
 935         strcpyW(endkey, wIfexec);
 936         ifexeclen = sizeof(ifexec);
 937         if (RegQueryValueW(HKEY_CLASSES_ROOT, regkey, ifexec, &ifexeclen) == ERROR_SUCCESS)
 938         {
 939             exec = ifexec;
 940         }
 941     }
 942
 943     SHELL_ArgifyW(static_res, ARRAY_SIZE(static_res), exec, lpFile, pidl, szCommandline, &resultLen);
 944     if (resultLen > ARRAY_SIZE(static_res))
 945     {
 946         res = dynamic_res = heap_alloc(resultLen * sizeof(WCHAR));
 947         SHELL_ArgifyW(dynamic_res, resultLen, exec, lpFile, pidl, szCommandline, NULL);
 948     }
 949     else
 950         res = static_res;
 951     TRACE("%s %s => %s\n", debugstr_w(exec), debugstr_w(lpFile), debugstr_w(res));
 952
 953     /* It's documented in the KB 330337 that IE has a bug and returns
 954      * error DMLERR_NOTPROCESSED on XTYP_EXECUTE request.
 955      */
 956     if (unicode)
 957         hDdeData = DdeClientTransaction((LPBYTE)res, (strlenW(res) + 1) * sizeof(WCHAR), hConv, 0L, 0,
 958                                          XTYP_EXECUTE, 30000, &tid);
 959     else
 960     {
 961         DWORD lenA = WideCharToMultiByte(CP_ACP, 0, res, -1, NULL, 0, NULL, NULL);
 962         char *resA = heap_alloc(lenA);
 963         WideCharToMultiByte(CP_ACP, 0, res, -1, resA, lenA, NULL, NULL);
 964         hDdeData = DdeClientTransaction( (LPBYTE)resA, lenA, hConv, 0L, 0,
 965                                          XTYP_EXECUTE, 10000, &tid );
 966         heap_free(resA);
 967     }
 968     if (hDdeData)
 969         DdeFreeDataHandle(hDdeData);
 970     else
 971         WARN("DdeClientTransaction failed with error %04x\n", DdeGetLastError(ddeInst));
 972     ret = 33;
 973
 974     heap_free(dynamic_res);
 975
 976     DdeDisconnect(hConv);
 977
 978  error:
 979     DdeUninitialize(ddeInst);
 980
 981     return ret;
 982 }
 983
 984 /*************************************************************************
 985  *      execute_from_key [Internal]
 986  */
 987 static UINT_PTR execute_from_key(LPCWSTR key, LPCWSTR lpFile, WCHAR *env, LPCWSTR szCommandline,
 988                              LPCWSTR executable_name,
 989                              SHELL_ExecuteW32 execfunc,
 990                              LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out)
 991 {
 992     static const WCHAR wCommand[] = {'c','o','m','m','a','n','d',0};
 993     static const WCHAR wDdeexec[] = {'d','d','e','e','x','e','c',0};
 994     WCHAR cmd[256], param[1024], ddeexec[256];
 995     LONG cmdlen = sizeof(cmd), ddeexeclen = sizeof(ddeexec);
 996     UINT_PTR retval = SE_ERR_NOASSOC;
 997     DWORD resultLen;
 998     LPWSTR tmp;
 999
1000     TRACE("%s %s %s %s %s\n", debugstr_w(key), debugstr_w(lpFile), debugstr_w(env),
1001            debugstr_w(szCommandline), debugstr_w(executable_name));
1002
1003     cmd[0] = '\0';
1004     param[0] = '\0';
1005
1006     /* Get the application from the registry */
1007     if (RegQueryValueW(HKEY_CLASSES_ROOT, key, cmd, &cmdlen) == ERROR_SUCCESS)
1008     {
1009         TRACE("got cmd: %s\n", debugstr_w(cmd));
1010
1011         /* Is there a replace() function anywhere? */
1012         cmdlen /= sizeof(WCHAR);
1013         if (cmdlen >= ARRAY_SIZE(cmd))
1014             cmdlen = ARRAY_SIZE(cmd) - 1;
1015         cmd[cmdlen] = '\0';
1016         SHELL_ArgifyW(param, ARRAY_SIZE(param), cmd, lpFile, psei->lpIDList, szCommandline, &resultLen);
1017         if (resultLen > ARRAY_SIZE(param))
1018             ERR("Argify buffer not large enough, truncating\n");
1019     }
1020
1021     /* Get the parameters needed by the application
1022        from the associated ddeexec key */
1023     tmp = strstrW(key, wCommand);
1024     assert(tmp);
1025     strcpyW(tmp, wDdeexec);
1026
1027     if (RegQueryValueW(HKEY_CLASSES_ROOT, key, ddeexec, &ddeexeclen) == ERROR_SUCCESS)
1028     {
1029         TRACE("Got ddeexec %s => %s\n", debugstr_w(key), debugstr_w(ddeexec));
1030         if (!param[0]) strcpyW(param, executable_name);
1031         retval = dde_connect(key, param, ddeexec, lpFile, env, szCommandline, psei->lpIDList, execfunc, psei, psei_out);
1032     }
1033     else if (param[0])
1034     {
1035         TRACE("executing: %s\n", debugstr_w(param));
1036         retval = execfunc(param, env, FALSE, psei, psei_out);
1037     }
1038     else
1039         WARN("Nothing appropriate found for %s\n", debugstr_w(key));
1040
1041     return retval;
1042 }
1043
1044 /*************************************************************************
1045  * FindExecutableA                      [SHELL32.@]
1046  */
1047 HINSTANCE WINAPI FindExecutableA(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult)
1048 {
1049     HINSTANCE retval;
1050     WCHAR *wFile = NULL, *wDirectory = NULL;
1051     WCHAR wResult[MAX_PATH];
1052
1053     if (lpFile) __SHCloneStrAtoW(&wFile, lpFile);
1054     if (lpDirectory) __SHCloneStrAtoW(&wDirectory, lpDirectory);
1055
1056     retval = FindExecutableW(wFile, wDirectory, wResult);
1057     WideCharToMultiByte(CP_ACP, 0, wResult, -1, lpResult, MAX_PATH, NULL, NULL);
1058     SHFree( wFile );
1059     SHFree( wDirectory );
1060
1061     TRACE("returning %s\n", lpResult);
1062     return retval;
1063 }
1064
1065 /*************************************************************************
1066  * FindExecutableW                      [SHELL32.@]
1067  *
1068  * This function returns the executable associated with the specified file
1069  * for the default verb.
1070  *
1071  * PARAMS
1072  *  lpFile   [I] The file to find the association for. This must refer to
1073  *               an existing file otherwise FindExecutable fails and returns
1074  *               SE_ERR_FNF.
1075  *  lpResult [O] Points to a buffer into which the executable path is
1076  *               copied. This parameter must not be NULL otherwise
1077  *               FindExecutable() segfaults. The buffer must be of size at
1078  *               least MAX_PATH characters.
1079  *
1080  * RETURNS
1081  *  A value greater than 32 on success, less than or equal to 32 otherwise.
1082  *  See the SE_ERR_* constants.
1083  *
1084  * NOTES
1085  *  On Windows XP and 2003, FindExecutable() seems to first convert the
1086  *  filename into 8.3 format, thus taking into account only the first three
1087  *  characters of the extension, and expects to find an association for those.
1088  *  However other Windows versions behave sanely.
1089  */
1090 HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult)
1091 {
1092     UINT_PTR retval = SE_ERR_NOASSOC;
1093     WCHAR old_dir[1024];
1094     WCHAR res[MAX_PATH];
1095
1096     TRACE("File %s, Dir %s\n", debugstr_w(lpFile), debugstr_w(lpDirectory));
1097
1098     lpResult[0] = '\0'; /* Start off with an empty return string */
1099     if (lpFile == NULL)
1100         return (HINSTANCE)SE_ERR_FNF;
1101
1102     if (lpDirectory)
1103     {
1104         GetCurrentDirectoryW(ARRAY_SIZE(old_dir), old_dir);
1105         SetCurrentDirectoryW(lpDirectory);
1106     }
1107
1108     retval = SHELL_FindExecutable(lpDirectory, lpFile, wszOpen, res, MAX_PATH, NULL, NULL, NULL, NULL);
1109
1110     if (retval > 32)
1111         strcpyW(lpResult, res);
1112
1113     TRACE("returning %s\n", debugstr_w(lpResult));
1114     if (lpDirectory)
1115         SetCurrentDirectoryW(old_dir);
1116     return (HINSTANCE)retval;
1117 }
1118
1119 /* FIXME: is this already implemented somewhere else? */
1120 static HKEY ShellExecute_GetClassKey( const SHELLEXECUTEINFOW *sei )
1121 {
1122     LPCWSTR ext = NULL, lpClass = NULL;
1123     LPWSTR cls = NULL;
1124     DWORD type = 0, sz = 0;
1125     HKEY hkey = 0;
1126     LONG r;
1127
1128     if (sei->fMask & SEE_MASK_CLASSALL)
1129         return sei->hkeyClass;
1130
1131     if (sei->fMask & SEE_MASK_CLASSNAME)
1132         lpClass = sei->lpClass;
1133     else
1134     {
1135         ext = PathFindExtensionW( sei->lpFile );
1136         TRACE("ext = %s\n", debugstr_w( ext ) );
1137         if (!ext)
1138             return hkey;
1139
1140         r = RegOpenKeyW( HKEY_CLASSES_ROOT, ext, &hkey );
1141         if (r != ERROR_SUCCESS )
1142             return hkey;
1143
1144         r = RegQueryValueExW( hkey, NULL, 0, &type, NULL, &sz );
1145         if ( r == ERROR_SUCCESS && type == REG_SZ )
1146         {
1147             sz += sizeof (WCHAR);
1148             cls = heap_alloc( sz );
1149             cls[0] = 0;
1150             RegQueryValueExW( hkey, NULL, 0, &type, (LPBYTE) cls, &sz );
1151         }
1152
1153         RegCloseKey( hkey );
1154         lpClass = cls;
1155     }
1156
1157     TRACE("class = %s\n", debugstr_w(lpClass) );
1158
1159     hkey = 0;
1160     if ( lpClass )
1161         RegOpenKeyW( HKEY_CLASSES_ROOT, lpClass, &hkey );
1162
1163     heap_free( cls );
1164
1165     return hkey;
1166 }
1167
1168 static HRESULT shellex_get_dataobj( LPSHELLEXECUTEINFOW sei, IDataObject **dataobj )
1169 {
1170     LPCITEMIDLIST pidllast = NULL;
1171     IShellFolder *shf = NULL;
1172     LPITEMIDLIST pidl = NULL;
1173     HRESULT r = SE_ERR_DLLNOTFOUND;
1174
1175     if (sei->fMask & SEE_MASK_CLASSALL)
1176         pidl = sei->lpIDList;
1177     else
1178     {
1179         WCHAR fullpath[MAX_PATH];
1180         BOOL ret;
1181
1182         fullpath[0] = 0;
1183         ret = GetFullPathNameW( sei->lpFile, MAX_PATH, fullpath, NULL );
1184         if (!ret)
1185             goto end;
1186
1187         pidl = ILCreateFromPathW( fullpath );
1188     }
1189
1190     r = SHBindToParent( pidl, &IID_IShellFolder, (LPVOID*)&shf, &pidllast );
1191     if ( FAILED( r ) )
1192         goto end;
1193
1194     r = IShellFolder_GetUIObjectOf( shf, NULL, 1, &pidllast,
1195                                 &IID_IDataObject, NULL, (void**)dataobj );
1196
1197 end:
1198     if ( pidl != sei->lpIDList )
1199         ILFree( pidl );
1200     if ( shf )
1201         IShellFolder_Release( shf );
1202     return r;
1203 }
1204
1205 static HRESULT shellex_run_context_menu_default( IShellExtInit *obj,
1206                                                  LPSHELLEXECUTEINFOW sei )
1207 {
1208     IContextMenu *cm = NULL;
1209     CMINVOKECOMMANDINFOEX ici;
1210     MENUITEMINFOW info;
1211     WCHAR string[0x80];
1212     INT i, n, def = -1;
1213     HMENU hmenu = 0;
1214     HRESULT r;
1215
1216     TRACE("%p %p\n", obj, sei );
1217
1218     r = IShellExtInit_QueryInterface( obj, &IID_IContextMenu, (LPVOID*) &cm );
1219     if ( FAILED( r ) )
1220         return r;
1221
1222     hmenu = CreateMenu();
1223     if ( !hmenu )
1224         goto end;
1225
1226     /* the number of the last menu added is returned in r */
1227     r = IContextMenu_QueryContextMenu( cm, hmenu, 0, 0x20, 0x7fff, CMF_DEFAULTONLY );
1228     if ( FAILED( r ) )
1229         goto end;
1230
1231     n = GetMenuItemCount( hmenu );
1232     for ( i = 0; i < n; i++ )
1233     {
1234         memset( &info, 0, sizeof info );
1235         info.cbSize = sizeof info;
1236         info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_DATA | MIIM_ID;
1237         info.dwTypeData = string;
1238         info.cch = ARRAY_SIZE(string);
1239         string[0] = 0;
1240         GetMenuItemInfoW( hmenu, i, TRUE, &info );
1241
1242         TRACE("menu %d %s %08x %08lx %08x %08x\n", i, debugstr_w(string),
1243             info.fState, info.dwItemData, info.fType, info.wID );
1244         if ( ( !sei->lpVerb && (info.fState & MFS_DEFAULT) ) ||
1245              ( sei->lpVerb && !lstrcmpiW( sei->lpVerb, string ) ) )
1246         {
1247             def = i;
1248             break;
1249         }
1250     }
1251
1252     r = E_FAIL;
1253     if ( def == -1 )
1254         goto end;
1255
1256     memset( &ici, 0, sizeof ici );
1257     ici.cbSize = sizeof ici;
1258     ici.fMask = CMIC_MASK_UNICODE | (sei->fMask & (SEE_MASK_NO_CONSOLE|SEE_MASK_NOASYNC|SEE_MASK_ASYNCOK|SEE_MASK_FLAG_NO_UI));
1259     ici.nShow = sei->nShow;
1260     ici.lpVerb = MAKEINTRESOURCEA( def );
1261     ici.hwnd = sei->hwnd;
1262     ici.lpParametersW = sei->lpParameters;
1263
1264     r = IContextMenu_InvokeCommand( cm, (LPCMINVOKECOMMANDINFO) &ici );
1265
1266     TRACE("invoke command returned %08x\n", r );
1267
1268 end:
1269     if ( hmenu )
1270         DestroyMenu( hmenu );
1271     if ( cm )
1272         IContextMenu_Release( cm );
1273     return r;
1274 }
1275
1276 static HRESULT shellex_load_object_and_run( HKEY hkey, LPCGUID guid, LPSHELLEXECUTEINFOW sei )
1277 {
1278     IDataObject *dataobj = NULL;
1279     IObjectWithSite *ows = NULL;
1280     IShellExtInit *obj = NULL;
1281     HRESULT r;
1282
1283     TRACE("%p %s %p\n", hkey, debugstr_guid( guid ), sei );
1284
1285     r = CoInitialize( NULL );
1286     if ( FAILED( r ) )
1287         goto end;
1288
1289     r = CoCreateInstance( guid, NULL, CLSCTX_INPROC_SERVER,
1290                            &IID_IShellExtInit, (LPVOID*)&obj );
1291     if ( FAILED( r ) )
1292     {
1293         ERR("failed %08x\n", r );
1294         goto end;
1295     }
1296
1297     r = shellex_get_dataobj( sei, &dataobj );
1298     if ( FAILED( r ) )
1299     {
1300         ERR("failed to get data object\n");
1301         goto end;
1302     }
1303
1304     r = IShellExtInit_Initialize( obj, NULL, dataobj, hkey );
1305     if ( FAILED( r ) )
1306         goto end;
1307
1308     r = IShellExtInit_QueryInterface( obj, &IID_IObjectWithSite, (LPVOID*) &ows );
1309     if ( FAILED( r ) )
1310         goto end;
1311
1312     IObjectWithSite_SetSite( ows, NULL );
1313
1314     r = shellex_run_context_menu_default( obj, sei );
1315
1316 end:
1317     if ( ows )
1318         IObjectWithSite_Release( ows );
1319     if ( dataobj )
1320         IDataObject_Release( dataobj );
1321     if ( obj )
1322         IShellExtInit_Release( obj );
1323     CoUninitialize();
1324     return r;
1325 }
1326
1327
1328 /*************************************************************************
1329  *      ShellExecute_FromContextMenu [Internal]
1330  */
1331 static LONG ShellExecute_FromContextMenu( LPSHELLEXECUTEINFOW sei )
1332 {
1333     static const WCHAR szcm[] = { 's','h','e','l','l','e','x','\\',
1334         'C','o','n','t','e','x','t','M','e','n','u','H','a','n','d','l','e','r','s',0 };
1335     HKEY hkey, hkeycm = 0;
1336     WCHAR szguid[39];
1337     HRESULT hr;
1338     GUID guid;
1339     DWORD i;
1340     LONG r;
1341
1342     TRACE("%s\n", debugstr_w(sei->lpFile) );
1343
1344     hkey = ShellExecute_GetClassKey( sei );
1345     if ( !hkey )
1346         return ERROR_FUNCTION_FAILED;
1347
1348     r = RegOpenKeyW( hkey, szcm, &hkeycm );
1349     if ( r == ERROR_SUCCESS )
1350     {
1351         i = 0;
1352         while ( 1 )
1353         {
1354             r = RegEnumKeyW( hkeycm, i++, szguid, ARRAY_SIZE(szguid));
1355             if ( r != ERROR_SUCCESS )
1356                 break;
1357
1358             hr = CLSIDFromString( szguid, &guid );
1359             if (SUCCEEDED(hr))
1360             {
1361                 /* stop at the first one that succeeds in running */
1362                 hr = shellex_load_object_and_run( hkey, &guid, sei );
1363                 if ( SUCCEEDED( hr ) )
1364                     break;
1365             }
1366         }
1367         RegCloseKey( hkeycm );
1368     }
1369
1370     if ( hkey != sei->hkeyClass )
1371         RegCloseKey( hkey );
1372     return r;
1373 }
1374
1375 static UINT_PTR SHELL_quote_and_execute( LPCWSTR wcmd, LPCWSTR wszParameters, LPCWSTR lpstrProtocol, LPCWSTR wszApplicationName, LPWSTR env, LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out, SHELL_ExecuteW32 execfunc );
1376
1377 static UINT_PTR SHELL_execute_class( LPCWSTR wszApplicationName, LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out, SHELL_ExecuteW32 execfunc )
1378 {
1379     static const WCHAR wQuote[] = {'"',0};
1380     static const WCHAR wSpace[] = {' ',0};
1381     WCHAR execCmd[1024], classname[1024];
1382     /* launch a document by fileclass like 'WordPad.Document.1' */
1383     /* the Commandline contains 'c:\Path\wordpad.exe "%1"' */
1384     /* FIXME: wcmd should not be of a fixed size. Fixed to 1024, MAX_PATH is way too short! */
1385     ULONG cmask=(psei->fMask & SEE_MASK_CLASSALL);
1386     DWORD resultLen;
1387     BOOL done;
1388     UINT_PTR rslt;
1389
1390   /* FIXME: remove following block when SHELL_quote_and_execute supports hkeyClass parameter */
1391   if (cmask != SEE_MASK_CLASSNAME)
1392   {
1393     WCHAR wcmd[1024];
1394     HCR_GetExecuteCommandW((cmask == SEE_MASK_CLASSKEY) ? psei->hkeyClass : NULL,
1395                            (cmask == SEE_MASK_CLASSNAME) ? psei->lpClass: NULL,
1396                            psei->lpVerb,
1397                            execCmd, sizeof(execCmd));
1398
1399     /* FIXME: get the extension of lpFile, check if it fits to the lpClass */
1400     TRACE("SEE_MASK_CLASSNAME->%s, doc->%s\n", debugstr_w(execCmd), debugstr_w(wszApplicationName));
1401
1402     wcmd[0] = '\0';
1403     done = SHELL_ArgifyW(wcmd, ARRAY_SIZE(wcmd), execCmd, wszApplicationName, psei->lpIDList, NULL, &resultLen);
1404     if (!done && wszApplicationName[0])
1405     {
1406         strcatW(wcmd, wSpace);
1407         if (*wszApplicationName != '"')
1408         {
1409             strcatW(wcmd, wQuote);
1410             strcatW(wcmd, wszApplicationName);
1411             strcatW(wcmd, wQuote);
1412         }
1413         else
1414             strcatW(wcmd, wszApplicationName);
1415     }
1416     if (resultLen > ARRAY_SIZE(wcmd))
1417         ERR("Argify buffer not large enough... truncating\n");
1418     return execfunc(wcmd, NULL, FALSE, psei, psei_out);
1419   }
1420
1421     strcpyW(classname, psei->lpClass);
1422     rslt = SHELL_FindExecutableByVerb(psei->lpVerb, NULL, classname, execCmd, sizeof(execCmd));
1423
1424     TRACE("SHELL_FindExecutableByVerb returned %u (%s, %s)\n", (unsigned int)rslt, debugstr_w(classname), debugstr_w(execCmd));
1425     if (33 > rslt)
1426         return rslt;
1427     rslt = SHELL_quote_and_execute( execCmd, wszEmpty, classname,
1428                                       wszApplicationName, NULL, psei,
1429                                       psei_out, execfunc );
1430     return rslt;
1431 }
1432
1433 static void SHELL_translate_idlist( LPSHELLEXECUTEINFOW sei, LPWSTR wszParameters, DWORD parametersLen, LPWSTR wszApplicationName, DWORD dwApplicationNameLen )
1434 {
1435     static const WCHAR wExplorer[] = {'e','x','p','l','o','r','e','r','.','e','x','e',0};
1436     WCHAR buffer[MAX_PATH];
1437
1438     /* last chance to translate IDList: now also allow CLSID paths */
1439     if (SUCCEEDED(SHELL_GetPathFromIDListForExecuteW(sei->lpIDList, buffer, ARRAY_SIZE(buffer)))) {
1440         if (buffer[0]==':' && buffer[1]==':') {
1441             /* open shell folder for the specified class GUID */
1442             if (strlenW(buffer) + 1 > parametersLen)
1443                 ERR("parameters len exceeds buffer size (%i > %i), truncating\n",
1444                     lstrlenW(buffer) + 1, parametersLen);
1445             lstrcpynW(wszParameters, buffer, parametersLen);
1446             if (strlenW(wExplorer) > dwApplicationNameLen)
1447                 ERR("application len exceeds buffer size (%i > %i), truncating\n",
1448                     lstrlenW(wExplorer) + 1, dwApplicationNameLen);
1449             lstrcpynW(wszApplicationName, wExplorer, dwApplicationNameLen);
1450
1451             sei->fMask &= ~SEE_MASK_INVOKEIDLIST;
1452         } else {
1453             WCHAR target[MAX_PATH];
1454             DWORD attribs;
1455             DWORD resultLen;
1456             /* Check if we're executing a directory and if so use the
1457                handler for the Folder class */
1458             strcpyW(target, buffer);
1459             attribs = GetFileAttributesW(buffer);
1460             if (attribs != INVALID_FILE_ATTRIBUTES &&
1461                 (attribs & FILE_ATTRIBUTE_DIRECTORY) &&
1462                 HCR_GetExecuteCommandW(0, wszFolder,
1463                                        sei->lpVerb,
1464                                        buffer, sizeof(buffer))) {
1465                 SHELL_ArgifyW(wszApplicationName, dwApplicationNameLen,
1466                               buffer, target, sei->lpIDList, NULL, &resultLen);
1467                 if (resultLen > dwApplicationNameLen)
1468                     ERR("Argify buffer not large enough... truncating\n");
1469             }
1470             sei->fMask &= ~SEE_MASK_INVOKEIDLIST;
1471         }
1472     }
1473 }
1474
1475 static UINT_PTR SHELL_quote_and_execute( LPCWSTR wcmd, LPCWSTR wszParameters, LPCWSTR wszKeyname, LPCWSTR wszApplicationName, LPWSTR env, LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out, SHELL_ExecuteW32 execfunc )
1476 {
1477     static const WCHAR wQuote[] = {'"',0};
1478     static const WCHAR wSpace[] = {' ',0};
1479     UINT_PTR retval;
1480     DWORD len;
1481     WCHAR *wszQuotedCmd;
1482
1483     /* Length of quotes plus length of command plus NULL terminator */
1484     len = 2 + lstrlenW(wcmd) + 1;
1485     if (wszParameters[0])
1486     {
1487         /* Length of space plus length of parameters */
1488         len += 1 + lstrlenW(wszParameters);
1489     }
1490     wszQuotedCmd = heap_alloc(len * sizeof(WCHAR));
1491     /* Must quote to handle case where cmd contains spaces,
1492      * else security hole if malicious user creates executable file "C:\\Program"
1493      */
1494     strcpyW(wszQuotedCmd, wQuote);
1495     strcatW(wszQuotedCmd, wcmd);
1496     strcatW(wszQuotedCmd, wQuote);
1497     if (wszParameters[0]) {
1498         strcatW(wszQuotedCmd, wSpace);
1499         strcatW(wszQuotedCmd, wszParameters);
1500     }
1501     TRACE("%s/%s => %s/%s\n", debugstr_w(wszApplicationName), debugstr_w(psei->lpVerb), debugstr_w(wszQuotedCmd), debugstr_w(wszKeyname));
1502     if (*wszKeyname)
1503         retval = execute_from_key(wszKeyname, wszApplicationName, env, psei->lpParameters, wcmd, execfunc, psei, psei_out);
1504     else
1505         retval = execfunc(wszQuotedCmd, env, FALSE, psei, psei_out);
1506     heap_free(wszQuotedCmd);
1507     return retval;
1508 }
1509
1510 static UINT_PTR SHELL_execute_url( LPCWSTR lpFile, LPCWSTR wcmd, LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out, SHELL_ExecuteW32 execfunc )
1511 {
1512     static const WCHAR wShell[] = {'\\','s','h','e','l','l','\\',0};
1513     static const WCHAR wCommand[] = {'\\','c','o','m','m','a','n','d',0};
1514     UINT_PTR retval;
1515     WCHAR *lpstrProtocol;
1516     LPCWSTR lpstrRes;
1517     INT iSize;
1518     DWORD len;
1519
1520     lpstrRes = strchrW(lpFile, ':');
1521     if (lpstrRes)
1522         iSize = lpstrRes - lpFile;
1523     else
1524         iSize = strlenW(lpFile);
1525
1526     TRACE("Got URL: %s\n", debugstr_w(lpFile));
1527     /* Looking for ...<protocol>\shell\<lpVerb>\command */
1528     len = iSize + lstrlenW(wShell) + lstrlenW(wCommand) + 1;
1529     if (psei->lpVerb && *psei->lpVerb)
1530         len += lstrlenW(psei->lpVerb);
1531     else
1532         len += lstrlenW(wszOpen);
1533     lpstrProtocol = heap_alloc(len * sizeof(WCHAR));
1534     memcpy(lpstrProtocol, lpFile, iSize*sizeof(WCHAR));
1535     lpstrProtocol[iSize] = '\0';
1536     strcatW(lpstrProtocol, wShell);
1537     strcatW(lpstrProtocol, psei->lpVerb && *psei->lpVerb ? psei->lpVerb: wszOpen);
1538     strcatW(lpstrProtocol, wCommand);
1539
1540     retval = execute_from_key(lpstrProtocol, lpFile, NULL, psei->lpParameters,
1541                               wcmd, execfunc, psei, psei_out);
1542     heap_free(lpstrProtocol);
1543     return retval;
1544 }
1545
1546 static void do_error_dialog( UINT_PTR retval, HWND hwnd )
1547 {
1548     WCHAR msg[2048];
1549     int error_code=GetLastError();
1550
1551     if (retval == SE_ERR_NOASSOC)
1552         LoadStringW(shell32_hInstance, IDS_SHLEXEC_NOASSOC, msg, ARRAY_SIZE(msg));
1553     else
1554         FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error_code, 0, msg, ARRAY_SIZE(msg), NULL);
1555
1556     MessageBoxW(hwnd, msg, NULL, MB_ICONERROR);
1557 }
1558
1559 static WCHAR *expand_environment( const WCHAR *str )
1560 {
1561     WCHAR *buf;
1562     DWORD len;
1563
1564     len = ExpandEnvironmentStringsW(str, NULL, 0);
1565     if (!len) return NULL;
1566
1567     buf = heap_alloc(len * sizeof(WCHAR));
1568     if (!buf) return NULL;
1569
1570     len = ExpandEnvironmentStringsW(str, buf, len);
1571     if (!len)
1572     {
1573         heap_free(buf);
1574         return NULL;
1575     }
1576     return buf;
1577 }
1578
1579 /*************************************************************************
1580  *      SHELL_execute [Internal]
1581  */
1582 static BOOL SHELL_execute( LPSHELLEXECUTEINFOW sei, SHELL_ExecuteW32 execfunc )
1583 {
1584     static const WCHAR wWww[] = {'w','w','w',0};
1585     static const WCHAR wHttp[] = {'h','t','t','p',':','/','/',0};
1586     static const DWORD unsupportedFlags =
1587         SEE_MASK_INVOKEIDLIST  | SEE_MASK_ICON         | SEE_MASK_HOTKEY |
1588         SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
1589         SEE_MASK_UNICODE       | SEE_MASK_ASYNCOK      | SEE_MASK_HMONITOR;
1590
1591     WCHAR parametersBuffer[1024], dirBuffer[MAX_PATH], wcmdBuffer[1024];
1592     WCHAR *wszApplicationName, *wszParameters, *wszDir, *wcmd = NULL;
1593     DWORD dwApplicationNameLen = MAX_PATH+2;
1594     DWORD parametersLen = ARRAY_SIZE(parametersBuffer);
1595     DWORD wcmdLen = ARRAY_SIZE(wcmdBuffer);
1596     DWORD len;
1597     SHELLEXECUTEINFOW sei_tmp;  /* modifiable copy of SHELLEXECUTEINFO struct */
1598     WCHAR *env;
1599     WCHAR wszKeyname[256];
1600     LPCWSTR lpFile;
1601     UINT_PTR retval = SE_ERR_NOASSOC;
1602
1603     /* make a local copy of the LPSHELLEXECUTEINFO structure and work with this from now on */
1604     sei_tmp = *sei;
1605
1606     TRACE("mask=0x%08x hwnd=%p verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s\n",
1607             sei_tmp.fMask, sei_tmp.hwnd, debugstr_w(sei_tmp.lpVerb),
1608             debugstr_w(sei_tmp.lpFile), debugstr_w(sei_tmp.lpParameters),
1609             debugstr_w(sei_tmp.lpDirectory), sei_tmp.nShow,
1610             ((sei_tmp.fMask & SEE_MASK_CLASSALL) == SEE_MASK_CLASSNAME) ?
1611                 debugstr_w(sei_tmp.lpClass) : "not used");
1612
1613     sei->hProcess = NULL;
1614
1615     /* make copies of all path/command strings */
1616     if (!sei_tmp.lpFile)
1617     {
1618         wszApplicationName = heap_alloc(dwApplicationNameLen*sizeof(WCHAR));
1619         *wszApplicationName = '\0';
1620     }
1621     else if (*sei_tmp.lpFile == '\"' && sei_tmp.lpFile[(len = strlenW(sei_tmp.lpFile))-1] == '\"')
1622     {
1623         if(len-1 >= dwApplicationNameLen) dwApplicationNameLen = len;
1624         wszApplicationName = heap_alloc(dwApplicationNameLen*sizeof(WCHAR));
1625         memcpy(wszApplicationName, sei_tmp.lpFile+1, len*sizeof(WCHAR));
1626         if(len > 2)
1627             wszApplicationName[len-2] = '\0';
1628         TRACE("wszApplicationName=%s\n",debugstr_w(wszApplicationName));
1629     } else {
1630         DWORD l = strlenW(sei_tmp.lpFile)+1;
1631         if(l > dwApplicationNameLen) dwApplicationNameLen = l+1;
1632         wszApplicationName = heap_alloc(dwApplicationNameLen*sizeof(WCHAR));
1633         memcpy(wszApplicationName, sei_tmp.lpFile, l*sizeof(WCHAR));
1634     }
1635
1636     wszParameters = parametersBuffer;
1637     if (sei_tmp.lpParameters)
1638     {
1639         len = lstrlenW(sei_tmp.lpParameters) + 1;
1640         if (len > parametersLen)
1641         {
1642             wszParameters = heap_alloc(len * sizeof(WCHAR));
1643             parametersLen = len;
1644         }
1645         strcpyW(wszParameters, sei_tmp.lpParameters);
1646     }
1647     else
1648         *wszParameters = '\0';
1649
1650     wszDir = dirBuffer;
1651     if (sei_tmp.lpDirectory)
1652     {
1653         len = lstrlenW(sei_tmp.lpDirectory) + 1;
1654         if (len > ARRAY_SIZE(dirBuffer))
1655             wszDir = heap_alloc(len * sizeof(WCHAR));
1656         strcpyW(wszDir, sei_tmp.lpDirectory);
1657     }
1658     else
1659         *wszDir = '\0';
1660
1661     /* adjust string pointers to point to the new buffers */
1662     sei_tmp.lpFile = wszApplicationName;
1663     sei_tmp.lpParameters = wszParameters;
1664     sei_tmp.lpDirectory = wszDir;
1665
1666     if (sei_tmp.fMask & unsupportedFlags)
1667     {
1668         FIXME("flags ignored: 0x%08x\n", sei_tmp.fMask & unsupportedFlags);
1669     }
1670
1671     /* process the IDList */
1672     if (sei_tmp.fMask & SEE_MASK_IDLIST)
1673     {
1674         IShellExecuteHookW* pSEH;
1675
1676         HRESULT hr = SHBindToParent(sei_tmp.lpIDList, &IID_IShellExecuteHookW, (LPVOID*)&pSEH, NULL);
1677
1678         if (SUCCEEDED(hr))
1679         {
1680             hr = IShellExecuteHookW_Execute(pSEH, &sei_tmp);
1681
1682             IShellExecuteHookW_Release(pSEH);
1683
1684             if (hr == S_OK) {
1685                 heap_free(wszApplicationName);
1686                 if (wszParameters != parametersBuffer)
1687                     heap_free(wszParameters);
1688                 if (wszDir != dirBuffer)
1689                     heap_free(wszDir);
1690                 return TRUE;
1691             }
1692         }
1693
1694         SHGetPathFromIDListW(sei_tmp.lpIDList, wszApplicationName);
1695         TRACE("-- idlist=%p (%s)\n", sei_tmp.lpIDList, debugstr_w(wszApplicationName));
1696     }
1697
1698     if (sei_tmp.fMask & SEE_MASK_DOENVSUBST)
1699     {
1700         WCHAR *tmp;
1701
1702         tmp = expand_environment(sei_tmp.lpFile);
1703         if (!tmp)
1704         {
1705             retval = SE_ERR_OOM;
1706             goto end;
1707         }
1708         heap_free(wszApplicationName);
1709         sei_tmp.lpFile = wszApplicationName = tmp;
1710
1711         tmp = expand_environment(sei_tmp.lpDirectory);
1712         if (!tmp)
1713         {
1714             retval = SE_ERR_OOM;
1715             goto end;
1716         }
1717         if (wszDir != dirBuffer)
1718             heap_free(wszDir);
1719         sei_tmp.lpDirectory = wszDir = tmp;
1720     }
1721
1722     if ( ERROR_SUCCESS == ShellExecute_FromContextMenu( &sei_tmp ) )
1723     {
1724         sei->hInstApp = (HINSTANCE) 33;
1725         heap_free(wszApplicationName);
1726         if (wszParameters != parametersBuffer)
1727             heap_free(wszParameters);
1728         if (wszDir != dirBuffer)
1729             heap_free(wszDir);
1730         return TRUE;
1731     }
1732
1733     if (sei_tmp.fMask & SEE_MASK_CLASSALL)
1734     {
1735         retval = SHELL_execute_class( wszApplicationName, &sei_tmp, sei,
1736                                       execfunc );
1737         if (retval <= 32 && !(sei_tmp.fMask & SEE_MASK_FLAG_NO_UI))
1738             do_error_dialog(retval, sei_tmp.hwnd);
1739         heap_free(wszApplicationName);
1740         if (wszParameters != parametersBuffer)
1741             heap_free(wszParameters);
1742         if (wszDir != dirBuffer)
1743             heap_free(wszDir);
1744         return retval > 32;
1745     }
1746
1747     /* Has the IDList not yet been translated? */
1748     if (sei_tmp.fMask & SEE_MASK_IDLIST)
1749     {
1750         SHELL_translate_idlist( &sei_tmp, wszParameters,
1751                                 parametersLen,
1752                                 wszApplicationName,
1753                                 dwApplicationNameLen );
1754     }
1755
1756     /* convert file URLs */
1757     if (UrlIsFileUrlW(sei_tmp.lpFile))
1758     {
1759         LPWSTR buf;
1760         DWORD size;
1761
1762         size = MAX_PATH;
1763         buf = heap_alloc(size * sizeof(WCHAR));
1764         if (!buf || FAILED(PathCreateFromUrlW(sei_tmp.lpFile, buf, &size, 0))) {
1765             heap_free(buf);
1766             return SE_ERR_OOM;
1767         }
1768
1769         heap_free(wszApplicationName);
1770         wszApplicationName = buf;
1771         sei_tmp.lpFile = wszApplicationName;
1772     }
1773     else /* or expand environment strings (not both!) */
1774     {
1775         len = ExpandEnvironmentStringsW(sei_tmp.lpFile, NULL, 0);
1776         if (len>0)
1777         {
1778             LPWSTR buf;
1779             buf = heap_alloc((len + 1) * sizeof(WCHAR));
1780
1781             ExpandEnvironmentStringsW(sei_tmp.lpFile, buf, len + 1);
1782             heap_free(wszApplicationName);
1783             wszApplicationName = buf;
1784
1785             sei_tmp.lpFile = wszApplicationName;
1786         }
1787     }
1788
1789     if (*sei_tmp.lpDirectory)
1790     {
1791         len = ExpandEnvironmentStringsW(sei_tmp.lpDirectory, NULL, 0);
1792         if (len > 0)
1793         {
1794             LPWSTR buf;
1795             len++;
1796             buf = heap_alloc(len * sizeof(WCHAR));
1797             ExpandEnvironmentStringsW(sei_tmp.lpDirectory, buf, len);
1798             if (wszDir != dirBuffer)
1799                 heap_free(wszDir);
1800             wszDir = buf;
1801             sei_tmp.lpDirectory = wszDir;
1802         }
1803     }
1804
1805     /* Else, try to execute the filename */
1806     TRACE("execute:%s,%s,%s\n", debugstr_w(wszApplicationName), debugstr_w(wszParameters), debugstr_w(wszDir));
1807     lpFile = sei_tmp.lpFile;
1808     wcmd = wcmdBuffer;
1809     strcpyW(wcmd, wszApplicationName);
1810     if (sei_tmp.lpDirectory)
1811     {
1812         LPCWSTR searchPath[] = {
1813             sei_tmp.lpDirectory,
1814             NULL
1815         };
1816         PathFindOnPathW(wcmd, searchPath);
1817     }
1818     retval = SHELL_quote_and_execute( wcmd, wszParameters, wszEmpty,
1819                                       wszApplicationName, NULL, &sei_tmp,
1820                                       sei, execfunc );
1821     if (retval > 32) {
1822         heap_free(wszApplicationName);
1823         if (wszParameters != parametersBuffer)
1824             heap_free(wszParameters);
1825         if (wszDir != dirBuffer)
1826             heap_free(wszDir);
1827         if (wcmd != wcmdBuffer)
1828             heap_free(wcmd);
1829         return TRUE;
1830     }
1831
1832     /* Else, try to find the executable */
1833     wcmd[0] = '\0';
1834     retval = SHELL_FindExecutable(sei_tmp.lpDirectory, lpFile, sei_tmp.lpVerb, wcmd, wcmdLen, wszKeyname, &env, sei_tmp.lpIDList, sei_tmp.lpParameters);
1835     if (retval > 32)  /* Found */
1836     {
1837         retval = SHELL_quote_and_execute( wcmd, wszParameters, wszKeyname,
1838                                           wszApplicationName, env, &sei_tmp,
1839                                           sei, execfunc );
1840         heap_free( env );
1841     }
1842     else if (PathIsDirectoryW(lpFile))
1843     {
1844         static const WCHAR wExplorer[] = {'e','x','p','l','o','r','e','r',0};
1845         static const WCHAR wQuote[] = {'"',0};
1846         WCHAR wExec[MAX_PATH];
1847         WCHAR * lpQuotedFile = heap_alloc( sizeof(WCHAR) * (strlenW(lpFile) + 3) );
1848
1849         if (lpQuotedFile)
1850         {
1851             retval = SHELL_FindExecutable( sei_tmp.lpDirectory, wExplorer,
1852                                            wszOpen, wExec, MAX_PATH,
1853                                            NULL, &env, NULL, NULL );
1854             if (retval > 32)
1855             {
1856                 strcpyW(lpQuotedFile, wQuote);
1857                 strcatW(lpQuotedFile, lpFile);
1858                 strcatW(lpQuotedFile, wQuote);
1859                 retval = SHELL_quote_and_execute( wExec, lpQuotedFile,
1860                                                   wszKeyname,
1861                                                   wszApplicationName, env,
1862                                                   &sei_tmp, sei, execfunc );
1863                 heap_free( env );
1864             }
1865             heap_free( lpQuotedFile );
1866         }
1867         else
1868             retval = 0; /* Out of memory */
1869     }
1870     else if (PathIsURLW(lpFile))    /* File not found, check for URL */
1871     {
1872         retval = SHELL_execute_url( lpFile, wcmd, &sei_tmp, sei, execfunc );
1873     }
1874     /* Check if file specified is in the form www.??????.*** */
1875     else if (!strncmpiW(lpFile, wWww, 3))
1876     {
1877         /* if so, prefix lpFile with http:// and call ShellExecute */
1878         WCHAR lpstrTmpFile[256];
1879         strcpyW(lpstrTmpFile, wHttp);
1880         strcatW(lpstrTmpFile, lpFile);
1881         retval = (UINT_PTR)ShellExecuteW(sei_tmp.hwnd, sei_tmp.lpVerb, lpstrTmpFile, NULL, NULL, 0);
1882     }
1883
1884 end:
1885     TRACE("retval %lu\n", retval);
1886
1887     heap_free(wszApplicationName);
1888     if (wszParameters != parametersBuffer)
1889         heap_free(wszParameters);
1890     if (wszDir != dirBuffer)
1891         heap_free(wszDir);
1892     if (wcmd != wcmdBuffer)
1893         heap_free(wcmd);
1894
1895     sei->hInstApp = (HINSTANCE)(retval > 32 ? 33 : retval);
1896
1897     if (retval <= 32 && !(sei_tmp.fMask & SEE_MASK_FLAG_NO_UI))
1898         do_error_dialog(retval, sei_tmp.hwnd);
1899     return retval > 32;
1900 }
1901
1902 /*************************************************************************
1903  * ShellExecuteA                        [SHELL32.290]
1904  */
1905 HINSTANCE WINAPI ShellExecuteA(HWND hWnd, LPCSTR lpVerb, LPCSTR lpFile,
1906                                LPCSTR lpParameters, LPCSTR lpDirectory, INT iShowCmd)
1907 {
1908     SHELLEXECUTEINFOA sei;
1909
1910     TRACE("%p,%s,%s,%s,%s,%d\n",
1911           hWnd, debugstr_a(lpVerb), debugstr_a(lpFile),
1912           debugstr_a(lpParameters), debugstr_a(lpDirectory), iShowCmd);
1913
1914     sei.cbSize = sizeof(sei);
1915     sei.fMask = SEE_MASK_FLAG_NO_UI;
1916     sei.hwnd = hWnd;
1917     sei.lpVerb = lpVerb;
1918     sei.lpFile = lpFile;
1919     sei.lpParameters = lpParameters;
1920     sei.lpDirectory = lpDirectory;
1921     sei.nShow = iShowCmd;
1922     sei.lpIDList = 0;
1923     sei.lpClass = 0;
1924     sei.hkeyClass = 0;
1925     sei.dwHotKey = 0;
1926     sei.hProcess = 0;
1927
1928     ShellExecuteExA (&sei);
1929     return sei.hInstApp;
1930 }
1931
1932 /*************************************************************************
1933  * ShellExecuteExA                              [SHELL32.292]
1934  *
1935  */
1936 BOOL WINAPI DECLSPEC_HOTPATCH ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
1937 {
1938     SHELLEXECUTEINFOW seiW;
1939     BOOL ret;
1940     WCHAR *wVerb = NULL, *wFile = NULL, *wParameters = NULL, *wDirectory = NULL, *wClass = NULL;
1941
1942     TRACE("%p\n", sei);
1943
1944     memcpy(&seiW, sei, sizeof(SHELLEXECUTEINFOW));
1945
1946     if (sei->lpVerb)
1947         seiW.lpVerb = __SHCloneStrAtoW(&wVerb, sei->lpVerb);
1948
1949     if (sei->lpFile)
1950         seiW.lpFile = __SHCloneStrAtoW(&wFile, sei->lpFile);
1951
1952     if (sei->lpParameters)
1953         seiW.lpParameters = __SHCloneStrAtoW(&wParameters, sei->lpParameters);
1954
1955     if (sei->lpDirectory)
1956         seiW.lpDirectory = __SHCloneStrAtoW(&wDirectory, sei->lpDirectory);
1957
1958     if ((sei->fMask & SEE_MASK_CLASSALL) == SEE_MASK_CLASSNAME && sei->lpClass)
1959         seiW.lpClass = __SHCloneStrAtoW(&wClass, sei->lpClass);
1960     else
1961         seiW.lpClass = NULL;
1962
1963     ret = SHELL_execute( &seiW, SHELL_ExecuteW );
1964
1965     sei->hInstApp = seiW.hInstApp;
1966
1967     if (sei->fMask & SEE_MASK_NOCLOSEPROCESS)
1968         sei->hProcess = seiW.hProcess;
1969
1970     SHFree(wVerb);
1971     SHFree(wFile);
1972     SHFree(wParameters);
1973     SHFree(wDirectory);
1974     SHFree(wClass);
1975
1976     return ret;
1977 }
1978
1979 /*************************************************************************
1980  * ShellExecuteExW                              [SHELL32.293]
1981  *
1982  */
1983 BOOL WINAPI DECLSPEC_HOTPATCH ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
1984 {
1985     return SHELL_execute( sei, SHELL_ExecuteW );
1986 }
1987
1988 /*************************************************************************
1989  * ShellExecuteW                        [SHELL32.294]
1990  * from shellapi.h
1991  * WINSHELLAPI HINSTANCE APIENTRY ShellExecuteW(HWND hwnd, LPCWSTR lpVerb,
1992  * LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
1993  */
1994 HINSTANCE WINAPI ShellExecuteW(HWND hwnd, LPCWSTR lpVerb, LPCWSTR lpFile,
1995                                LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd)
1996 {
1997     SHELLEXECUTEINFOW sei;
1998
1999     TRACE("\n");
2000     sei.cbSize = sizeof(sei);
2001     sei.fMask = SEE_MASK_FLAG_NO_UI;
2002     sei.hwnd = hwnd;
2003     sei.lpVerb = lpVerb;
2004     sei.lpFile = lpFile;
2005     sei.lpParameters = lpParameters;
2006     sei.lpDirectory = lpDirectory;
2007     sei.nShow = nShowCmd;
2008     sei.lpIDList = 0;
2009     sei.lpClass = 0;
2010     sei.hkeyClass = 0;
2011     sei.dwHotKey = 0;
2012     sei.hProcess = 0;
2013
2014     SHELL_execute( &sei, SHELL_ExecuteW );
2015     return sei.hInstApp;
2016 }
2017
2018 /*************************************************************************
2019  * WOWShellExecute                      [SHELL32.@]
2020  *
2021  * FIXME: the callback function most likely doesn't work the same way on Windows.
2022  */
2023 HINSTANCE WINAPI WOWShellExecute(HWND hWnd, LPCSTR lpVerb,LPCSTR lpFile,
2024                                  LPCSTR lpParameters,LPCSTR lpDirectory, INT iShowCmd, void *callback)
2025 {
2026     SHELLEXECUTEINFOW seiW;
2027     WCHAR *wVerb = NULL, *wFile = NULL, *wParameters = NULL, *wDirectory = NULL;
2028     HANDLE hProcess = 0;
2029
2030     seiW.lpVerb = lpVerb ? __SHCloneStrAtoW(&wVerb, lpVerb) : NULL;
2031     seiW.lpFile = lpFile ? __SHCloneStrAtoW(&wFile, lpFile) : NULL;
2032     seiW.lpParameters = lpParameters ? __SHCloneStrAtoW(&wParameters, lpParameters) : NULL;
2033     seiW.lpDirectory = lpDirectory ? __SHCloneStrAtoW(&wDirectory, lpDirectory) : NULL;
2034
2035     seiW.cbSize = sizeof(seiW);
2036     seiW.fMask = 0;
2037     seiW.hwnd = hWnd;
2038     seiW.nShow = iShowCmd;
2039     seiW.lpIDList = 0;
2040     seiW.lpClass = 0;
2041     seiW.hkeyClass = 0;
2042     seiW.dwHotKey = 0;
2043     seiW.hProcess = hProcess;
2044
2045     SHELL_execute( &seiW, callback );
2046
2047     SHFree(wVerb);
2048     SHFree(wFile);
2049     SHFree(wParameters);
2050     SHFree(wDirectory);
2051     return seiW.hInstApp;
2052 }
2053
2054 /*************************************************************************
2055  * ShellExec_RunDLLW        [SHELL32.@]
2056  */
2057 void WINAPI ShellExec_RunDLLW(HWND hwnd, HINSTANCE instance, WCHAR *cmdline, int cmdshow)
2058 {
2059     BOOL in_single_quotes = FALSE, in_double_quotes = FALSE;
2060     WCHAR *args;
2061
2062     TRACE("%p, %p, %s, %d\n", hwnd, instance, debugstr_w(cmdline), cmdshow);
2063
2064     /* Replace the first whitespace character in the command line string with a
2065        null terminator to separate the program name from the program arguments */
2066     for (args = cmdline; *args; args++)
2067     {
2068         switch (*args)
2069         {
2070         case '\\':
2071             args++; /* skip the next character */
2072             break;
2073         case '\'':
2074             if (!in_double_quotes)
2075                 in_single_quotes = !in_single_quotes;
2076             break;
2077         case '"':
2078             if (!in_single_quotes)
2079                 in_double_quotes = !in_double_quotes;
2080             break;
2081         case ' ':
2082         case '\t':
2083             if (!in_single_quotes && !in_double_quotes)
2084             {
2085                 *args = 0;
2086                 args++;
2087                 goto execute;
2088             }
2089         }
2090     }
2091
2092 execute:
2093     ShellExecuteW(hwnd, NULL, cmdline, args, NULL, cmdshow);
2094 }
2095
2096 /*************************************************************************
2097  * ShellExec_RunDLLA        [SHELL32.@]
2098  */
2099 void WINAPI ShellExec_RunDLLA(HWND hwnd, HINSTANCE instance, CHAR *cmdline, int cmdshow)
2100 {
2101     WCHAR *cmdlineW;
2102     ShellExec_RunDLLW(hwnd, instance, __SHCloneStrAtoW(&cmdlineW, cmdline), cmdshow);
2103     SHFree(cmdlineW);
2104 }
2105
2106 /*************************************************************************
2107  * OpenAs_RunDLLA          [SHELL32.@]
2108  */
2109 void WINAPI OpenAs_RunDLLA(HWND hwnd, HINSTANCE hinst, LPCSTR cmdline, int cmdshow)
2110 {
2111     FIXME("%p, %p, %s, %d\n", hwnd, hinst, debugstr_a(cmdline), cmdshow);
2112 }
2113
2114 /*************************************************************************
2115  * OpenAs_RunDLLW          [SHELL32.@]
2116  */
2117 void WINAPI OpenAs_RunDLLW(HWND hwnd, HINSTANCE hinst, LPCWSTR cmdline, int cmdshow)
2118 {
2119     FIXME("%p, %p, %s, %d\n", hwnd, hinst, debugstr_w(cmdline), cmdshow);
2120 }
2121
2122 /*************************************************************************
2123  * RegenerateUserEnvironment          [SHELL32.@]
2124  */
2125 BOOL WINAPI RegenerateUserEnvironment(WCHAR *wunknown, BOOL bunknown)
2126 {
2127     FIXME("stub: %p, %d\n", wunknown, bunknown);
2128     return FALSE;
2129 }