2 * Shell Library Functions
4 * Copyright 1998 Marcus Meissner
5 * Copyright 2002 Eric Pouech
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.
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.
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
23 #include "wine/port.h"
45 #include "wine/winbase16.h"
46 #include "shell32_main.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(exec);
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};
60 #define SEE_MASK_CLASSALL (SEE_MASK_CLASSNAME | SEE_MASK_CLASSKEY)
63 /***********************************************************************
64 * SHELL_ArgifyW [Internal]
66 * this function is supposed to expand the escape sequences found in the registry
67 * some diving reported that the following were used:
68 * + %1, %2... seem to report to parameter of index N in ShellExecute pmts
73 * %I address of a global item ID (explorer switch /idlist)
74 * %L seems to be %1 as long filename followed by the 8+3 variation
76 * %* all following parameters (see batfile)
79 * FIXME: Careful of going over string boundaries. No checking is done to 'res'...
81 static BOOL SHELL_ArgifyW(WCHAR* out, int len, const WCHAR* fmt, const WCHAR* lpFile, LPITEMIDLIST pidl, LPCWSTR args)
85 BOOL found_p1 = FALSE;
90 TRACE("%p, %d, %s, %s, %p, %p\n", out, len, debugstr_w(fmt),
91 debugstr_w(lpFile), pidl, args);
125 while(*args && !isspace(*args))
128 while(isspace(*args))
133 /* else fall through */
135 if (!done || (*fmt == '1'))
137 /*FIXME Is the call to SearchPathW() really needed? We already have separated out the parameter string in args. */
138 if (SearchPathW(NULL, lpFile, wszExe, sizeof(xlpFile)/sizeof(WCHAR), xlpFile, NULL))
143 /* Add double quotation marks unless we already have them
144 (e.g.: "file://%1" %* for exefile) or unless the arg is already
145 enclosed in double quotation marks */
146 if ((res == out || *(fmt + 1) != '"') && *cmd != '"')
163 * IE uses this a lot for activating things such as windows media
164 * player. This is not verified to be fully correct but it appears
170 strcpyW(res, lpFile);
171 res += strlenW(lpFile);
179 HGLOBAL hmem = SHAllocShared(pidl, ILGetSize(pidl), 0);
180 pv = SHLockShared(hmem, 0);
181 res += sprintfW(res, wszILPtr, pv);
189 * Check if this is an env-variable here...
192 /* Make sure that we have at least one more %.*/
193 if (strchrW(fmt, '%'))
195 WCHAR tmpBuffer[1024];
196 PWSTR tmpB = tmpBuffer;
197 WCHAR tmpEnvBuff[MAX_PATH];
204 TRACE("Checking %s to be an env-var\n", debugstr_w(tmpBuffer));
206 envRet = GetEnvironmentVariableW(tmpBuffer, tmpEnvBuff, MAX_PATH);
207 if (envRet == 0 || envRet > MAX_PATH)
208 strcpyW( res, tmpBuffer );
210 strcpyW( res, tmpEnvBuff );
216 /* Don't skip past terminator (catch a single '%' at the end) */
231 HRESULT SHELL_GetPathFromIDListForExecuteA(LPCITEMIDLIST pidl, LPSTR pszPath, UINT uOutSize)
234 IShellFolder* desktop;
236 HRESULT hr = SHGetDesktopFolder(&desktop);
239 hr = IShellFolder_GetDisplayNameOf(desktop, pidl, SHGDN_FORPARSING, &strret);
242 StrRetToStrNA(pszPath, uOutSize, &strret, pidl);
244 IShellFolder_Release(desktop);
250 HRESULT SHELL_GetPathFromIDListForExecuteW(LPCITEMIDLIST pidl, LPWSTR pszPath, UINT uOutSize)
253 IShellFolder* desktop;
255 HRESULT hr = SHGetDesktopFolder(&desktop);
258 hr = IShellFolder_GetDisplayNameOf(desktop, pidl, SHGDN_FORPARSING, &strret);
261 StrRetToStrNW(pszPath, uOutSize, &strret, pidl);
263 IShellFolder_Release(desktop);
269 /*************************************************************************
270 * SHELL_ExecuteW [Internal]
273 static UINT_PTR SHELL_ExecuteW(const WCHAR *lpCmd, WCHAR *env, BOOL shWait,
274 LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out)
276 STARTUPINFOW startup;
277 PROCESS_INFORMATION info;
278 UINT_PTR retval = 31;
280 WCHAR curdir[MAX_PATH];
282 TRACE("Execute %s from directory %s\n", debugstr_w(lpCmd), debugstr_w(psei->lpDirectory));
283 /* ShellExecute specifies the command from psei->lpDirectory
284 * if present. Not from the current dir as CreateProcess does */
285 if( psei->lpDirectory && psei->lpDirectory[0] )
286 if( ( gcdret = GetCurrentDirectoryW( MAX_PATH, curdir)))
287 if( !SetCurrentDirectoryW( psei->lpDirectory))
288 ERR("cannot set directory %s\n", debugstr_w(psei->lpDirectory));
289 ZeroMemory(&startup,sizeof(STARTUPINFOW));
290 startup.cb = sizeof(STARTUPINFOW);
291 startup.dwFlags = STARTF_USESHOWWINDOW;
292 startup.wShowWindow = psei->nShow;
293 if (CreateProcessW(NULL, (LPWSTR)lpCmd, NULL, NULL, FALSE, CREATE_UNICODE_ENVIRONMENT, env,
294 psei->lpDirectory && *psei->lpDirectory ? psei->lpDirectory : NULL,
297 /* Give 30 seconds to the app to come up, if desired. Probably only needed
298 when starting app immediately before making a DDE connection. */
300 if (WaitForInputIdle( info.hProcess, 30000 ) == WAIT_FAILED)
301 WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
303 if (psei->fMask & SEE_MASK_NOCLOSEPROCESS)
304 psei_out->hProcess = info.hProcess;
306 CloseHandle( info.hProcess );
307 CloseHandle( info.hThread );
309 else if ((retval = GetLastError()) >= 32)
311 TRACE("CreateProcess returned error %d\n", retval);
312 retval = ERROR_BAD_FORMAT;
315 TRACE("returning %u\n", retval);
317 psei_out->hInstApp = (HINSTANCE)retval;
319 if( !SetCurrentDirectoryW( curdir))
320 ERR("cannot return to directory %s\n", debugstr_w(curdir));
326 /***********************************************************************
327 * SHELL_BuildEnvW [Internal]
329 * Build the environment for the new process, adding the specified
330 * path to the PATH variable. Returned pointer must be freed by caller.
332 static void *SHELL_BuildEnvW( const WCHAR *path )
334 static const WCHAR wPath[] = {'P','A','T','H','=',0};
335 WCHAR *strings, *new_env;
337 int total = strlenW(path) + 1;
338 BOOL got_path = FALSE;
340 if (!(strings = GetEnvironmentStringsW())) return NULL;
344 int len = strlenW(p) + 1;
345 if (!strncmpiW( p, wPath, 5 )) got_path = TRUE;
349 if (!got_path) total += 5; /* we need to create PATH */
350 total++; /* terminating null */
352 if (!(new_env = HeapAlloc( GetProcessHeap(), 0, total * sizeof(WCHAR) )))
354 FreeEnvironmentStringsW( strings );
361 int len = strlenW(p) + 1;
362 memcpy( p2, p, len * sizeof(WCHAR) );
363 if (!strncmpiW( p, wPath, 5 ))
366 strcpyW( p2 + len, path );
367 p2 += strlenW(path) + 1;
374 strcpyW( p2, wPath );
376 p2 += strlenW(p2) + 1;
379 FreeEnvironmentStringsW( strings );
384 /***********************************************************************
385 * SHELL_TryAppPathW [Internal]
387 * Helper function for SHELL_FindExecutable
388 * @param lpResult - pointer to a buffer of size MAX_PATH
389 * On entry: szName is a filename (probably without path separators).
390 * On exit: if szName found in "App Path", place full path in lpResult, and return true
392 static BOOL SHELL_TryAppPathW( LPCWSTR szName, LPWSTR lpResult, WCHAR **env)
394 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',
395 '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','A','p','p',' ','P','a','t','h','s','\\',0};
396 static const WCHAR wPath[] = {'P','a','t','h',0};
403 if (env) *env = NULL;
404 strcpyW(buffer, wszKeyAppPaths);
405 strcatW(buffer, szName);
406 res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, buffer, 0, KEY_READ, &hkApp);
409 len = MAX_PATH*sizeof(WCHAR);
410 res = RegQueryValueW(hkApp, NULL, lpResult, &len);
416 DWORD count = sizeof(buffer);
417 if (!RegQueryValueExW(hkApp, wPath, NULL, NULL, (LPBYTE)buffer, &count) && buffer[0])
418 *env = SHELL_BuildEnvW( buffer );
422 if (hkApp) RegCloseKey(hkApp);
426 static UINT SHELL_FindExecutableByOperation(LPCWSTR lpPath, LPCWSTR lpFile, LPCWSTR lpOperation, LPWSTR key, LPWSTR filetype, LPWSTR command, LONG commandlen)
428 static const WCHAR wCommand[] = {'\\','c','o','m','m','a','n','d',0};
430 /* Looking for ...buffer\shell\<verb>\command */
431 strcatW(filetype, wszShell);
432 strcatW(filetype, lpOperation);
433 strcatW(filetype, wCommand);
435 if (RegQueryValueW(HKEY_CLASSES_ROOT, filetype, command,
436 &commandlen) == ERROR_SUCCESS)
438 commandlen /= sizeof(WCHAR);
439 if (key) strcpyW(key, filetype);
443 LONG paramlen = sizeof(param);
444 static const WCHAR wSpace[] = {' ',0};
446 /* FIXME: it seems all Windows version don't behave the same here.
447 * the doc states that this ddeexec information can be found after
449 * on Win98, it doesn't appear, but I think it does on Win2k
451 /* Get the parameters needed by the application
452 from the associated ddeexec key */
453 tmp = strstrW(filetype, wCommand);
455 strcatW(filetype, wDdeexec);
456 if (RegQueryValueW(HKEY_CLASSES_ROOT, filetype, param,
457 ¶mlen) == ERROR_SUCCESS)
459 paramlen /= sizeof(WCHAR);
460 strcatW(command, wSpace);
461 strcatW(command, param);
462 commandlen += paramlen;
466 command[commandlen] = '\0';
468 return 33; /* FIXME see SHELL_FindExecutable() */
471 return 31; /* default - 'No association was found' */
474 /*************************************************************************
475 * SHELL_FindExecutable [Internal]
477 * Utility for code sharing between FindExecutable and ShellExecute
479 * lpFile the name of a file
480 * lpOperation the operation on it (open)
482 * lpResult a buffer, big enough :-(, to store the command to do the
483 * operation on the file
484 * key a buffer, big enough, to get the key name to do actually the
485 * command (it'll be used afterwards for more information
488 UINT SHELL_FindExecutable(LPCWSTR lpPath, LPCWSTR lpFile, LPCWSTR lpOperation,
489 LPWSTR lpResult, int resultLen, LPWSTR key, WCHAR **env, LPITEMIDLIST pidl, LPCWSTR args)
491 static const WCHAR wWindows[] = {'w','i','n','d','o','w','s',0};
492 static const WCHAR wPrograms[] = {'p','r','o','g','r','a','m','s',0};
493 static const WCHAR wExtensions[] = {'e','x','e',' ','p','i','f',' ','b','a','t',' ','c','m','d',' ','c','o','m',0};
494 WCHAR *extension = NULL; /* pointer to file extension */
495 WCHAR filetype[256]; /* registry name for this filetype */
496 LONG filetypelen = sizeof(filetype); /* length of above */
497 WCHAR command[1024]; /* command from registry */
498 WCHAR wBuffer[256]; /* Used to GetProfileString */
499 UINT retval = 31; /* default - 'No association was found' */
500 WCHAR *tok; /* token pointer */
501 WCHAR xlpFile[256]; /* result of SearchPath */
502 DWORD attribs; /* file attributes */
504 TRACE("%s\n", (lpFile != NULL) ? debugstr_w(lpFile) : "-");
507 lpResult[0] = '\0'; /* Start off with an empty return string */
508 if (key) *key = '\0';
510 /* trap NULL parameters on entry */
511 if ((lpFile == NULL) || (lpResult == NULL) || (lpOperation == NULL))
513 WARN("(lpFile=%s,lpResult=%s,lpOperation=%s): NULL parameter\n",
514 debugstr_w(lpFile), debugstr_w(lpOperation), debugstr_w(lpResult));
515 return 2; /* File not found. Close enough, I guess. */
518 if (SHELL_TryAppPathW( lpFile, lpResult, env ))
520 TRACE("found %s via App Paths\n", debugstr_w(lpResult));
524 if (SearchPathW(lpPath, lpFile, wszExe, sizeof(xlpFile)/sizeof(WCHAR), xlpFile, NULL))
526 TRACE("SearchPathW returned non-zero\n");
528 /* Hey, isn't this value ignored? Why make this call? Shouldn't we return here? --dank*/
531 attribs = GetFileAttributesW(lpFile);
532 if (attribs!=INVALID_FILE_ATTRIBUTES && (attribs&FILE_ATTRIBUTE_DIRECTORY))
534 strcpyW(filetype, wszFolder);
535 filetypelen = 6; /* strlen("Folder") */
539 /* First thing we need is the file's extension */
540 extension = strrchrW(xlpFile, '.'); /* Assume last "." is the one; */
541 /* File->Run in progman uses */
543 TRACE("xlpFile=%s,extension=%s\n", debugstr_w(xlpFile), debugstr_w(extension));
545 if (extension == NULL || extension[1]==0)
547 WARN("Returning 31 - No association\n");
548 return 31; /* no association */
551 /* Three places to check: */
552 /* 1. win.ini, [windows], programs (NB no leading '.') */
553 /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */
554 /* 3. win.ini, [extensions], extension (NB no leading '.' */
555 /* All I know of the order is that registry is checked before */
556 /* extensions; however, it'd make sense to check the programs */
557 /* section first, so that's what happens here. */
559 /* See if it's a program - if GetProfileString fails, we skip this
560 * section. Actually, if GetProfileString fails, we've probably
561 * got a lot more to worry about than running a program... */
562 if (GetProfileStringW(wWindows, wPrograms, wExtensions, wBuffer, sizeof(wBuffer)/sizeof(WCHAR)) > 0)
569 while (*p && *p != ' ' && *p != '\t') p++;
573 while (*p == ' ' || *p == '\t') p++;
576 if (strcmpiW(tok, &extension[1]) == 0) /* have to skip the leading "." */
578 strcpyW(lpResult, xlpFile);
579 /* Need to perhaps check that the file has a path
581 TRACE("found %s\n", debugstr_w(lpResult));
584 /* Greater than 32 to indicate success FIXME According to the
585 * docs, I should be returning a handle for the
586 * executable. Does this mean I'm supposed to open the
587 * executable file or something? More RTFM, I guess... */
594 if (RegQueryValueW(HKEY_CLASSES_ROOT, extension, filetype,
595 &filetypelen) == ERROR_SUCCESS)
597 filetypelen /= sizeof(WCHAR);
598 filetype[filetypelen] = '\0';
599 TRACE("File type: %s\n", debugstr_w(filetype));
610 /* pass the operation string to SHELL_FindExecutableByOperation() */
611 filetype[filetypelen] = '\0';
612 retval = SHELL_FindExecutableByOperation(lpPath, lpFile, lpOperation, key, filetype, command, sizeof(command));
616 SHELL_ArgifyW(lpResult, resultLen, command, xlpFile, pidl, args);
618 /* Remove double quotation marks and command line arguments */
619 if (*lpResult == '"')
622 while (*(p + 1) != '"')
631 else /* Check win.ini */
633 static const WCHAR wExtensions[] = {'e','x','t','e','n','s','i','o','n','s',0};
635 /* Toss the leading dot */
637 if (GetProfileStringW(wExtensions, extension, wszEmpty, command, sizeof(command)/sizeof(WCHAR)) > 0)
639 if (strlenW(command) != 0)
641 strcpyW(lpResult, command);
642 tok = strchrW(lpResult, '^'); /* should be ^.extension? */
646 strcatW(lpResult, xlpFile); /* what if no dir in xlpFile? */
647 tok = strchrW(command, '^'); /* see above */
648 if ((tok != NULL) && (strlenW(tok)>5))
650 strcatW(lpResult, &tok[5]);
653 retval = 33; /* FIXME - see above */
658 TRACE("returning %s\n", debugstr_w(lpResult));
662 /******************************************************************
665 * callback for the DDE connection. not really useful
667 static HDDEDATA CALLBACK dde_cb(UINT uType, UINT uFmt, HCONV hConv,
668 HSZ hsz1, HSZ hsz2, HDDEDATA hData,
669 ULONG_PTR dwData1, ULONG_PTR dwData2)
671 TRACE("dde_cb: %04x, %04x, %p, %p, %p, %p, %08lx, %08lx\n",
672 uType, uFmt, hConv, hsz1, hsz2, hData, dwData1, dwData2);
676 /******************************************************************
679 * ShellExecute helper. Used to do an operation with a DDE connection
681 * Handles both the direct connection (try #1), and if it fails,
682 * launching an application and trying (#2) to connect to it
685 static unsigned dde_connect(WCHAR* key, const WCHAR* start, WCHAR* ddeexec,
686 const WCHAR* lpFile, WCHAR *env,
687 LPCWSTR szCommandline, LPITEMIDLIST pidl, SHELL_ExecuteW32 execfunc,
688 LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out)
690 static const WCHAR wApplication[] = {'\\','a','p','p','l','i','c','a','t','i','o','n',0};
691 static const WCHAR wTopic[] = {'\\','t','o','p','i','c',0};
692 WCHAR * endkey = key + strlenW(key);
693 WCHAR app[256], topic[256], ifexec[256], res[256];
694 LONG applen, topiclen, ifexeclen;
698 HSZ hszApp, hszTopic;
702 BOOL unicode = !(GetVersion() & 0x80000000);
704 strcpyW(endkey, wApplication);
705 applen = sizeof(app);
706 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, app, &applen) != ERROR_SUCCESS)
708 FIXME("default app name NIY %s\n", debugstr_w(key));
712 strcpyW(endkey, wTopic);
713 topiclen = sizeof(topic);
714 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, topic, &topiclen) != ERROR_SUCCESS)
716 static const WCHAR wSystem[] = {'S','y','s','t','e','m',0};
717 strcpyW(topic, wSystem);
722 if (DdeInitializeW(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR)
727 if (DdeInitializeA(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR)
731 hszApp = DdeCreateStringHandleW(ddeInst, app, CP_WINUNICODE);
732 hszTopic = DdeCreateStringHandleW(ddeInst, topic, CP_WINUNICODE);
734 hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
738 static const WCHAR wIfexec[] = {'\\','i','f','e','x','e','c',0};
739 TRACE("Launching '%s'\n", debugstr_w(start));
740 ret = execfunc(start, env, TRUE, psei, psei_out);
743 TRACE("Couldn't launch\n");
746 hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
749 TRACE("Couldn't connect. ret=%d\n", ret);
750 DdeUninitialize(ddeInst);
751 SetLastError(ERROR_DDE_FAIL);
752 return 30; /* whatever */
754 strcpyW(endkey, wIfexec);
755 ifexeclen = sizeof(ifexec);
756 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, ifexec, &ifexeclen) == ERROR_SUCCESS)
762 SHELL_ArgifyW(res, sizeof(res)/sizeof(WCHAR), exec, lpFile, pidl, szCommandline);
763 TRACE("%s %s => %s\n", debugstr_w(exec), debugstr_w(lpFile), debugstr_w(res));
765 /* It's documented in the KB 330337 that IE has a bug and returns
766 * error DMLERR_NOTPROCESSED on XTYP_EXECUTE request.
769 hDdeData = DdeClientTransaction((LPBYTE)res, (strlenW(res) + 1) * sizeof(WCHAR), hConv, 0L, 0,
770 XTYP_EXECUTE, 30000, &tid);
773 DWORD lenA = WideCharToMultiByte(CP_ACP, 0, res, -1, NULL, 0, NULL, NULL);
774 char *resA = HeapAlloc(GetProcessHeap(), 0, lenA);
775 WideCharToMultiByte(CP_ACP, 0, res, -1, resA, lenA, NULL, NULL);
776 hDdeData = DdeClientTransaction( (LPBYTE)resA, lenA, hConv, 0L, 0,
777 XTYP_EXECUTE, 10000, &tid );
778 HeapFree(GetProcessHeap(), 0, resA);
781 DdeFreeDataHandle(hDdeData);
783 WARN("DdeClientTransaction failed with error %04x\n", DdeGetLastError(ddeInst));
786 DdeDisconnect(hConv);
789 DdeUninitialize(ddeInst);
794 /*************************************************************************
795 * execute_from_key [Internal]
797 static UINT_PTR execute_from_key(LPWSTR key, LPCWSTR lpFile, WCHAR *env, LPCWSTR szCommandline,
798 LPCWSTR executable_name,
799 SHELL_ExecuteW32 execfunc,
800 LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out)
803 LONG cmdlen = sizeof(cmd);
804 UINT_PTR retval = 31;
806 TRACE("%s %s %s %s %s\n", debugstr_w(key), debugstr_w(lpFile), debugstr_w(env),
807 debugstr_w(szCommandline), debugstr_w(executable_name));
811 /* Get the application from the registry */
812 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, cmd, &cmdlen) == ERROR_SUCCESS)
816 TRACE("got cmd: %s\n", debugstr_w(cmd));
820 /* Is there a replace() function anywhere? */
821 cmdlen /= sizeof(WCHAR);
823 if (!SHELL_ArgifyW(param, sizeof(param)/sizeof(WCHAR), cmd, lpFile, psei->lpIDList, szCommandline))
825 /* looks like there is no %1 param in the cmd, add one */
826 static const WCHAR oneW[] = { ' ','\"','%','1','\"',0 };
828 SHELL_ArgifyW(param, sizeof(param)/sizeof(WCHAR), cmd, lpFile, psei->lpIDList, szCommandline);
830 TRACE("executing: %s\n", debugstr_w(param));
831 retval = execfunc(param, env, FALSE, psei, psei_out);
835 static const WCHAR wCommand[] = {'c','o','m','m','a','n','d',0};
836 static const WCHAR wDdeexec[] = {'d','d','e','e','x','e','c',0};
839 LONG paramlen = sizeof(param);
843 /* Get the parameters needed by the application
844 from the associated ddeexec key */
845 tmp = strstrW(key, wCommand);
847 strcpyW(tmp, wDdeexec);
849 TRACE("trying ddeexec cmd: %s\n", debugstr_w(key));
851 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, param, ¶mlen) == ERROR_SUCCESS)
853 TRACE("Got ddeexec %s => %s\n", debugstr_w(key), debugstr_w(param));
854 retval = dde_connect(key, executable_name, param, lpFile, env, szCommandline, psei->lpIDList, execfunc, psei, psei_out);
857 WARN("Nothing appropriate found for %s\n", debugstr_w(key));
863 /*************************************************************************
864 * FindExecutableA [SHELL32.@]
866 HINSTANCE WINAPI FindExecutableA(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult)
869 WCHAR *wFile = NULL, *wDirectory = NULL;
870 WCHAR wResult[MAX_PATH];
872 if (lpFile) __SHCloneStrAtoW(&wFile, lpFile);
873 if (lpDirectory) __SHCloneStrAtoW(&wDirectory, lpDirectory);
875 retval = FindExecutableW(wFile, wDirectory, wResult);
876 WideCharToMultiByte(CP_ACP, 0, wResult, -1, lpResult, MAX_PATH, NULL, NULL);
877 if (wFile) SHFree( wFile );
878 if (wDirectory) SHFree( wDirectory );
880 TRACE("returning %s\n", lpResult);
884 /*************************************************************************
885 * FindExecutableW [SHELL32.@]
887 HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult)
889 UINT_PTR retval = 31; /* default - 'No association was found' */
892 TRACE("File %s, Dir %s\n",
893 (lpFile != NULL ? debugstr_w(lpFile) : "-"), (lpDirectory != NULL ? debugstr_w(lpDirectory) : "-"));
895 lpResult[0] = '\0'; /* Start off with an empty return string */
897 /* trap NULL parameters on entry */
898 if ((lpFile == NULL) || (lpResult == NULL))
900 /* FIXME - should throw a warning, perhaps! */
901 return (HINSTANCE)2; /* File not found. Close enough, I guess. */
906 GetCurrentDirectoryW(sizeof(old_dir)/sizeof(WCHAR), old_dir);
907 SetCurrentDirectoryW(lpDirectory);
910 retval = SHELL_FindExecutable(lpDirectory, lpFile, wszOpen, lpResult, MAX_PATH, NULL, NULL, NULL, NULL);
912 TRACE("returning %s\n", debugstr_w(lpResult));
914 SetCurrentDirectoryW(old_dir);
915 return (HINSTANCE)retval;
918 /* FIXME: is this already implemented somewhere else? */
919 static HKEY ShellExecute_GetClassKey( LPSHELLEXECUTEINFOW sei )
921 LPCWSTR ext = NULL, lpClass = NULL;
923 DWORD type = 0, sz = 0;
927 if (sei->fMask & SEE_MASK_CLASSALL)
928 return sei->hkeyClass;
930 if (sei->fMask & SEE_MASK_CLASSNAME)
931 lpClass = sei->lpClass;
934 ext = PathFindExtensionW( sei->lpFile );
935 TRACE("ext = %s\n", debugstr_w( ext ) );
939 r = RegOpenKeyW( HKEY_CLASSES_ROOT, ext, &hkey );
940 if (r != ERROR_SUCCESS )
943 r = RegQueryValueExW( hkey, NULL, 0, &type, NULL, &sz );
944 if ( r == ERROR_SUCCESS && type == REG_SZ )
946 sz += sizeof (WCHAR);
947 cls = HeapAlloc( GetProcessHeap(), 0, sz );
949 RegQueryValueExW( hkey, NULL, 0, &type, (LPBYTE) cls, &sz );
956 TRACE("class = %s\n", debugstr_w(lpClass) );
960 RegOpenKeyW( HKEY_CLASSES_ROOT, lpClass, &hkey );
962 HeapFree( GetProcessHeap(), 0, cls );
967 static IDataObject *shellex_get_dataobj( LPSHELLEXECUTEINFOW sei )
969 LPCITEMIDLIST pidllast = NULL;
970 IDataObject *dataobj = NULL;
971 IShellFolder *shf = NULL;
972 LPITEMIDLIST pidl = NULL;
975 if (sei->fMask & SEE_MASK_CLASSALL)
976 pidl = sei->lpIDList;
979 WCHAR fullpath[MAX_PATH];
982 r = GetFullPathNameW( sei->lpFile, MAX_PATH, fullpath, NULL );
986 pidl = ILCreateFromPathW( fullpath );
989 r = SHBindToParent( pidl, &IID_IShellFolder, (LPVOID*)&shf, &pidllast );
993 IShellFolder_GetUIObjectOf( shf, NULL, 1, &pidllast,
994 &IID_IDataObject, NULL, (LPVOID*) &dataobj );
997 if ( pidl != sei->lpIDList )
1000 IShellFolder_Release( shf );
1004 static HRESULT shellex_run_context_menu_default( IShellExtInit *obj,
1005 LPSHELLEXECUTEINFOW sei )
1007 IContextMenu *cm = NULL;
1008 CMINVOKECOMMANDINFOEX ici;
1015 TRACE("%p %p\n", obj, sei );
1017 r = IShellExtInit_QueryInterface( obj, &IID_IContextMenu, (LPVOID*) &cm );
1021 hmenu = CreateMenu();
1025 /* the number of the last menu added is returned in r */
1026 r = IContextMenu_QueryContextMenu( cm, hmenu, 0, 0x20, 0x7fff, CMF_DEFAULTONLY );
1030 n = GetMenuItemCount( hmenu );
1031 for ( i = 0; i < n; i++ )
1033 memset( &info, 0, sizeof info );
1034 info.cbSize = sizeof info;
1035 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_DATA | MIIM_ID;
1036 info.dwTypeData = string;
1037 info.cch = sizeof string;
1039 GetMenuItemInfoW( hmenu, i, TRUE, &info );
1041 TRACE("menu %d %s %08x %08lx %08x %08x\n", i, debugstr_w(string),
1042 info.fState, info.dwItemData, info.fType, info.wID );
1043 if ( ( !sei->lpVerb && (info.fState & MFS_DEFAULT) ) ||
1044 ( sei->lpVerb && !lstrcmpiW( sei->lpVerb, string ) ) )
1055 memset( &ici, 0, sizeof ici );
1056 ici.cbSize = sizeof ici;
1057 ici.fMask = CMIC_MASK_UNICODE;
1058 ici.nShow = sei->nShow;
1059 ici.lpVerb = MAKEINTRESOURCEA( def );
1060 ici.hwnd = sei->hwnd;
1061 ici.lpParametersW = sei->lpParameters;
1063 r = IContextMenu_InvokeCommand( cm, (LPCMINVOKECOMMANDINFO) &ici );
1065 TRACE("invoke command returned %08lx\n", r );
1069 DestroyMenu( hmenu );
1071 IContextMenu_Release( cm );
1075 static HRESULT shellex_load_object_and_run( HKEY hkey, LPCGUID guid, LPSHELLEXECUTEINFOW sei )
1077 IDataObject *dataobj = NULL;
1078 IObjectWithSite *ows = NULL;
1079 IShellExtInit *obj = NULL;
1082 TRACE("%p %s %p\n", hkey, debugstr_guid( guid ), sei );
1084 r = CoInitialize( NULL );
1088 r = CoCreateInstance( guid, NULL, CLSCTX_INPROC_SERVER,
1089 &IID_IShellExtInit, (LPVOID*)&obj );
1092 ERR("failed %08lx\n", r );
1096 dataobj = shellex_get_dataobj( sei );
1099 ERR("failed to get data object\n");
1103 r = IShellExtInit_Initialize( obj, NULL, dataobj, hkey );
1107 r = IShellExtInit_QueryInterface( obj, &IID_IObjectWithSite, (LPVOID*) &ows );
1111 IObjectWithSite_SetSite( ows, NULL );
1113 r = shellex_run_context_menu_default( obj, sei );
1117 IObjectWithSite_Release( ows );
1119 IDataObject_Release( dataobj );
1121 IShellExtInit_Release( obj );
1127 /*************************************************************************
1128 * ShellExecute_FromContextMenu [Internal]
1130 static LONG ShellExecute_FromContextMenu( LPSHELLEXECUTEINFOW sei )
1132 static const WCHAR szcm[] = { 's','h','e','l','l','e','x','\\',
1133 'C','o','n','t','e','x','t','M','e','n','u','H','a','n','d','l','e','r','s',0 };
1134 HKEY hkey, hkeycm = 0;
1141 TRACE("%s\n", debugstr_w(sei->lpFile) );
1143 hkey = ShellExecute_GetClassKey( sei );
1145 return ERROR_FUNCTION_FAILED;
1147 r = RegOpenKeyW( hkey, szcm, &hkeycm );
1148 if ( r == ERROR_SUCCESS )
1153 r = RegEnumKeyW( hkeycm, i++, szguid, 39 );
1154 if ( r != ERROR_SUCCESS )
1157 hr = CLSIDFromString( szguid, &guid );
1160 /* stop at the first one that succeeds in running */
1161 hr = shellex_load_object_and_run( hkey, &guid, sei );
1162 if ( SUCCEEDED( hr ) )
1166 RegCloseKey( hkeycm );
1169 if ( hkey != sei->hkeyClass )
1170 RegCloseKey( hkey );
1174 /*************************************************************************
1175 * SHELL_execute [Internal]
1177 BOOL SHELL_execute( LPSHELLEXECUTEINFOW sei, SHELL_ExecuteW32 execfunc )
1179 static const WCHAR wQuote[] = {'"',0};
1180 static const WCHAR wSpace[] = {' ',0};
1181 static const WCHAR wWww[] = {'w','w','w',0};
1182 static const WCHAR wFile[] = {'f','i','l','e',0};
1183 static const WCHAR wHttp[] = {'h','t','t','p',':','/','/',0};
1184 static const WCHAR wExplorer[] = {'e','x','p','l','o','r','e','r','.','e','x','e',0};
1185 static const DWORD unsupportedFlags =
1186 SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
1187 SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI |
1188 SEE_MASK_UNICODE | SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK |
1191 WCHAR *wszApplicationName, wszParameters[1024], wszDir[MAX_PATH];
1192 DWORD dwApplicationNameLen = MAX_PATH+2;
1193 SHELLEXECUTEINFOW sei_tmp; /* modifiable copy of SHELLEXECUTEINFO struct */
1194 WCHAR wfileName[MAX_PATH];
1196 WCHAR lpstrProtocol[256];
1198 UINT_PTR retval = 31;
1200 WCHAR buffer[MAX_PATH];
1203 /* make a local copy of the LPSHELLEXECUTEINFO structure and work with this from now on */
1204 memcpy(&sei_tmp, sei, sizeof(sei_tmp));
1206 TRACE("mask=0x%08lx hwnd=%p verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s\n",
1207 sei_tmp.fMask, sei_tmp.hwnd, debugstr_w(sei_tmp.lpVerb),
1208 debugstr_w(sei_tmp.lpFile), debugstr_w(sei_tmp.lpParameters),
1209 debugstr_w(sei_tmp.lpDirectory), sei_tmp.nShow,
1210 ((sei_tmp.fMask & SEE_MASK_CLASSALL) == SEE_MASK_CLASSNAME) ?
1211 debugstr_w(sei_tmp.lpClass) : "not used");
1213 sei->hProcess = NULL;
1215 /* make copies of all path/command strings */
1216 if (!sei_tmp.lpFile)
1218 wszApplicationName = HeapAlloc(GetProcessHeap(), 0, dwApplicationNameLen*sizeof(WCHAR));
1219 *wszApplicationName = '\0';
1221 else if (*sei_tmp.lpFile == '\"')
1223 DWORD l = strlenW(sei_tmp.lpFile+1);
1224 if(l >= dwApplicationNameLen) dwApplicationNameLen = l+1;
1225 wszApplicationName = HeapAlloc(GetProcessHeap(), 0, dwApplicationNameLen*sizeof(WCHAR));
1226 memcpy(wszApplicationName, sei_tmp.lpFile+1, (l+1)*sizeof(WCHAR));
1227 if (wszApplicationName[l-1] == '\"')
1228 wszApplicationName[l-1] = '\0';
1229 TRACE("wszApplicationName=%s\n",debugstr_w(wszApplicationName));
1231 DWORD l = strlenW(sei_tmp.lpFile)+1;
1232 if(l > dwApplicationNameLen) dwApplicationNameLen = l+1;
1233 wszApplicationName = HeapAlloc(GetProcessHeap(), 0, dwApplicationNameLen*sizeof(WCHAR));
1234 memcpy(wszApplicationName, sei_tmp.lpFile, l*sizeof(WCHAR));
1237 if (sei_tmp.lpParameters)
1238 strcpyW(wszParameters, sei_tmp.lpParameters);
1240 *wszParameters = '\0';
1242 if (sei_tmp.lpDirectory)
1243 strcpyW(wszDir, sei_tmp.lpDirectory);
1247 /* adjust string pointers to point to the new buffers */
1248 sei_tmp.lpFile = wszApplicationName;
1249 sei_tmp.lpParameters = wszParameters;
1250 sei_tmp.lpDirectory = wszDir;
1252 if (sei_tmp.fMask & unsupportedFlags)
1254 FIXME("flags ignored: 0x%08lx\n", sei_tmp.fMask & unsupportedFlags);
1257 /* process the IDList */
1258 if (sei_tmp.fMask & SEE_MASK_IDLIST)
1260 IShellExecuteHookW* pSEH;
1262 HRESULT hr = SHBindToParent(sei_tmp.lpIDList, &IID_IShellExecuteHookW, (LPVOID*)&pSEH, NULL);
1266 hr = IShellExecuteHookW_Execute(pSEH, &sei_tmp);
1268 IShellExecuteHookW_Release(pSEH);
1271 HeapFree(GetProcessHeap(), 0, wszApplicationName);
1276 SHGetPathFromIDListW(sei_tmp.lpIDList, wszApplicationName);
1277 TRACE("-- idlist=%p (%s)\n", sei_tmp.lpIDList, debugstr_w(wszApplicationName));
1280 if ( ERROR_SUCCESS == ShellExecute_FromContextMenu( &sei_tmp ) )
1282 sei->hInstApp = (HINSTANCE) 33;
1283 HeapFree(GetProcessHeap(), 0, wszApplicationName);
1287 if (sei_tmp.fMask & SEE_MASK_CLASSALL)
1289 /* launch a document by fileclass like 'WordPad.Document.1' */
1290 /* the Commandline contains 'c:\Path\wordpad.exe "%1"' */
1291 /* FIXME: szCommandline should not be of a fixed size. Fixed to 1024, MAX_PATH is way too short! */
1292 ULONG cmask=(sei_tmp.fMask & SEE_MASK_CLASSALL);
1293 HCR_GetExecuteCommandW((cmask == SEE_MASK_CLASSKEY) ? sei_tmp.hkeyClass : NULL,
1294 (cmask == SEE_MASK_CLASSNAME) ? sei_tmp.lpClass: NULL,
1295 (sei_tmp.lpVerb) ? sei_tmp.lpVerb : wszOpen,
1296 wszParameters, sizeof(wszParameters)/sizeof(WCHAR));
1298 /* FIXME: get the extension of lpFile, check if it fits to the lpClass */
1299 TRACE("SEE_MASK_CLASSNAME->'%s', doc->'%s'\n", debugstr_w(wszParameters), debugstr_w(wszApplicationName));
1302 done = SHELL_ArgifyW(wcmd, sizeof(wcmd)/sizeof(WCHAR), wszParameters, wszApplicationName, sei_tmp.lpIDList, NULL);
1303 if (!done && wszApplicationName[0])
1305 strcatW(wcmd, wSpace);
1306 strcatW(wcmd, wszApplicationName);
1308 retval = execfunc(wcmd, NULL, FALSE, &sei_tmp, sei);
1310 HeapFree(GetProcessHeap(), 0, wszApplicationName);
1314 /* Has the IDList not yet been translated? */
1315 if (sei_tmp.fMask & SEE_MASK_IDLIST)
1317 /* last chance to translate IDList: now also allow CLSID paths */
1318 if (SUCCEEDED(SHELL_GetPathFromIDListForExecuteW(sei_tmp.lpIDList, buffer, sizeof(buffer)))) {
1319 if (buffer[0]==':' && buffer[1]==':') {
1320 /* open shell folder for the specified class GUID */
1321 strcpyW(wszParameters, buffer);
1322 strcpyW(wszApplicationName, wExplorer);
1324 sei_tmp.fMask &= ~SEE_MASK_INVOKEIDLIST;
1326 WCHAR target[MAX_PATH];
1328 /* Check if we're executing a directory and if so use the
1329 handler for the Folder class */
1330 strcpyW(target, buffer);
1331 attribs = GetFileAttributesW(buffer);
1332 if (attribs != INVALID_FILE_ATTRIBUTES &&
1333 (attribs & FILE_ATTRIBUTE_DIRECTORY) &&
1334 HCR_GetExecuteCommandW(0, wszFolder,
1335 sei_tmp.lpVerb?sei_tmp.lpVerb:wszOpen,
1336 buffer, sizeof(buffer))) {
1337 SHELL_ArgifyW(wszApplicationName, dwApplicationNameLen,
1338 buffer, target, sei_tmp.lpIDList, NULL);
1340 sei_tmp.fMask &= ~SEE_MASK_INVOKEIDLIST;
1345 /* expand environment strings */
1346 if (ExpandEnvironmentStringsW(sei_tmp.lpFile, buffer, MAX_PATH))
1347 lstrcpyW(wszApplicationName, buffer);
1349 if (*sei_tmp.lpParameters)
1350 if (ExpandEnvironmentStringsW(sei_tmp.lpParameters, buffer, MAX_PATH))
1351 lstrcpyW(wszParameters, buffer);
1353 if (*sei_tmp.lpDirectory)
1354 if (ExpandEnvironmentStringsW(sei_tmp.lpDirectory, buffer, MAX_PATH))
1355 lstrcpyW(wszDir, buffer);
1357 /* Else, try to execute the filename */
1358 TRACE("execute:%s,%s,%s\n", debugstr_w(wszApplicationName), debugstr_w(wszParameters), debugstr_w(wszDir));
1360 /* separate out command line arguments from executable file name */
1361 if (!*sei_tmp.lpParameters) {
1362 /* If the executable path is quoted, handle the rest of the command line as parameters. */
1363 if (sei_tmp.lpFile[0] == '"') {
1364 LPWSTR src = wszApplicationName/*sei_tmp.lpFile*/ + 1;
1365 LPWSTR dst = wfileName;
1368 /* copy the unquoted executable path to 'wfileName' */
1369 while(*src && *src!='"')
1377 while(isspace(*src))
1382 /* copy the parameter string to 'wszParameters' */
1383 strcpyW(wszParameters, src);
1385 /* terminate previous command string after the quote character */
1390 /* If the executable name is not quoted, we have to use this search loop here,
1391 that in CreateProcess() is not sufficient because it does not handle shell links. */
1392 WCHAR buffer[MAX_PATH], xlpFile[MAX_PATH];
1395 LPWSTR beg = wszApplicationName/*sei_tmp.lpFile*/;
1396 for(s=beg; (space=strchrW(s, ' ')); s=space+1) {
1397 int idx = space-sei_tmp.lpFile;
1398 memcpy(buffer, sei_tmp.lpFile, idx * sizeof(WCHAR));
1401 /*FIXME This finds directory paths if the targeted file name contains spaces. */
1402 if (SearchPathW(*sei_tmp.lpDirectory? sei_tmp.lpDirectory: NULL, buffer, wszExe, sizeof(xlpFile), xlpFile, NULL))
1404 /* separate out command from parameter string */
1405 LPCWSTR p = space + 1;
1410 strcpyW(wszParameters, p);
1417 strcpyW(wfileName, sei_tmp.lpFile);
1420 strcpyW(wfileName, sei_tmp.lpFile);
1424 strcpyW(wcmd, wszApplicationName);
1425 if (sei_tmp.lpParameters[0]) {
1426 strcatW(wcmd, wSpace);
1427 strcatW(wcmd, wszParameters);
1430 /* We set the default to open, and that should generally work.
1431 But that is not really the way the MS docs say to do it. */
1432 if (!sei_tmp.lpVerb)
1433 sei_tmp.lpVerb = wszOpen;
1435 retval = execfunc(wcmd, NULL, FALSE, &sei_tmp, sei);
1437 HeapFree(GetProcessHeap(), 0, wszApplicationName);
1441 /* Else, try to find the executable */
1443 retval = SHELL_FindExecutable(sei_tmp.lpDirectory, lpFile, sei_tmp.lpVerb, wcmd, 1024, lpstrProtocol, &env, sei_tmp.lpIDList, sei_tmp.lpParameters);
1444 if (retval > 32) /* Found */
1446 WCHAR wszQuotedCmd[MAX_PATH+2];
1447 /* Must quote to handle case where cmd contains spaces,
1448 * else security hole if malicious user creates executable file "C:\\Program"
1450 strcpyW(wszQuotedCmd, wQuote);
1451 strcatW(wszQuotedCmd, wcmd);
1452 strcatW(wszQuotedCmd, wQuote);
1453 if (wszParameters[0]) {
1454 strcatW(wszQuotedCmd, wSpace);
1455 strcatW(wszQuotedCmd, wszParameters);
1457 TRACE("%s/%s => %s/%s\n", debugstr_w(wszApplicationName), debugstr_w(sei_tmp.lpVerb), debugstr_w(wszQuotedCmd), debugstr_w(lpstrProtocol));
1459 retval = execute_from_key(lpstrProtocol, wszApplicationName, env, sei_tmp.lpParameters, wcmd, execfunc, &sei_tmp, sei);
1461 retval = execfunc(wszQuotedCmd, env, FALSE, &sei_tmp, sei);
1462 HeapFree( GetProcessHeap(), 0, env );
1464 else if (PathIsURLW((LPWSTR)lpFile)) /* File not found, check for URL */
1466 static const WCHAR wShell[] = {'\\','s','h','e','l','l','\\',0};
1467 static const WCHAR wCommand[] = {'\\','c','o','m','m','a','n','d',0};
1471 lpstrRes = strchrW(lpFile, ':');
1473 iSize = lpstrRes - lpFile;
1475 iSize = strlenW(lpFile);
1477 TRACE("Got URL: %s\n", debugstr_w(lpFile));
1478 /* Looking for ...protocol\shell\lpOperation\command */
1479 memcpy(lpstrProtocol, lpFile, iSize*sizeof(WCHAR));
1480 lpstrProtocol[iSize] = '\0';
1481 strcatW(lpstrProtocol, wShell);
1482 strcatW(lpstrProtocol, sei_tmp.lpVerb? sei_tmp.lpVerb: wszOpen);
1483 strcatW(lpstrProtocol, wCommand);
1485 /* Remove File Protocol from lpFile */
1486 /* In the case file://path/file */
1487 if (!strncmpiW(lpFile, wFile, iSize))
1490 while (*lpFile == ':') lpFile++;
1492 retval = execute_from_key(lpstrProtocol, lpFile, NULL, sei_tmp.lpParameters, wcmd, execfunc, &sei_tmp, sei);
1494 /* Check if file specified is in the form www.??????.*** */
1495 else if (!strncmpiW(lpFile, wWww, 3))
1497 /* if so, append lpFile http:// and call ShellExecute */
1498 WCHAR lpstrTmpFile[256];
1499 strcpyW(lpstrTmpFile, wHttp);
1500 strcatW(lpstrTmpFile, lpFile);
1501 retval = (UINT_PTR)ShellExecuteW(sei_tmp.hwnd, sei_tmp.lpVerb, lpstrTmpFile, NULL, NULL, 0);
1504 TRACE("retval %u\n", retval);
1506 HeapFree(GetProcessHeap(), 0, wszApplicationName);
1508 sei->hInstApp = (HINSTANCE)(retval > 32 ? 33 : retval);
1512 /*************************************************************************
1513 * ShellExecuteA [SHELL32.290]
1515 HINSTANCE WINAPI ShellExecuteA(HWND hWnd, LPCSTR lpOperation,LPCSTR lpFile,
1516 LPCSTR lpParameters,LPCSTR lpDirectory, INT iShowCmd)
1518 SHELLEXECUTEINFOA sei;
1520 TRACE("%p,%s,%s,%s,%s,%d\n",
1521 hWnd, debugstr_a(lpOperation), debugstr_a(lpFile),
1522 debugstr_a(lpParameters), debugstr_a(lpDirectory), iShowCmd);
1524 sei.cbSize = sizeof(sei);
1527 sei.lpVerb = lpOperation;
1528 sei.lpFile = lpFile;
1529 sei.lpParameters = lpParameters;
1530 sei.lpDirectory = lpDirectory;
1531 sei.nShow = iShowCmd;
1538 ShellExecuteExA (&sei);
1539 return sei.hInstApp;
1542 /*************************************************************************
1543 * ShellExecuteExA [SHELL32.292]
1546 BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
1548 SHELLEXECUTEINFOW seiW;
1550 WCHAR *wVerb = NULL, *wFile = NULL, *wParameters = NULL, *wDirectory = NULL, *wClass = NULL;
1554 memcpy(&seiW, sei, sizeof(SHELLEXECUTEINFOW));
1557 seiW.lpVerb = __SHCloneStrAtoW(&wVerb, sei->lpVerb);
1560 seiW.lpFile = __SHCloneStrAtoW(&wFile, sei->lpFile);
1562 if (sei->lpParameters)
1563 seiW.lpParameters = __SHCloneStrAtoW(&wParameters, sei->lpParameters);
1565 if (sei->lpDirectory)
1566 seiW.lpDirectory = __SHCloneStrAtoW(&wDirectory, sei->lpDirectory);
1568 if ((sei->fMask & SEE_MASK_CLASSALL) == SEE_MASK_CLASSNAME && sei->lpClass)
1569 seiW.lpClass = __SHCloneStrAtoW(&wClass, sei->lpClass);
1571 seiW.lpClass = NULL;
1573 ret = SHELL_execute( &seiW, SHELL_ExecuteW );
1575 sei->hInstApp = seiW.hInstApp;
1577 if (sei->fMask & SEE_MASK_NOCLOSEPROCESS)
1578 sei->hProcess = seiW.hProcess;
1580 if (wVerb) SHFree(wVerb);
1581 if (wFile) SHFree(wFile);
1582 if (wParameters) SHFree(wParameters);
1583 if (wDirectory) SHFree(wDirectory);
1584 if (wClass) SHFree(wClass);
1589 /*************************************************************************
1590 * ShellExecuteExW [SHELL32.293]
1593 BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
1595 return SHELL_execute( sei, SHELL_ExecuteW );
1598 /*************************************************************************
1599 * ShellExecuteW [SHELL32.294]
1601 * WINSHELLAPI HINSTANCE APIENTRY ShellExecuteW(HWND hwnd, LPCWSTR lpOperation,
1602 * LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
1604 HINSTANCE WINAPI ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile,
1605 LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd)
1607 SHELLEXECUTEINFOW sei;
1610 sei.cbSize = sizeof(sei);
1613 sei.lpVerb = lpOperation;
1614 sei.lpFile = lpFile;
1615 sei.lpParameters = lpParameters;
1616 sei.lpDirectory = lpDirectory;
1617 sei.nShow = nShowCmd;
1624 SHELL_execute( &sei, SHELL_ExecuteW );
1625 return sei.hInstApp;