| /* |
| * Shell Library Functions |
| * |
| * Copyright 1998 Marcus Meissner |
| * Copyright 2002 Eric Pouech |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <ctype.h> |
| #include <assert.h> |
| |
| #include "windef.h" |
| #include "winerror.h" |
| #include "winreg.h" |
| #include "shellapi.h" |
| #include "shlobj.h" |
| #include "shlwapi.h" |
| #include "ddeml.h" |
| |
| #include "wine/winbase16.h" |
| #include "shell32_main.h" |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(exec); |
| |
| /* this function is supposed to expand the escape sequences found in the registry |
| * some diving reported that the following were used: |
| * + %1, %2... seem to report to parameter of index N in ShellExecute pmts |
| + + %* seem to report to all parameter (or all remaining, ie after removing |
| * the already used %1 %2...) |
| * + %L seems to be %1 as long filename followed by the 8+3 variation |
| * + %l unknown |
| * + %S unknown |
| * + %I unknown |
| */ |
| static void argify(char* res, int len, const char* fmt, const char* lpFile) |
| { |
| char xlpFile[1024]; |
| |
| while (*fmt) |
| { |
| if (*fmt == '%') |
| { |
| switch (*++fmt) |
| { |
| case '\0': |
| case '%': |
| *res++ = '%'; |
| break; |
| case '1': |
| if (SearchPathA(NULL, lpFile, ".exe", sizeof(xlpFile), xlpFile, NULL)) |
| { |
| strcpy(res, xlpFile); |
| res += strlen(xlpFile); |
| } |
| else |
| { |
| strcpy(res, lpFile); |
| res += strlen(lpFile); |
| } |
| break; |
| default: FIXME("Unknown escape sequence %%%c\n", *fmt); |
| } |
| fmt++; |
| } |
| else |
| *res++ = *fmt++; |
| } |
| *res = '\0'; |
| } |
| |
| /************************************************************************* |
| * SHELL_FindExecutable [Internal] |
| * |
| * Utility for code sharing between FindExecutable and ShellExecute |
| * in: |
| * lpFile the name of a file |
| * lpOperation the operation on it (open) |
| * out: |
| * lpResult a buffer, big enough :-(, to store the command to do the |
| * operation on the file |
| * key a buffer, big enough, to get the key name to do actually the |
| * command (it'll be used afterwards for more information |
| * on the operation) |
| */ |
| static HINSTANCE SHELL_FindExecutable(LPCSTR lpFile, LPCSTR lpOperation, |
| LPSTR lpResult, LPSTR key) |
| { |
| char *extension = NULL; /* pointer to file extension */ |
| char tmpext[5]; /* local copy to mung as we please */ |
| char filetype[256]; /* registry name for this filetype */ |
| LONG filetypelen = 256; /* length of above */ |
| char command[256]; /* command from registry */ |
| LONG commandlen = 256; /* This is the most DOS can handle :) */ |
| char buffer[256]; /* Used to GetProfileString */ |
| HINSTANCE retval = 31; /* default - 'No association was found' */ |
| char *tok; /* token pointer */ |
| int i; /* random counter */ |
| char xlpFile[256] = ""; /* result of SearchPath */ |
| |
| TRACE("%s\n", (lpFile != NULL) ? lpFile : "-"); |
| |
| lpResult[0] = '\0'; /* Start off with an empty return string */ |
| |
| /* trap NULL parameters on entry */ |
| if ((lpFile == NULL) || (lpResult == NULL) || (lpOperation == NULL)) |
| { |
| WARN("(lpFile=%s,lpResult=%s,lpOperation=%s): NULL parameter\n", |
| lpFile, lpOperation, lpResult); |
| return 2; /* File not found. Close enough, I guess. */ |
| } |
| |
| if (SearchPathA(NULL, lpFile, ".exe", sizeof(xlpFile), xlpFile, NULL)) |
| { |
| TRACE("SearchPathA returned non-zero\n"); |
| lpFile = xlpFile; |
| } |
| |
| /* First thing we need is the file's extension */ |
| extension = strrchr(xlpFile, '.'); /* Assume last "." is the one; */ |
| /* File->Run in progman uses */ |
| /* .\FILE.EXE :( */ |
| TRACE("xlpFile=%s,extension=%s\n", xlpFile, extension); |
| |
| if ((extension == NULL) || (extension == &xlpFile[strlen(xlpFile)])) |
| { |
| WARN("Returning 31 - No association\n"); |
| return 31; /* no association */ |
| } |
| |
| /* Make local copy & lowercase it for reg & 'programs=' lookup */ |
| lstrcpynA(tmpext, extension, 5); |
| CharLowerA(tmpext); |
| TRACE("%s file\n", tmpext); |
| |
| /* Three places to check: */ |
| /* 1. win.ini, [windows], programs (NB no leading '.') */ |
| /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */ |
| /* 3. win.ini, [extensions], extension (NB no leading '.' */ |
| /* All I know of the order is that registry is checked before */ |
| /* extensions; however, it'd make sense to check the programs */ |
| /* section first, so that's what happens here. */ |
| |
| if (key) *key = '\0'; |
| |
| /* See if it's a program - if GetProfileString fails, we skip this |
| * section. Actually, if GetProfileString fails, we've probably |
| * got a lot more to worry about than running a program... */ |
| if (GetProfileStringA("windows", "programs", "exe pif bat com", |
| buffer, sizeof(buffer)) > 0) |
| { |
| for (i = 0;i<strlen(buffer); i++) buffer[i] = tolower(buffer[i]); |
| |
| tok = strtok(buffer, " \t"); /* ? */ |
| while (tok!= NULL) |
| { |
| if (strcmp(tok, &tmpext[1]) == 0) /* have to skip the leading "." */ |
| { |
| strcpy(lpResult, xlpFile); |
| /* Need to perhaps check that the file has a path |
| * attached */ |
| TRACE("found %s\n", lpResult); |
| return 33; |
| |
| /* Greater than 32 to indicate success FIXME According to the |
| * docs, I should be returning a handle for the |
| * executable. Does this mean I'm supposed to open the |
| * executable file or something? More RTFM, I guess... */ |
| } |
| tok = strtok(NULL, " \t"); |
| } |
| } |
| |
| /* Check registry */ |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, tmpext, filetype, |
| &filetypelen) == ERROR_SUCCESS) |
| { |
| filetype[filetypelen] = '\0'; |
| TRACE("File type: %s\n", filetype); |
| |
| /* Looking for ...buffer\shell\lpOperation\command */ |
| strcat(filetype, "\\shell\\"); |
| strcat(filetype, lpOperation); |
| strcat(filetype, "\\command"); |
| |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, filetype, command, |
| &commandlen) == ERROR_SUCCESS) |
| { |
| if (key) strcpy(key, filetype); |
| #if 0 |
| LPSTR tmp; |
| char param[256]; |
| LONG paramlen = 256; |
| |
| /* FIXME: it seems all Windows version don't behave the same here. |
| * the doc states that this ddeexec information can be found after |
| * the exec names. |
| * on Win98, it doesn't appear, but I think it does on Win2k |
| */ |
| /* Get the parameters needed by the application |
| from the associated ddeexec key */ |
| tmp = strstr(filetype, "command"); |
| tmp[0] = '\0'; |
| strcat(filetype, "ddeexec"); |
| |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, filetype, param, ¶mlen) == ERROR_SUCCESS) |
| { |
| strcat(command, " "); |
| strcat(command, param); |
| commandlen += paramlen; |
| } |
| #endif |
| command[commandlen] = '\0'; |
| argify(lpResult, sizeof(lpResult), command, xlpFile); |
| retval = 33; /* FIXME see above */ |
| } |
| } |
| else /* Check win.ini */ |
| { |
| /* Toss the leading dot */ |
| extension++; |
| if (GetProfileStringA("extensions", extension, "", command, |
| sizeof(command)) > 0) |
| { |
| if (strlen(command) != 0) |
| { |
| strcpy(lpResult, command); |
| tok = strstr(lpResult, "^"); /* should be ^.extension? */ |
| if (tok != NULL) |
| { |
| tok[0] = '\0'; |
| strcat(lpResult, xlpFile); /* what if no dir in xlpFile? */ |
| tok = strstr(command, "^"); /* see above */ |
| if ((tok != NULL) && (strlen(tok)>5)) |
| { |
| strcat(lpResult, &tok[5]); |
| } |
| } |
| retval = 33; /* FIXME - see above */ |
| } |
| } |
| } |
| |
| TRACE("returning %s\n", lpResult); |
| return retval; |
| } |
| |
| /****************************************************************** |
| * dde_cb |
| * |
| * callback for the DDE connection. not really usefull |
| */ |
| static HDDEDATA CALLBACK dde_cb(UINT uType, UINT uFmt, HCONV hConv, |
| HSZ hsz1, HSZ hsz2, |
| HDDEDATA hData, DWORD dwData1, DWORD dwData2) |
| { |
| return (HDDEDATA)0; |
| } |
| |
| /****************************************************************** |
| * dde_connect |
| * |
| * ShellExecute helper. Used to do an operation with a DDE connection |
| * |
| * Handles both the direct connection (try #1), and if it fails, |
| * launching an application and trying (#2) to connect to it |
| * |
| */ |
| static unsigned dde_connect(char* key, char* start, char* ddeexec, |
| const char* lpFile, |
| int iCmdShow, BOOL is32) |
| { |
| char* endkey = key + strlen(key); |
| char app[256], topic[256], ifexec[256], res[256]; |
| LONG applen, topiclen, ifexeclen; |
| char* exec; |
| DWORD ddeInst = 0; |
| DWORD tid; |
| HSZ hszApp, hszTopic; |
| HCONV hConv; |
| unsigned ret = 31; |
| |
| strcpy(endkey, "\\application"); |
| applen = sizeof(app); |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, key, app, &applen) != ERROR_SUCCESS) |
| { |
| FIXME("default app name NIY %s\n", key); |
| return 2; |
| } |
| |
| strcpy(endkey, "\\topic"); |
| topiclen = sizeof(topic); |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, key, topic, &topiclen) != ERROR_SUCCESS) |
| { |
| strcpy(topic, "System"); |
| } |
| |
| if (DdeInitializeA(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR) |
| { |
| return 2; |
| } |
| |
| hszApp = DdeCreateStringHandleA(ddeInst, app, CP_WINANSI); |
| hszTopic = DdeCreateStringHandleA(ddeInst, topic, CP_WINANSI); |
| |
| hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL); |
| exec = ddeexec; |
| if (!hConv) |
| { |
| TRACE("Launching '%s'\n", start); |
| ret = (is32) ? WinExec(start, iCmdShow) : WinExec16(start, iCmdShow); |
| if (ret < 32) |
| { |
| TRACE("Couldn't launch\n"); |
| goto error; |
| } |
| hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL); |
| if (!hConv) |
| { |
| ret = 30; /* whatever */ |
| goto error; |
| } |
| strcpy(endkey, "\\ifexec"); |
| ifexeclen = sizeof(ifexec); |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, key, ifexec, &ifexeclen) == ERROR_SUCCESS) |
| { |
| exec = ifexec; |
| } |
| } |
| |
| argify(res, sizeof(res), exec, lpFile); |
| TRACE("%s %s => %s\n", exec, lpFile, res); |
| |
| ret = (DdeClientTransaction(res, strlen(res) + 1, hConv, 0L, 0, |
| XTYP_EXECUTE, 10000, &tid) != DMLERR_NO_ERROR) ? 31 : 32; |
| DdeDisconnect(hConv); |
| error: |
| DdeUninitialize(ddeInst); |
| return ret; |
| } |
| |
| static HINSTANCE execute_from_key(LPSTR key, LPCSTR lpFile, INT iShowCmd, BOOL is32) |
| { |
| char cmd[1024] = ""; |
| LONG cmdlen = sizeof(cmd); |
| HINSTANCE retval = 31; |
| |
| /* Get the application for the registry */ |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, key, cmd, &cmdlen) == ERROR_SUCCESS) |
| { |
| LPSTR tmp; |
| char param[256] = ""; |
| LONG paramlen = 256; |
| |
| /* Get the parameters needed by the application |
| from the associated ddeexec key */ |
| tmp = strstr(key, "command"); |
| assert(tmp); |
| strcpy(tmp, "ddeexec"); |
| |
| if (RegQueryValueA(HKEY_CLASSES_ROOT, key, param, ¶mlen) == ERROR_SUCCESS) |
| { |
| TRACE("Got ddeexec %s => %s\n", key, param); |
| retval = dde_connect(key, cmd, param, lpFile, iShowCmd, is32); |
| } |
| else |
| { |
| /* Is there a replace() function anywhere? */ |
| cmd[cmdlen] = '\0'; |
| argify(param, sizeof(param), cmd, lpFile); |
| |
| retval = (is32) ? WinExec(param, iShowCmd) : WinExec16(param, iShowCmd); |
| } |
| } |
| else TRACE("ooch\n"); |
| |
| return retval; |
| } |
| |
| static HINSTANCE SHELL_Execute(HWND hWnd, LPCSTR lpOperation, LPCSTR lpFile, |
| LPCSTR lpParameters, LPCSTR lpDirectory, |
| INT iShowCmd, BOOL is32) |
| { |
| HINSTANCE retval = 31; |
| char old_dir[1024]; |
| char cmd[1024]; |
| |
| TRACE("(%04x,'%s','%s','%s','%s',%x)\n", |
| hWnd, lpOperation ? lpOperation:"<null>", lpFile ? lpFile:"<null>", |
| lpParameters ? lpParameters : "<null>", |
| lpDirectory ? lpDirectory : "<null>", iShowCmd); |
| |
| if (lpFile == NULL) return 0; /* should not happen */ |
| if (lpOperation == NULL) /* default is open */ |
| lpOperation = "open"; |
| |
| if (lpDirectory) |
| { |
| GetCurrentDirectoryA(sizeof(old_dir), old_dir); |
| SetCurrentDirectoryA(lpDirectory); |
| } |
| |
| /* First try to execute lpFile with lpParameters directly */ |
| strcpy(cmd, lpFile); |
| if (lpParameters) |
| { |
| strcat(cmd, " "); |
| strcat(cmd, lpParameters); |
| } |
| |
| retval = (is32) ? WinExec(cmd, iShowCmd) : WinExec16(cmd, iShowCmd); |
| |
| /* Unable to execute lpFile directly |
| Check if we can match an application to lpFile */ |
| if (retval < 32) |
| { |
| char lpstrProtocol[256]; |
| |
| cmd[0] = '\0'; |
| retval = SHELL_FindExecutable(lpFile, lpOperation, cmd, lpstrProtocol); |
| |
| if (retval > 32) /* Found */ |
| { |
| TRACE("%s/%s => %s/%s\n", lpFile, lpOperation, cmd, lpstrProtocol); |
| if (*lpstrProtocol) |
| retval = execute_from_key(lpstrProtocol, lpFile, iShowCmd, is32); |
| else |
| retval = (is32) ? WinExec(cmd, iShowCmd) : WinExec16(cmd, iShowCmd); |
| } |
| else if (PathIsURLA((LPSTR)lpFile)) /* File not found, check for URL */ |
| { |
| LPSTR lpstrRes; |
| INT iSize; |
| |
| lpstrRes = strchr(lpFile, ':'); |
| iSize = lpstrRes - lpFile; |
| |
| TRACE("Got URL: %s\n", lpFile); |
| /* Looking for ...protocol\shell\lpOperation\command */ |
| strncpy(lpstrProtocol, lpFile, iSize); |
| lpstrProtocol[iSize] = '\0'; |
| strcat(lpstrProtocol, "\\shell\\"); |
| strcat(lpstrProtocol, lpOperation); |
| strcat(lpstrProtocol, "\\command"); |
| |
| /* Remove File Protocol from lpFile */ |
| /* In the case file://path/file */ |
| if (!strncasecmp(lpFile, "file", iSize)) |
| { |
| lpFile += iSize; |
| while (*lpFile == ':') lpFile++; |
| } |
| |
| retval = execute_from_key(lpstrProtocol, lpFile, iShowCmd, is32); |
| } |
| /* Check if file specified is in the form www.??????.*** */ |
| else if (!strncasecmp(lpFile, "www", 3)) |
| { |
| /* if so, append lpFile http:// and call ShellExecute */ |
| char lpstrTmpFile[256] = "http://" ; |
| strcat(lpstrTmpFile, lpFile); |
| retval = ShellExecuteA(hWnd, lpOperation, lpstrTmpFile, NULL, NULL, 0); |
| } |
| } |
| if (lpDirectory) |
| SetCurrentDirectoryA(old_dir); |
| return retval; |
| } |
| |
| /************************************************************************* |
| * FindExecutableA [SHELL32.@] |
| */ |
| HINSTANCE WINAPI FindExecutableA(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult) |
| { |
| HINSTANCE retval = 31; /* default - 'No association was found' */ |
| char old_dir[1024]; |
| |
| TRACE("File %s, Dir %s\n", |
| (lpFile != NULL ? lpFile : "-"), (lpDirectory != NULL ? lpDirectory : "-")); |
| |
| lpResult[0] = '\0'; /* Start off with an empty return string */ |
| |
| /* trap NULL parameters on entry */ |
| if ((lpFile == NULL) || (lpResult == NULL)) |
| { |
| /* FIXME - should throw a warning, perhaps! */ |
| return 2; /* File not found. Close enough, I guess. */ |
| } |
| |
| if (lpDirectory) |
| { |
| GetCurrentDirectoryA(sizeof(old_dir), old_dir); |
| SetCurrentDirectoryA(lpDirectory); |
| } |
| |
| retval = SHELL_FindExecutable(lpFile, "open", lpResult, NULL); |
| |
| TRACE("returning %s\n", lpResult); |
| if (lpDirectory) |
| SetCurrentDirectoryA(old_dir); |
| return retval; |
| } |
| |
| /************************************************************************* |
| * FindExecutableW [SHELL32.@] |
| */ |
| HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult) |
| { |
| FIXME("(%p,%p,%p): stub\n", lpFile, lpDirectory, lpResult); |
| return 31; /* default - 'No association was found' */ |
| } |
| |
| /************************************************************************* |
| * ShellExecute [SHELL.20] |
| */ |
| HINSTANCE16 WINAPI ShellExecute16( HWND16 hWnd, LPCSTR lpOperation, |
| LPCSTR lpFile, LPCSTR lpParameters, |
| LPCSTR lpDirectory, INT16 iShowCmd ) |
| { |
| return (HINSTANCE16)SHELL_Execute(hWnd, lpOperation, lpFile, |
| lpParameters, lpDirectory, iShowCmd, FALSE ); |
| } |
| |
| /************************************************************************* |
| * ShellExecuteA [SHELL32.290] |
| */ |
| HINSTANCE WINAPI ShellExecuteA(HWND hWnd, LPCSTR lpOperation,LPCSTR lpFile, |
| LPCSTR lpParameters,LPCSTR lpDirectory, INT iShowCmd) |
| { |
| TRACE("\n"); |
| return SHELL_Execute( hWnd, lpOperation, lpFile, lpParameters, |
| lpDirectory, iShowCmd, TRUE ); |
| } |
| |
| /************************************************************************* |
| * ShellExecuteW [SHELL32.294] |
| * from shellapi.h |
| * WINSHELLAPI HINSTANCE APIENTRY ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, |
| * LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd); |
| */ |
| HINSTANCE WINAPI ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, |
| LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd) |
| { |
| FIXME(": stub\n"); |
| return 0; |
| } |
| |