/* * Unit test of the ShellExecute function. * * Copyright 2005 Francois Gouget for CodeWeavers * * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* TODO: * - test the default verb selection * - test selection of an alternate class * - try running executables in more ways * - try passing arguments to executables * - ShellExecute("foo.shlexec") with no path should work if foo.shlexec is * in the PATH * - test associations that use %l, %L or "%1" instead of %1 * - we may want to test ShellExecuteEx() instead of ShellExecute() * and then we could also check its return value * - ShellExecuteEx() also calls SetLastError() with meaningful values which * we could check */ /* Needed to get SEE_MASK_NOZONECHECKS with the PSDK */ #define NTDDI_WINXPSP1 0x05010100 #define NTDDI_VERSION NTDDI_WINXPSP1 #define _WIN32_WINNT 0x0501 #include #include #include "wtypes.h" #include "winbase.h" #include "windef.h" #include "shellapi.h" #include "shlwapi.h" #include "wine/test.h" #include "shell32_test.h" static char argv0[MAX_PATH]; static int myARGC; static char** myARGV; static char tmpdir[MAX_PATH]; static char child_file[MAX_PATH]; static DLLVERSIONINFO dllver; static BOOL skip_noassoc_tests = FALSE; static HANDLE dde_ready_event; /*** * * ShellExecute wrappers * ***/ static void dump_child(void); static HANDLE hEvent; static void init_event(const char* child_file) { char* event_name; event_name=strrchr(child_file, '\\')+1; hEvent=CreateEvent(NULL, FALSE, FALSE, event_name); } static void strcat_param(char* str, const char* name, const char* param) { if (param) { if (str[strlen(str)-1] == '"') strcat(str, ", "); strcat(str, name); strcat(str, "=\""); strcat(str, param); strcat(str, "\""); } } static int _todo_wait = 0; #define todo_wait for (_todo_wait = 1; _todo_wait; _todo_wait = 0) static char shell_call[2048]=""; static int bad_shellexecute = 0; static INT_PTR shell_execute(LPCSTR verb, LPCSTR file, LPCSTR parameters, LPCSTR directory) { INT_PTR rc, rcEmpty = 0; if(!verb) rcEmpty = shell_execute("", file, parameters, directory); strcpy(shell_call, "ShellExecute("); strcat_param(shell_call, "verb", verb); strcat_param(shell_call, "file", file); strcat_param(shell_call, "params", parameters); strcat_param(shell_call, "dir", directory); strcat(shell_call, ")"); if (winetest_debug > 1) trace("%s\n", shell_call); DeleteFile(child_file); SetLastError(0xcafebabe); /* FIXME: We cannot use ShellExecuteEx() here because if there is no * association it displays the 'Open With' dialog and I could not find * a flag to prevent this. */ rc=(INT_PTR)ShellExecute(NULL, verb, file, parameters, directory, SW_SHOWNORMAL); if (rc > 32) { int wait_rc; wait_rc=WaitForSingleObject(hEvent, 5000); if (wait_rc == WAIT_TIMEOUT) { HWND wnd = FindWindowA("#32770", "Windows"); if (wnd != NULL) { SendMessage(wnd, WM_CLOSE, 0, 0); win_skip("Skipping shellexecute of file with unassociated extension\n"); skip_noassoc_tests = TRUE; rc = SE_ERR_NOASSOC; } } if (!_todo_wait) ok(wait_rc==WAIT_OBJECT_0 || rc <= 32, "%s WaitForSingleObject returned %d\n", shell_call, wait_rc); else todo_wine ok(wait_rc==WAIT_OBJECT_0 || rc <= 32, "%s WaitForSingleObject returned %d\n", shell_call, wait_rc); } /* The child process may have changed the result file, so let profile * functions know about it */ WritePrivateProfileStringA(NULL, NULL, NULL, child_file); if (rc > 32) dump_child(); if(!verb) { if (rc != rcEmpty && rcEmpty == SE_ERR_NOASSOC) /* NT4 */ bad_shellexecute = 1; ok(rc == rcEmpty || broken(rc != rcEmpty && rcEmpty == SE_ERR_NOASSOC) /* NT4 */, "%s Got different return value with empty string: %lu %lu\n", shell_call, rc, rcEmpty); } return rc; } static INT_PTR shell_execute_ex(DWORD mask, LPCSTR verb, LPCSTR file, LPCSTR parameters, LPCSTR directory, LPCSTR class) { SHELLEXECUTEINFO sei; BOOL success; INT_PTR rc; strcpy(shell_call, "ShellExecuteEx("); if (mask) { char smask[11]; sprintf(smask, "0x%x", mask); strcat_param(shell_call, "mask", smask); } strcat_param(shell_call, "verb", verb); strcat_param(shell_call, "file", file); strcat_param(shell_call, "params", parameters); strcat_param(shell_call, "dir", directory); strcat_param(shell_call, "class", class); strcat(shell_call, ")"); if (winetest_debug > 1) trace("%s\n", shell_call); sei.cbSize=sizeof(sei); sei.fMask=SEE_MASK_NOCLOSEPROCESS | mask; sei.hwnd=NULL; sei.lpVerb=verb; sei.lpFile=file; sei.lpParameters=parameters; sei.lpDirectory=directory; sei.nShow=SW_SHOWNORMAL; sei.hInstApp=NULL; /* Out */ sei.lpIDList=NULL; sei.lpClass=class; sei.hkeyClass=NULL; sei.dwHotKey=0; U(sei).hIcon=NULL; sei.hProcess=NULL; /* Out */ DeleteFile(child_file); SetLastError(0xcafebabe); success=ShellExecuteEx(&sei); rc=(INT_PTR)sei.hInstApp; ok((success && rc > 32) || (!success && rc <= 32), "%s rc=%d and hInstApp=%ld is not allowed\n", shell_call, success, rc); if (rc > 32) { int wait_rc; if (sei.hProcess!=NULL) { wait_rc=WaitForSingleObject(sei.hProcess, 5000); ok(wait_rc==WAIT_OBJECT_0, "WaitForSingleObject(hProcess) returned %d\n", wait_rc); } wait_rc=WaitForSingleObject(hEvent, 5000); if (!_todo_wait) ok(wait_rc==WAIT_OBJECT_0, "WaitForSingleObject returned %d\n", wait_rc); else todo_wine ok(wait_rc==WAIT_OBJECT_0, "WaitForSingleObject returned %d\n", wait_rc); } /* The child process may have changed the result file, so let profile * functions know about it */ WritePrivateProfileStringA(NULL, NULL, NULL, child_file); if (rc > 32) dump_child(); return rc; } /*** * * Functions to create / delete associations wrappers * ***/ static BOOL create_test_association(const char* extension) { HKEY hkey, hkey_shell; char class[MAX_PATH]; LONG rc; sprintf(class, "shlexec%s", extension); rc=RegCreateKeyEx(HKEY_CLASSES_ROOT, extension, 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey, NULL); if (rc != ERROR_SUCCESS) return FALSE; rc=RegSetValueEx(hkey, NULL, 0, REG_SZ, (LPBYTE) class, strlen(class)+1); ok(rc==ERROR_SUCCESS, "RegSetValueEx '%s' failed, expected ERROR_SUCCESS, got %d\n", class, rc); CloseHandle(hkey); rc=RegCreateKeyEx(HKEY_CLASSES_ROOT, class, 0, NULL, 0, KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS, NULL, &hkey, NULL); ok(rc==ERROR_SUCCESS, "RegCreateKeyEx '%s' failed, expected ERROR_SUCCESS, got %d\n", class, rc); rc=RegCreateKeyEx(hkey, "shell", 0, NULL, 0, KEY_CREATE_SUB_KEY, NULL, &hkey_shell, NULL); ok(rc==ERROR_SUCCESS, "RegCreateKeyEx 'shell' failed, expected ERROR_SUCCESS, got %d\n", rc); CloseHandle(hkey); CloseHandle(hkey_shell); return TRUE; } /* Based on RegDeleteTreeW from dlls/advapi32/registry.c */ static LSTATUS myRegDeleteTreeA(HKEY hKey, LPCSTR lpszSubKey) { LONG ret; DWORD dwMaxSubkeyLen, dwMaxValueLen; DWORD dwMaxLen, dwSize; CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf; HKEY hSubKey = hKey; if(lpszSubKey) { ret = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey); if (ret) return ret; } /* Get highest length for keys, values */ ret = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL, &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL); if (ret) goto cleanup; dwMaxSubkeyLen++; dwMaxValueLen++; dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen); if (dwMaxLen > sizeof(szNameBuf)/sizeof(CHAR)) { /* Name too big: alloc a buffer for it */ if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(CHAR)))) { ret = ERROR_NOT_ENOUGH_MEMORY; goto cleanup; } } /* Recursively delete all the subkeys */ while (TRUE) { dwSize = dwMaxLen; if (RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL, NULL, NULL, NULL)) break; ret = myRegDeleteTreeA(hSubKey, lpszName); if (ret) goto cleanup; } if (lpszSubKey) ret = RegDeleteKeyA(hKey, lpszSubKey); else while (TRUE) { dwSize = dwMaxLen; if (RegEnumValueA(hKey, 0, lpszName, &dwSize, NULL, NULL, NULL, NULL)) break; ret = RegDeleteValueA(hKey, lpszName); if (ret) goto cleanup; } cleanup: /* Free buffer if allocated */ if (lpszName != szNameBuf) HeapFree( GetProcessHeap(), 0, lpszName); if(lpszSubKey) RegCloseKey(hSubKey); return ret; } static void delete_test_association(const char* extension) { char class[MAX_PATH]; sprintf(class, "shlexec%s", extension); myRegDeleteTreeA(HKEY_CLASSES_ROOT, class); myRegDeleteTreeA(HKEY_CLASSES_ROOT, extension); } static void create_test_verb_dde(const char* extension, const char* verb, int rawcmd, const char* cmdtail, const char *ddeexec, const char *application, const char *topic, const char *ifexec) { HKEY hkey_shell, hkey_verb, hkey_cmd; char shell[MAX_PATH]; char* cmd; LONG rc; sprintf(shell, "shlexec%s\\shell", extension); rc=RegOpenKeyEx(HKEY_CLASSES_ROOT, shell, 0, KEY_CREATE_SUB_KEY, &hkey_shell); assert(rc==ERROR_SUCCESS); rc=RegCreateKeyEx(hkey_shell, verb, 0, NULL, 0, KEY_CREATE_SUB_KEY, NULL, &hkey_verb, NULL); assert(rc==ERROR_SUCCESS); rc=RegCreateKeyEx(hkey_verb, "command", 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey_cmd, NULL); assert(rc==ERROR_SUCCESS); if (rawcmd) { rc=RegSetValueEx(hkey_cmd, NULL, 0, REG_SZ, (LPBYTE)cmdtail, strlen(cmdtail)+1); } else { cmd=HeapAlloc(GetProcessHeap(), 0, strlen(argv0)+10+strlen(child_file)+2+strlen(cmdtail)+1); sprintf(cmd,"%s shlexec \"%s\" %s", argv0, child_file, cmdtail); rc=RegSetValueEx(hkey_cmd, NULL, 0, REG_SZ, (LPBYTE)cmd, strlen(cmd)+1); assert(rc==ERROR_SUCCESS); HeapFree(GetProcessHeap(), 0, cmd); } if (ddeexec) { HKEY hkey_ddeexec, hkey_application, hkey_topic, hkey_ifexec; rc=RegCreateKeyEx(hkey_verb, "ddeexec", 0, NULL, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY, NULL, &hkey_ddeexec, NULL); assert(rc==ERROR_SUCCESS); rc=RegSetValueEx(hkey_ddeexec, NULL, 0, REG_SZ, (LPBYTE)ddeexec, strlen(ddeexec)+1); assert(rc==ERROR_SUCCESS); if (application) { rc=RegCreateKeyEx(hkey_ddeexec, "application", 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey_application, NULL); assert(rc==ERROR_SUCCESS); rc=RegSetValueEx(hkey_application, NULL, 0, REG_SZ, (LPBYTE)application, strlen(application)+1); assert(rc==ERROR_SUCCESS); CloseHandle(hkey_application); } if (topic) { rc=RegCreateKeyEx(hkey_ddeexec, "topic", 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey_topic, NULL); assert(rc==ERROR_SUCCESS); rc=RegSetValueEx(hkey_topic, NULL, 0, REG_SZ, (LPBYTE)topic, strlen(topic)+1); assert(rc==ERROR_SUCCESS); CloseHandle(hkey_topic); } if (ifexec) { rc=RegCreateKeyEx(hkey_ddeexec, "ifexec", 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey_ifexec, NULL); assert(rc==ERROR_SUCCESS); rc=RegSetValueEx(hkey_ifexec, NULL, 0, REG_SZ, (LPBYTE)ifexec, strlen(ifexec)+1); assert(rc==ERROR_SUCCESS); CloseHandle(hkey_ifexec); } CloseHandle(hkey_ddeexec); } CloseHandle(hkey_shell); CloseHandle(hkey_verb); CloseHandle(hkey_cmd); } static void create_test_verb(const char* extension, const char* verb, int rawcmd, const char* cmdtail) { create_test_verb_dde(extension, verb, rawcmd, cmdtail, NULL, NULL, NULL, NULL); } /*** * * Functions to check that the child process was started just right * (borrowed from dlls/kernel32/tests/process.c) * ***/ static const char* encodeA(const char* str) { static char encoded[2*1024+1]; char* ptr; size_t len,i; if (!str) return ""; len = strlen(str) + 1; if (len >= sizeof(encoded)/2) { fprintf(stderr, "string is too long!\n"); assert(0); } ptr = encoded; for (i = 0; i < len; i++) sprintf(&ptr[i * 2], "%02x", (unsigned char)str[i]); ptr[2 * len] = '\0'; return ptr; } static unsigned decode_char(char c) { if (c >= '0' && c <= '9') return c - '0'; if (c >= 'a' && c <= 'f') return c - 'a' + 10; assert(c >= 'A' && c <= 'F'); return c - 'A' + 10; } static char* decodeA(const char* str) { static char decoded[1024]; char* ptr; size_t len,i; len = strlen(str) / 2; if (!len--) return NULL; if (len >= sizeof(decoded)) { fprintf(stderr, "string is too long!\n"); assert(0); } ptr = decoded; for (i = 0; i < len; i++) ptr[i] = (decode_char(str[2 * i]) << 4) | decode_char(str[2 * i + 1]); ptr[len] = '\0'; return ptr; } static void childPrintf(HANDLE h, const char* fmt, ...) { va_list valist; char buffer[1024]; DWORD w; va_start(valist, fmt); vsprintf(buffer, fmt, valist); va_end(valist); WriteFile(h, buffer, strlen(buffer), &w, NULL); } static DWORD ddeInst; static HSZ hszTopic; static char ddeExec[MAX_PATH], ddeApplication[MAX_PATH]; static BOOL post_quit_on_execute; static HDDEDATA CALLBACK ddeCb(UINT uType, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2, HDDEDATA hData, ULONG_PTR dwData1, ULONG_PTR dwData2) { DWORD size = 0; if (winetest_debug > 2) trace("dde_cb: %04x, %04x, %p, %p, %p, %p, %08lx, %08lx\n", uType, uFmt, hConv, hsz1, hsz2, hData, dwData1, dwData2); switch (uType) { case XTYP_CONNECT: if (!DdeCmpStringHandles(hsz1, hszTopic)) { size = DdeQueryString(ddeInst, hsz2, ddeApplication, MAX_PATH, CP_WINANSI); assert(size < MAX_PATH); return (HDDEDATA)TRUE; } return (HDDEDATA)FALSE; case XTYP_EXECUTE: size = DdeGetData(hData, (LPBYTE)ddeExec, MAX_PATH, 0L); assert(size < MAX_PATH); DdeFreeDataHandle(hData); if (post_quit_on_execute) PostQuitMessage(0); return (HDDEDATA)DDE_FACK; default: return NULL; } } /* * This is just to make sure the child won't run forever stuck in a GetMessage() * loop when DDE fails for some reason. */ static void CALLBACK childTimeout(HWND wnd, UINT msg, UINT_PTR timer, DWORD time) { trace("childTimeout called\n"); PostQuitMessage(0); } static void doChild(int argc, char** argv) { char *filename, longpath[MAX_PATH] = ""; HANDLE hFile, map; int i; int rc; HSZ hszApplication; UINT_PTR timer; HANDLE dde_ready; MSG msg; char *shared_block; filename=argv[2]; hFile=CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0); if (hFile == INVALID_HANDLE_VALUE) return; /* Arguments */ childPrintf(hFile, "[Arguments]\r\n"); if (winetest_debug > 2) { trace("cmdlineA='%s'\n", GetCommandLineA()); trace("argcA=%d\n", argc); } childPrintf(hFile, "cmdlineA=%s\r\n", encodeA(GetCommandLineA())); childPrintf(hFile, "argcA=%d\r\n", argc); for (i = 0; i < argc; i++) { if (winetest_debug > 2) trace("argvA%d='%s'\n", i, argv[i]); childPrintf(hFile, "argvA%d=%s\r\n", i, encodeA(argv[i])); } GetModuleFileNameA(GetModuleHandleA(NULL), longpath, MAX_PATH); childPrintf(hFile, "longPath=%s\r\n", encodeA(longpath)); map = OpenFileMappingA(FILE_MAP_READ, FALSE, "winetest_shlexec_dde_map"); if (map != NULL) { shared_block = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 4096); CloseHandle(map); if (shared_block[0] != '\0' || shared_block[1] != '\0') { post_quit_on_execute = TRUE; ddeInst = 0; rc = DdeInitializeA(&ddeInst, ddeCb, CBF_SKIP_ALLNOTIFICATIONS | CBF_FAIL_ADVISES | CBF_FAIL_POKES | CBF_FAIL_REQUESTS, 0L); assert(rc == DMLERR_NO_ERROR); hszApplication = DdeCreateStringHandleA(ddeInst, shared_block, CP_WINANSI); hszTopic = DdeCreateStringHandleA(ddeInst, shared_block + strlen(shared_block) + 1, CP_WINANSI); assert(hszApplication && hszTopic); assert(DdeNameService(ddeInst, hszApplication, 0L, DNS_REGISTER | DNS_FILTEROFF)); timer = SetTimer(NULL, 0, 2500, childTimeout); dde_ready = OpenEvent(EVENT_MODIFY_STATE, FALSE, "winetest_shlexec_dde_ready"); SetEvent(dde_ready); CloseHandle(dde_ready); while (GetMessage(&msg, NULL, 0, 0)) DispatchMessage(&msg); Sleep(500); KillTimer(NULL, timer); assert(DdeNameService(ddeInst, hszApplication, 0L, DNS_UNREGISTER)); assert(DdeFreeStringHandle(ddeInst, hszTopic)); assert(DdeFreeStringHandle(ddeInst, hszApplication)); assert(DdeUninitialize(ddeInst)); } else { dde_ready = OpenEvent(EVENT_MODIFY_STATE, FALSE, "winetest_shlexec_dde_ready"); SetEvent(dde_ready); CloseHandle(dde_ready); } UnmapViewOfFile(shared_block); childPrintf(hFile, "ddeExec=%s\r\n", encodeA(ddeExec)); } CloseHandle(hFile); init_event(filename); SetEvent(hEvent); CloseHandle(hEvent); } static char* getChildString(const char* sect, const char* key) { char buf[1024]; char* ret; GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), child_file); if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL; assert(!(strlen(buf) & 1)); ret = decodeA(buf); return ret; } static void dump_child(void) { if (winetest_debug > 1) { char key[18]; char* str; int i, c; str=getChildString("Arguments", "cmdlineA"); trace("cmdlineA='%s'\n", str); c=GetPrivateProfileIntA("Arguments", "argcA", -1, child_file); trace("argcA=%d\n",c); for (i=0;i 32, "%s failed: rc=%lu\n", shell_call, rc); /* if quoted, existing "drawback_file.noassoc" not prevents finding "drawback_file.noassoc foo.shlexec" on wine */ sprintf(fileA, "\"%s\\drawback_file.noassoc foo.shlexec\"", tmpdir); rc=shell_execute(NULL, fileA, NULL, NULL); ok(rc > 32 || broken(rc == SE_ERR_FNF) /* Win95/NT4 */, "%s failed: rc=%lu\n", shell_call, rc); /* error should be SE_ERR_FNF, not SE_ERR_NOASSOC */ sprintf(fileA, "\"%s\\drawback_file.noassoc\" foo.shlexec", tmpdir); rc=shell_execute(NULL, fileA, NULL, NULL); ok(rc == SE_ERR_FNF, "%s succeeded: rc=%lu\n", shell_call, rc); /* ""command"" not works on wine (and real win9x and w2k) */ sprintf(fileA, "\"\"%s\\simple.shlexec\"\"", tmpdir); rc=shell_execute(NULL, fileA, NULL, NULL); todo_wine ok(rc > 32 || broken(rc == SE_ERR_FNF) /* Win9x/2000 */, "%s failed: rc=%lu\n", shell_call, rc); /* nonexisting "drawback_nonexist.noassoc" not prevents finding "drawback_nonexist.noassoc foo.shlexec" on wine */ sprintf(fileA, "%s\\drawback_nonexist.noassoc foo.shlexec", tmpdir); rc=shell_execute(NULL, fileA, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc); /* is SEE_MASK_DOENVSUBST default flag? Should only be when XP emulates 9x (XP bug or real 95 or ME behavior ?) */ rc=shell_execute(NULL, "%TMPDIR%\\simple.shlexec", NULL, NULL); todo_wine ok(rc == SE_ERR_FNF, "%s succeeded: rc=%lu\n", shell_call, rc); /* quoted */ rc=shell_execute(NULL, "\"%TMPDIR%\\simple.shlexec\"", NULL, NULL); todo_wine ok(rc == SE_ERR_FNF, "%s succeeded: rc=%lu\n", shell_call, rc); /* test SEE_MASK_DOENVSUBST works */ rc=shell_execute_ex(SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI, NULL, "%TMPDIR%\\simple.shlexec", NULL, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc); /* quoted lpFile does not work on real win95 and nt4 */ rc=shell_execute_ex(SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI, NULL, "\"%TMPDIR%\\simple.shlexec\"", NULL, NULL, NULL); ok(rc > 32 || broken(rc == SE_ERR_FNF) /* Win95/NT4 */, "%s failed: rc=%lu\n", shell_call, rc); } typedef struct { const char* cmd; const char* args[11]; int todo; } cmdline_tests_t; static const cmdline_tests_t cmdline_tests[] = { {"exe", {"exe", NULL}, 0}, {"exe arg1 arg2 \"arg three\" 'four five` six\\ $even)", {"exe", "arg1", "arg2", "arg three", "'four", "five`", "six\\", "$even)", NULL}, 0}, {"exe arg=1 arg-2 three\tfour\rfour\nfour ", {"exe", "arg=1", "arg-2", "three", "four\rfour\nfour", NULL}, 0}, {"exe arg\"one\" \"second\"arg thirdarg ", {"exe", "argone", "secondarg", "thirdarg", NULL}, 0}, /* Don't lose unclosed quoted arguments */ {"exe arg1 \"unclosed", {"exe", "arg1", "unclosed", NULL}, 0}, {"exe arg1 \"", {"exe", "arg1", "", NULL}, 0}, /* cmd's metacharacters have no special meaning */ {"exe \"one^\" \"arg\"&two three|four", {"exe", "one^", "arg&two", "three|four", NULL}, 0}, /* Environment variables are not interpreted either */ {"exe %TMPDIR% %2", {"exe", "%TMPDIR%", "%2", NULL}, 0}, /* If not followed by a quote, backslashes go through as is */ {"exe o\\ne t\\\\wo t\\\\\\ree f\\\\\\\\our ", {"exe", "o\\ne", "t\\\\wo", "t\\\\\\ree", "f\\\\\\\\our", NULL}, 0}, {"exe \"o\\ne\" \"t\\\\wo\" \"t\\\\\\ree\" \"f\\\\\\\\our\" ", {"exe", "o\\ne", "t\\\\wo", "t\\\\\\ree", "f\\\\\\\\our", NULL}, 0}, /* When followed by a quote their number is halved and the remainder * escapes the quote */ {"exe \\\"one \\\\\"two\" \\\\\\\"three \\\\\\\\\"four\" end", {"exe", "\"one", "\\two", "\\\"three", "\\\\four", "end", NULL}, 0}, {"exe \"one\\\" still\" \"two\\\\\" \"three\\\\\\\" still\" \"four\\\\\\\\\" end", {"exe", "one\" still", "two\\", "three\\\" still", "four\\\\", "end", NULL}, 0}, /* One can put a quote in an unquoted string by tripling it, that is in * effect quoting it like so """ -> ". The general rule is as follows: * 3n quotes -> n quotes * 3n+1 quotes -> n quotes plus start of a quoted string * 3n+2 quotes -> n quotes (plus an empty string from the remaining pair) * Nicely, when n is 0 we get the standard rules back. */ {"exe two\"\"quotes next", {"exe", "twoquotes", "next", NULL}, 0}, {"exe three\"\"\"quotes next", {"exe", "three\"quotes", "next", NULL}, 0}, {"exe four\"\"\"\" quotes\" next 4%3=1", {"exe", "four\" quotes", "next", "4%3=1", NULL}, 0}, {"exe five\"\"\"\"\"quotes next", {"exe", "five\"quotes", "next", NULL}, 0}, {"exe six\"\"\"\"\"\"quotes next", {"exe", "six\"\"quotes", "next", NULL}, 0}, {"exe seven\"\"\"\"\"\"\" quotes\" next 7%3=1", {"exe", "seven\"\" quotes", "next", "7%3=1", NULL}, 0}, {"exe twelve\"\"\"\"\"\"\"\"\"\"\"\"quotes next", {"exe", "twelve\"\"\"\"quotes", "next", NULL}, 0}, {"exe thirteen\"\"\"\"\"\"\"\"\"\"\"\"\" quotes\" next 13%3=1", {"exe", "thirteen\"\"\"\" quotes", "next", "13%3=1", NULL}, 0}, /* Inside a quoted string the opening quote is added to the set of * consecutive quotes to get the effective quotes count. This gives: * 1+3n quotes -> n quotes * 1+3n+1 quotes -> n quotes plus closes the quoted string * 1+3n+2 quotes -> n+1 quotes plus closes the quoted string */ {"exe \"two\"\"quotes next", {"exe", "two\"quotes", "next", NULL}, 0}, {"exe \"two\"\" next", {"exe", "two\"", "next", NULL}, 0}, {"exe \"three\"\"\" quotes\" next 4%3=1", {"exe", "three\" quotes", "next", "4%3=1", NULL}, 0}, {"exe \"four\"\"\"\"quotes next", {"exe", "four\"quotes", "next", NULL}, 0}, {"exe \"five\"\"\"\"\"quotes next", {"exe", "five\"\"quotes", "next", NULL}, 0}, {"exe \"six\"\"\"\"\"\" quotes\" next 7%3=1", {"exe", "six\"\" quotes", "next", "7%3=1", NULL}, 0}, {"exe \"eleven\"\"\"\"\"\"\"\"\"\"\"quotes next", {"exe", "eleven\"\"\"\"quotes", "next", NULL}, 0}, {"exe \"twelve\"\"\"\"\"\"\"\"\"\"\"\" quotes\" next 13%3=1", {"exe", "twelve\"\"\"\" quotes", "next", "13%3=1", NULL}, 0}, /* Escaped consecutive quotes are fun */ {"exe \"the crazy \\\\\"\"\"\\\\\" quotes", {"exe", "the crazy \\\"\\", "quotes", NULL}, 0}, /* The executable path has its own rules!!! * - Backslashes have no special meaning. * - If the first character is a quote, then the second quote ends the * executable path. * - The previous rule holds even if the next character is not a space! * - If the first character is not a quote, then quotes have no special * meaning either and the executable path stops at the first space. * - The consecutive quotes rules don't apply either. * - Even if there is no space between the executable path and the first * argument, the latter is parsed using the regular rules. */ {"exe\"file\"path arg1", {"exe\"file\"path", "arg1", NULL}, 0}, {"exe\"file\"path\targ1", {"exe\"file\"path", "arg1", NULL}, 0}, {"exe\"path\\ arg1", {"exe\"path\\", "arg1", NULL}, 0}, {"\\\"exe \"arg one\"", {"\\\"exe", "arg one", NULL}, 0}, {"\"spaced exe\" \"next arg\"", {"spaced exe", "next arg", NULL}, 0}, {"\"spaced exe\"\t\"next arg\"", {"spaced exe", "next arg", NULL}, 0}, {"\"exe\"arg\" one\" argtwo", {"exe", "arg one", "argtwo", NULL}, 0}, {"\"spaced exe\\\"arg1 arg2", {"spaced exe\\", "arg1", "arg2", NULL}, 0}, {"\"two\"\" arg1 ", {"two", " arg1 ", NULL}, 0}, {"\"three\"\"\" arg2", {"three", "", "arg2", NULL}, 0}, {"\"four\"\"\"\"arg1", {"four", "\"arg1", NULL}, 0}, /* If the first character is a space then the executable path is empty */ {" \"arg\"one argtwo", {"", "argone", "argtwo", NULL}, 0}, {NULL, {NULL}, 0} }; static BOOL test_one_cmdline(const cmdline_tests_t* test) { WCHAR cmdW[MAX_PATH], argW[MAX_PATH]; LPWSTR *cl2a; int cl2a_count; LPWSTR *argsW; int i, count; /* trace("----- cmd='%s'\n", test->cmd); */ MultiByteToWideChar(CP_ACP, 0, test->cmd, -1, cmdW, sizeof(cmdW)/sizeof(*cmdW)); argsW = cl2a = CommandLineToArgvW(cmdW, &cl2a_count); if (argsW == NULL && cl2a_count == -1) { win_skip("CommandLineToArgvW not implemented, skipping\n"); return FALSE; } count = 0; while (test->args[count]) count++; if ((test->todo & 0x1) == 0) ok(cl2a_count == count, "%s: expected %d arguments, but got %d\n", test->cmd, count, cl2a_count); else todo_wine ok(cl2a_count == count, "%s: expected %d arguments, but got %d\n", test->cmd, count, cl2a_count); for (i = 0; i < cl2a_count; i++) { if (i < count) { MultiByteToWideChar(CP_ACP, 0, test->args[i], -1, argW, sizeof(argW)/sizeof(*argW)); if ((test->todo & (1 << (i+4))) == 0) ok(!lstrcmpW(*argsW, argW), "%s: arg[%d] expected %s but got %s\n", test->cmd, i, wine_dbgstr_w(argW), wine_dbgstr_w(*argsW)); else todo_wine ok(!lstrcmpW(*argsW, argW), "%s: arg[%d] expected %s but got %s\n", test->cmd, i, wine_dbgstr_w(argW), wine_dbgstr_w(*argsW)); } else if ((test->todo & 0x1) == 0) ok(0, "%s: got extra arg[%d]=%s\n", test->cmd, i, wine_dbgstr_w(*argsW)); else todo_wine ok(0, "%s: got extra arg[%d]=%s\n", test->cmd, i, wine_dbgstr_w(*argsW)); argsW++; } LocalFree(cl2a); return TRUE; } static void test_commandline2argv(void) { static const WCHAR exeW[] = {'e','x','e',0}; const cmdline_tests_t* test; WCHAR strW[MAX_PATH]; LPWSTR *args; int numargs; DWORD le; test = cmdline_tests; while (test->cmd) { if (!test_one_cmdline(test)) return; test++; } SetLastError(0xdeadbeef); args = CommandLineToArgvW(exeW, NULL); le = GetLastError(); ok(args == NULL && le == ERROR_INVALID_PARAMETER, "expected NULL with ERROR_INVALID_PARAMETER got %p with %u\n", args, le); SetLastError(0xdeadbeef); args = CommandLineToArgvW(NULL, NULL); le = GetLastError(); ok(args == NULL && le == ERROR_INVALID_PARAMETER, "expected NULL with ERROR_INVALID_PARAMETER got %p with %u\n", args, le); *strW = 0; args = CommandLineToArgvW(strW, &numargs); ok(numargs == 1, "expected 1 args, got %d\n", numargs); if (numargs == 1) { GetModuleFileNameW(NULL, strW, sizeof(strW)/sizeof(*strW)); ok(!lstrcmpW(args[0], strW), "wrong path to the current executable: %s instead of %s\n", wine_dbgstr_w(args[0]), wine_dbgstr_w(strW)); } if (args) LocalFree(args); } /* The goal here is to analyze how ShellExecute() builds the command that * will be run. The tricky part is that there are three transformation * steps between the 'parameters' string we pass to ShellExecute() and the * argument list we observe in the child process: * - The parsing of 'parameters' string into individual arguments. The tests * show this is done differently from both CreateProcess() and * CommandLineToArgv()! * - The way the command 'formatting directives' such as %1, %2, etc are * handled. * - And the way the resulting command line is then parsed to yield the * argument list we check. */ typedef struct { const char* verb; const char* params; int todo; cmdline_tests_t cmd; cmdline_tests_t broken; } argify_tests_t; static const argify_tests_t argify_tests[] = { /* Start with three simple parameters. Notice that one can reorder and * duplicate the parameters. Also notice how %* take the raw input * parameters string, including the trailing spaces, no matter what * arguments have already been used. */ {"Params232S", "p2 p3 p4 ", 0xc2, {" p2 p3 \"p2\" \"p2 p3 p4 \"", {"", "p2", "p3", "p2", "p2 p3 p4 ", NULL}, 0}}, /* Unquoted argument references like %2 don't automatically quote their * argument. Similarly, when they are quoted they don't escape the quotes * that their argument may contain. */ {"Params232S", "\"p two\" p3 p4 ", 0x3f3, {" p two p3 \"p two\" \"\"p two\" p3 p4 \"", {"", "p", "two", "p3", "p two", "p", "two p3 p4 ", NULL}, 0}}, /* Only single digits are supported so only %1 to %9. Shown here with %20 * because %10 is a pain. */ {"Params20", "p", 0, {" \"p0\"", {"", "p0", NULL}, 0}}, /* Only (double-)quotes have a special meaning. */ {"Params23456", "'p2 p3` p4\\ $even", 0x40, {" \"'p2\" \"p3`\" \"p4\\\" \"$even\" \"\"", {"", "'p2", "p3`", "p4\" $even \"", NULL}, 0}}, {"Params23456", "p=2 p-3 p4\tp4\rp4\np4", 0x1c2, {" \"p=2\" \"p-3\" \"p4\tp4\rp4\np4\" \"\" \"\"", {"", "p=2", "p-3", "p4\tp4\rp4\np4", "", "", NULL}, 0}}, /* In unquoted strings, quotes are treated are a parameter separator just * like spaces! However they can be doubled to get a literal quote. * Specifically: * 2n quotes -> n quotes * 2n+1 quotes -> n quotes and a parameter separator */ {"Params23456789", "one\"quote \"p four\" one\"quote p7", 0xff3, {" \"one\" \"quote\" \"p four\" \"one\" \"quote\" \"p7\" \"\" \"\"", {"", "one", "quote", "p four", "one", "quote", "p7", "", "", NULL}, 0}}, {"Params23456789", "two\"\"quotes \"p three\" two\"\"quotes p5", 0xf2, {" \"two\"quotes\" \"p three\" \"two\"quotes\" \"p5\" \"\" \"\" \"\" \"\"", {"", "twoquotes p", "three twoquotes", "p5", "", "", "", "", NULL}, 0}}, {"Params23456789", "three\"\"\"quotes \"p four\" three\"\"\"quotes p6", 0xff3, {" \"three\"\" \"quotes\" \"p four\" \"three\"\" \"quotes\" \"p6\" \"\" \"\"", {"", "three\"", "quotes", "p four", "three\"", "quotes", "p6", "", "", NULL}, 0}}, {"Params23456789", "four\"\"\"\"quotes \"p three\" four\"\"\"\"quotes p5", 0xf3, {" \"four\"\"quotes\" \"p three\" \"four\"\"quotes\" \"p5\" \"\" \"\" \"\" \"\"", {"", "four\"quotes p", "three fourquotes p5 \"", "", "", "", NULL}, 0}}, /* Quoted strings cannot be continued by tacking on a non space character * either. */ {"Params23456", "\"p two\"p3 \"p four\"p5 p6", 0x1f3, {" \"p two\" \"p3\" \"p four\" \"p5\" \"p6\"", {"", "p two", "p3", "p four", "p5", "p6", NULL}, 0}}, /* In quoted strings, the quotes are halved and an odd number closes the * string. Specifically: * 2n quotes -> n quotes * 2n+1 quotes -> n quotes and closes the string and hence the parameter */ {"Params23456789", "\"one q\"uote \"p four\" \"one q\"uote p7", 0xff3, {" \"one q\" \"uote\" \"p four\" \"one q\" \"uote\" \"p7\" \"\" \"\"", {"", "one q", "uote", "p four", "one q", "uote", "p7", "", "", NULL}, 0}}, {"Params23456789", "\"two \"\" quotes\" \"p three\" \"two \"\" quotes\" p5", 0x1ff3, {" \"two \" quotes\" \"p three\" \"two \" quotes\" \"p5\" \"\" \"\" \"\" \"\"", {"", "two ", "quotes p", "three two", " quotes", "p5", "", "", "", "", NULL}, 0}}, {"Params23456789", "\"three q\"\"\"uotes \"p four\" \"three q\"\"\"uotes p7", 0xff3, {" \"three q\"\" \"uotes\" \"p four\" \"three q\"\" \"uotes\" \"p7\" \"\" \"\"", {"", "three q\"", "uotes", "p four", "three q\"", "uotes", "p7", "", "", NULL}, 0}}, {"Params23456789", "\"four \"\"\"\" quotes\" \"p three\" \"four \"\"\"\" quotes\" p5", 0xff3, {" \"four \"\" quotes\" \"p three\" \"four \"\" quotes\" \"p5\" \"\" \"\" \"\" \"\"", {"", "four \"", "quotes p", "three four", "", "quotes p5 \"", "", "", "", NULL}, 0}}, /* The quoted string rules also apply to consecutive quotes at the start * of a parameter but don't count the opening quote! */ {"Params23456789", "\"\"twoquotes \"p four\" \"\"twoquotes p7", 0xbf3, {" \"\" \"twoquotes\" \"p four\" \"\" \"twoquotes\" \"p7\" \"\" \"\"", {"", "", "twoquotes", "p four", "", "twoquotes", "p7", "", "", NULL}, 0}}, {"Params23456789", "\"\"\"three quotes\" \"p three\" \"\"\"three quotes\" p5", 0x6f3, {" \"\"three quotes\" \"p three\" \"\"three quotes\" \"p5\" \"\" \"\" \"\" \"\"", {"", "three", "quotes p", "three \"three", "quotes p5 \"", "", "", "", NULL}, 0}}, {"Params23456789", "\"\"\"\"fourquotes \"p four\" \"\"\"\"fourquotes p7", 0xbf3, {" \"\"\" \"fourquotes\" \"p four\" \"\"\" \"fourquotes\" \"p7\" \"\" \"\"", {"", "\"", "fourquotes", "p four", "\"", "fourquotes", "p7", "", "", NULL}, 0}}, /* An unclosed quoted string gets lost! */ {"Params23456", "p2 \"p3\" \"p4 is lost", 0x1c3, {" \"p2\" \"p3\" \"\" \"\" \"\"", {"", "p2", "p3", "", "", "", NULL}, 0}, {" \"p2\" \"p3\" \"p3\" \"\" \"\"", {"", "p2", "p3", "p3", "", "", NULL}, 0}}, /* Backslashes have no special meaning even when preceding quotes. All * they do is start an unquoted string. */ {"Params23456", "\\\"p\\three \"pfour\\\" pfive", 0x73, {" \"\\\" \"p\\three\" \"pfour\\\" \"pfive\" \"\"", {"", "\" p\\three pfour\"", "pfive", "", NULL}, 0}}, /* Environment variables are left untouched. */ {"Params23456", "%TMPDIR% %t %c", 0, {" \"%TMPDIR%\" \"%t\" \"%c\" \"\" \"\"", {"", "%TMPDIR%", "%t", "%c", "", "", NULL}, 0}}, /* %~2 is equivalent to %*. However %~3 and higher include the spaces * before the parameter! * (but not the previous parameter's closing quote fortunately) */ {"Params2345Etc", "p2 p3 \"p4\" p5 p6 ", 0x3f3, {" ~2=\"p2 p3 \"p4\" p5 p6 \" ~3=\" p3 \"p4\" p5 p6 \" ~4=\" \"p4\" p5 p6 \" ~5= p5 p6 ", {"", "~2=p2 p3 p4 p5 p6 ", "~3= p3 p4 p5 p6 ", "~4= p4 p5 p6 ", "~5=", "p5", "p6", NULL}, 0}}, /* %~n works even if there is no nth parameter. */ {"Params9Etc", "p2 p3 p4 p5 p6 p7 p8 ", 0x12, {" ~9=\" \"", {"", "~9= ", NULL}, 0}}, {"Params9Etc", "p2 p3 p4 p5 p6 p7 ", 0x12, {" ~9=\"\"", {"", "~9=", NULL}, 0}}, /* The %~n directives also transmit the tenth parameter and beyond. */ {"Params9Etc", "p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 and beyond!", 0x12, {" ~9=\" p9 p10 p11 and beyond!\"", {"", "~9= p9 p10 p11 and beyond!", NULL}, 0}}, /* Bad formatting directives lose their % sign, except those followed by * a tilde! Environment variables are not expanded but lose their % sign. */ {"ParamsBad", "p2 p3 p4 p5", 0x12, {" \"% - %~ %~0 %~1 %~a %~* a b c TMPDIR\"", {"", "% - %~ %~0 %~1 %~a %~* a b c TMPDIR", NULL}, 0}}, {NULL, NULL, 0, {NULL, {NULL}, 0}} }; static void test_argify(void) { BOOL has_cl2a = TRUE; char fileA[MAX_PATH], params[2*MAX_PATH+12]; INT_PTR rc; const argify_tests_t* test; const cmdline_tests_t *bad; const char* cmd; unsigned i, count; create_test_verb(".shlexec", "Params232S", 0, "Params232S %2 %3 \"%2\" \"%*\""); create_test_verb(".shlexec", "Params23456", 0, "Params23456 \"%2\" \"%3\" \"%4\" \"%5\" \"%6\""); create_test_verb(".shlexec", "Params23456789", 0, "Params23456789 \"%2\" \"%3\" \"%4\" \"%5\" \"%6\" \"%7\" \"%8\" \"%9\""); create_test_verb(".shlexec", "Params2345Etc", 0, "Params2345Etc ~2=\"%~2\" ~3=\"%~3\" ~4=\"%~4\" ~5=%~5"); create_test_verb(".shlexec", "Params9Etc", 0, "Params9Etc ~9=\"%~9\""); create_test_verb(".shlexec", "Params20", 0, "Params20 \"%20\""); create_test_verb(".shlexec", "ParamsBad", 0, "ParamsBad \"%% %- %~ %~0 %~1 %~a %~* %a %b %c %TMPDIR%\""); sprintf(fileA, "%s\\test file.shlexec", tmpdir); test = argify_tests; while (test->params) { bad = test->broken.cmd ? &test->broken : &test->cmd; /* trace("***** verb='%s' params='%s'\n", test->verb, test->params); */ rc = shell_execute_ex(SEE_MASK_DOENVSUBST, test->verb, fileA, test->params, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc); count = 0; while (test->cmd.args[count]) count++; if ((test->todo & 0x1) == 0) /* +4 for the shlexec arguments, -1 because of the added "" * argument for the CommandLineToArgvW() tests. */ okChildInt("argcA", 4 + count - 1); else todo_wine okChildInt("argcA", 4 + count - 1); cmd = getChildString("Arguments", "cmdlineA"); /* Our commands are such that the verb immediately precedes the * part we are interested in. */ if (cmd) cmd = strstr(cmd, test->verb); if (cmd) cmd += strlen(test->verb); if (!cmd) cmd = "(null)"; if ((test->todo & 0x2) == 0) ok(!strcmp(cmd, test->cmd.cmd) || broken(!strcmp(cmd, bad->cmd)), "%s: the cmdline is '%s' instead of '%s'\n", shell_call, cmd, test->cmd.cmd); else todo_wine ok(!strcmp(cmd, test->cmd.cmd) || broken(!strcmp(cmd, bad->cmd)), "%s: the cmdline is '%s' instead of '%s'\n", shell_call, cmd, test->cmd.cmd); for (i = 0; i < count - 1; i++) { char argname[18]; sprintf(argname, "argvA%d", 4 + i); if ((test->todo & (1 << (i+4))) == 0) okChildStringBroken(argname, test->cmd.args[i+1], bad->args[i+1]); else todo_wine okChildStringBroken(argname, test->cmd.args[i+1], bad->args[i+1]); } if (has_cl2a) has_cl2a = test_one_cmdline(&(test->cmd)); test++; } /* Test with a long parameter */ for (rc = 0; rc < MAX_PATH; rc++) fileA[rc] = 'a' + rc % 26; fileA[MAX_PATH-1] = '\0'; sprintf(params, "shlexec \"%s\" %s", child_file, fileA); /* We need NOZONECHECKS on Win2003 to block a dialog */ rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc); okChildInt("argcA", 4); okChildString("argvA3", fileA); } static void test_filename(void) { char filename[MAX_PATH]; const filename_tests_t* test; char* c; INT_PTR rc; test=filename_tests; while (test->basename) { BOOL quotedfile = FALSE; if (skip_noassoc_tests && test->rc == SE_ERR_NOASSOC) { win_skip("Skipping shellexecute of file with unassociated extension\n"); test++; continue; } sprintf(filename, test->basename, tmpdir); if (strchr(filename, '/')) { c=filename; while (*c) { if (*c=='\\') *c='/'; c++; } } if ((test->todo & 0x40)==0) { rc=shell_execute(test->verb, filename, NULL, NULL); } else { char quoted[MAX_PATH + 2]; quotedfile = TRUE; sprintf(quoted, "\"%s\"", filename); rc=shell_execute(test->verb, quoted, NULL, NULL); } if (rc > 32) rc=33; if ((test->todo & 0x1)==0) { ok(rc==test->rc || broken(quotedfile && rc == SE_ERR_FNF), /* NT4 */ "%s failed: rc=%ld err=%u\n", shell_call, rc, GetLastError()); } else todo_wine { ok(rc==test->rc, "%s failed: rc=%ld err=%u\n", shell_call, rc, GetLastError()); } if (rc == 33) { const char* verb; if ((test->todo & 0x2)==0) { okChildInt("argcA", 5); } else todo_wine { okChildInt("argcA", 5); } verb=(test->verb ? test->verb : "Open"); if ((test->todo & 0x4)==0) { okChildString("argvA3", verb); } else todo_wine { okChildString("argvA3", verb); } if ((test->todo & 0x8)==0) { okChildPath("argvA4", filename); } else todo_wine { okChildPath("argvA4", filename); } } test++; } test=noquotes_tests; while (test->basename) { sprintf(filename, test->basename, tmpdir); rc=shell_execute(test->verb, filename, NULL, NULL); if (rc > 32) rc=33; if ((test->todo & 0x1)==0) { ok(rc==test->rc, "%s failed: rc=%ld err=%u\n", shell_call, rc, GetLastError()); } else todo_wine { ok(rc==test->rc, "%s failed: rc=%ld err=%u\n", shell_call, rc, GetLastError()); } if (rc==0) { int count; const char* verb; char* str; verb=(test->verb ? test->verb : "Open"); if ((test->todo & 0x4)==0) { okChildString("argvA3", verb); } else todo_wine { okChildString("argvA3", verb); } count=4; str=filename; while (1) { char attrib[18]; char* space; space=strchr(str, ' '); if (space) *space='\0'; sprintf(attrib, "argvA%d", count); if ((test->todo & 0x8)==0) { okChildPath(attrib, str); } else todo_wine { okChildPath(attrib, str); } count++; if (!space) break; str=space+1; } if ((test->todo & 0x2)==0) { okChildInt("argcA", count); } else todo_wine { okChildInt("argcA", count); } } test++; } if (dllver.dwMajorVersion != 0) { /* The more recent versions of shell32.dll accept quoted filenames * while older ones (e.g. 4.00) don't. Still we want to test this * because IE 6 depends on the new behavior. * One day we may need to check the exact version of the dll but for * now making sure DllGetVersion() is present is sufficient. */ sprintf(filename, "\"%s\\test file.shlexec\"", tmpdir); rc=shell_execute(NULL, filename, NULL, NULL); ok(rc > 32, "%s failed: rc=%ld err=%u\n", shell_call, rc, GetLastError()); okChildInt("argcA", 5); okChildString("argvA3", "Open"); sprintf(filename, "%s\\test file.shlexec", tmpdir); okChildPath("argvA4", filename); } } typedef struct { const char* urlprefix; const char* basename; int flags; int todo; } fileurl_tests_t; #define URL_SUCCESS 0x1 #define USE_COLON 0x2 #define USE_BSLASH 0x4 static fileurl_tests_t fileurl_tests[]= { /* How many slashes does it take... */ {"file:", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"file:/", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"file://", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"file:///", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"File:///", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"file:////", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"file://///", "%s\\test file.shlexec", 0, 0}, /* Test with Windows-style paths */ {"file:///", "%s\\test file.shlexec", URL_SUCCESS | USE_COLON, 0}, {"file:///", "%s\\test file.shlexec", URL_SUCCESS | USE_BSLASH, 0}, /* Check handling of hostnames */ {"file://localhost/", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"file://localhost:80/", "%s\\test file.shlexec", 0, 0}, {"file://LocalHost/", "%s\\test file.shlexec", URL_SUCCESS, 0}, {"file://127.0.0.1/", "%s\\test file.shlexec", 0, 0}, {"file://::1/", "%s\\test file.shlexec", 0, 0}, {"file://notahost/", "%s\\test file.shlexec", 0, 0}, /* Environment variables are not expanded in URLs */ {"%urlprefix%", "%s\\test file.shlexec", 0, 0x1}, {"file:///", "%%TMPDIR%%\\test file.shlexec", 0, 0}, /* Test shortcuts vs. URLs */ {"file://///", "%s\\test_shortcut_shlexec.lnk", 0, 0x1d}, {NULL, NULL, 0, 0} }; static void test_fileurls(void) { char filename[MAX_PATH], fileurl[MAX_PATH], longtmpdir[MAX_PATH]; char command[MAX_PATH]; const fileurl_tests_t* test; char *s; INT_PTR rc; rc = (INT_PTR)ShellExecute(NULL, NULL, "file:///nosuchfile.shlexec", NULL, NULL, SW_SHOWNORMAL); if (rc > 32) { win_skip("shell32 is too old (likely < 4.72). Skipping the file URL tests\n"); return; } get_long_path_name(tmpdir, longtmpdir, sizeof(longtmpdir)/sizeof(*longtmpdir)); SetEnvironmentVariable("urlprefix", "file:///"); test=fileurl_tests; while (test->basename) { /* Build the file URL */ sprintf(filename, test->basename, longtmpdir); strcpy(fileurl, test->urlprefix); strcat(fileurl, filename); s = fileurl + strlen(test->urlprefix); while (*s) { if (!(test->flags & USE_COLON) && *s == ':') *s = '|'; else if (!(test->flags & USE_BSLASH) && *s == '\\') *s = '/'; s++; } /* Test it first with FindExecutable() */ rc = (INT_PTR)FindExecutableA(fileurl, NULL, command); ok(rc == SE_ERR_FNF, "FindExecutable(%s) failed: bad rc=%lu\n", fileurl, rc); /* Then ShellExecute() */ if ((test->todo & 0x10) == 0) rc = shell_execute(NULL, fileurl, NULL, NULL); else todo_wait rc = shell_execute(NULL, fileurl, NULL, NULL); if (bad_shellexecute) { win_skip("shell32 is too old (likely 4.72). Skipping the file URL tests\n"); break; } if (test->flags & URL_SUCCESS) { if ((test->todo & 0x1) == 0) ok(rc > 32, "%s failed: bad rc=%lu\n", shell_call, rc); else todo_wine ok(rc > 32, "%s failed: bad rc=%lu\n", shell_call, rc); } else { if ((test->todo & 0x1) == 0) ok(rc == SE_ERR_FNF || rc == SE_ERR_PNF || broken(rc == SE_ERR_ACCESSDENIED) /* win2000 */, "%s failed: bad rc=%lu\n", shell_call, rc); else todo_wine ok(rc == SE_ERR_FNF || rc == SE_ERR_PNF || broken(rc == SE_ERR_ACCESSDENIED) /* win2000 */, "%s failed: bad rc=%lu\n", shell_call, rc); } if (rc == 33) { if ((test->todo & 0x2) == 0) okChildInt("argcA", 5); else todo_wine okChildInt("argcA", 5); if ((test->todo & 0x4) == 0) okChildString("argvA3", "Open"); else todo_wine okChildString("argvA3", "Open"); if ((test->todo & 0x8) == 0) okChildPath("argvA4", filename); else todo_wine okChildPath("argvA4", filename); } test++; } SetEnvironmentVariable("urlprefix", NULL); } static void test_find_executable(void) { char notepad_path[MAX_PATH]; char filename[MAX_PATH]; char command[MAX_PATH]; const filename_tests_t* test; INT_PTR rc; if (!create_test_association(".sfe")) { skip("Unable to create association for '.sfe'\n"); return; } create_test_verb(".sfe", "Open", 1, "%1"); /* Don't test FindExecutable(..., NULL), it always crashes */ strcpy(command, "your word"); if (0) /* Can crash on Vista! */ { rc=(INT_PTR)FindExecutableA(NULL, NULL, command); ok(rc == SE_ERR_FNF || rc > 32 /* nt4 */, "FindExecutable(NULL) returned %ld\n", rc); ok(strcmp(command, "your word") != 0, "FindExecutable(NULL) returned command=[%s]\n", command); } GetSystemDirectoryA( notepad_path, MAX_PATH ); strcat( notepad_path, "\\notepad.exe" ); /* Search for something that should be in the system-wide search path (no default directory) */ strcpy(command, "your word"); rc=(INT_PTR)FindExecutableA("notepad.exe", NULL, command); ok(rc > 32, "FindExecutable(%s) returned %ld\n", "notepad.exe", rc); ok(strcasecmp(command, notepad_path) == 0, "FindExecutable(%s) returned command=[%s]\n", "notepad.exe", command); /* Search for something that should be in the system-wide search path (with default directory) */ strcpy(command, "your word"); rc=(INT_PTR)FindExecutableA("notepad.exe", tmpdir, command); ok(rc > 32, "FindExecutable(%s) returned %ld\n", "notepad.exe", rc); ok(strcasecmp(command, notepad_path) == 0, "FindExecutable(%s) returned command=[%s]\n", "notepad.exe", command); strcpy(command, "your word"); rc=(INT_PTR)FindExecutableA(tmpdir, NULL, command); ok(rc == SE_ERR_NOASSOC /* >= win2000 */ || rc > 32 /* win98, nt4 */, "FindExecutable(NULL) returned %ld\n", rc); ok(strcmp(command, "your word") != 0, "FindExecutable(NULL) returned command=[%s]\n", command); sprintf(filename, "%s\\test file.sfe", tmpdir); rc=(INT_PTR)FindExecutableA(filename, NULL, command); ok(rc > 32, "FindExecutable(%s) returned %ld\n", filename, rc); /* Depending on the platform, command could be '%1' or 'test file.sfe' */ rc=(INT_PTR)FindExecutableA("test file.sfe", tmpdir, command); ok(rc > 32, "FindExecutable(%s) returned %ld\n", filename, rc); rc=(INT_PTR)FindExecutableA("test file.sfe", NULL, command); ok(rc == SE_ERR_FNF, "FindExecutable(%s) returned %ld\n", filename, rc); delete_test_association(".sfe"); if (!create_test_association(".shl")) { skip("Unable to create association for '.shl'\n"); return; } create_test_verb(".shl", "Open", 0, "Open"); sprintf(filename, "%s\\test file.shl", tmpdir); rc=(INT_PTR)FindExecutableA(filename, NULL, command); ok(rc == SE_ERR_FNF /* NT4 */ || rc > 32, "FindExecutable(%s) returned %ld\n", filename, rc); sprintf(filename, "%s\\test file.shlfoo", tmpdir); rc=(INT_PTR)FindExecutableA(filename, NULL, command); delete_test_association(".shl"); if (rc > 32) { /* On Windows XP and 2003 FindExecutable() is completely broken. * Probably what it does is convert the filename to 8.3 format, * which as a side effect converts the '.shlfoo' extension to '.shl', * and then tries to find an association for '.shl'. This means it * will normally fail on most extensions with more than 3 characters, * like '.mpeg', etc. * Also it means we cannot do any other test. */ win_skip("FindExecutable() is broken -> not running 4+ character extension tests\n"); return; } test=filename_tests; while (test->basename) { sprintf(filename, test->basename, tmpdir); if (strchr(filename, '/')) { char* c; c=filename; while (*c) { if (*c=='\\') *c='/'; c++; } } /* Win98 does not '\0'-terminate command! */ memset(command, '\0', sizeof(command)); rc=(INT_PTR)FindExecutableA(filename, NULL, command); if (rc > 32) rc=33; if ((test->todo & 0x10)==0) { ok(rc==test->rc, "FindExecutable(%s) failed: rc=%ld\n", filename, rc); } else todo_wine { ok(rc==test->rc, "FindExecutable(%s) failed: rc=%ld\n", filename, rc); } if (rc > 32) { int equal; equal=strcmp(command, argv0) == 0 || /* NT4 returns an extra 0x8 character! */ (strlen(command) == strlen(argv0)+1 && strncmp(command, argv0, strlen(argv0)) == 0); if ((test->todo & 0x20)==0) { ok(equal, "FindExecutable(%s) returned command='%s' instead of '%s'\n", filename, command, argv0); } else todo_wine { ok(equal, "FindExecutable(%s) returned command='%s' instead of '%s'\n", filename, command, argv0); } } test++; } } static filename_tests_t lnk_tests[]= { /* Pass bad / nonexistent filenames as a parameter */ {NULL, "%s\\nonexistent.shlexec", 0xa, 33}, {NULL, "%s\\nonexistent.noassoc", 0xa, 33}, /* Pass regular paths as a parameter */ {NULL, "%s\\test file.shlexec", 0xa, 33}, {NULL, "%s/%%nasty%% $file.shlexec", 0xa, 33}, /* Pass filenames with no association as a parameter */ {NULL, "%s\\test file.noassoc", 0xa, 33}, {NULL, NULL, 0} }; static void test_lnks(void) { char filename[MAX_PATH]; char params[MAX_PATH]; const filename_tests_t* test; INT_PTR rc; /* Should open through our association */ sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir); rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); okChildInt("argcA", 5); okChildString("argvA3", "Open"); sprintf(params, "%s\\test file.shlexec", tmpdir); get_long_path_name(params, filename, sizeof(filename)); okChildPath("argvA4", filename); todo_wait rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_DOENVSUBST, NULL, "%TMPDIR%\\test_shortcut_shlexec.lnk", NULL, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); okChildInt("argcA", 5); todo_wine okChildString("argvA3", "Open"); sprintf(params, "%s\\test file.shlexec", tmpdir); get_long_path_name(params, filename, sizeof(filename)); todo_wine okChildPath("argvA4", filename); /* Should just run our executable */ sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir); rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); okChildInt("argcA", 4); okChildString("argvA3", "Lnk"); /* Lnk's ContextMenuHandler has priority over an explicit class */ rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, "shlexec.shlexec"); ok(rc > 32, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); okChildInt("argcA", 4); okChildString("argvA3", "Lnk"); if (dllver.dwMajorVersion>=6) { char* c; /* Recent versions of shell32.dll accept '/'s in shortcut paths. * Older versions don't or are quite buggy in this regard. */ sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir); c=filename; while (*c) { if (*c=='\\') *c='/'; c++; } rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, NULL); ok(rc > 32, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); okChildInt("argcA", 4); okChildString("argvA3", "Lnk"); } sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir); test=lnk_tests; while (test->basename) { params[0]='\"'; sprintf(params+1, test->basename, tmpdir); strcat(params,"\""); rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, params, NULL, NULL); if (rc > 32) rc=33; if ((test->todo & 0x1)==0) { ok(rc==test->rc, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); } else todo_wine { ok(rc==test->rc, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); } if (rc==0) { if ((test->todo & 0x2)==0) { okChildInt("argcA", 5); } else { okChildInt("argcA", 5); } if ((test->todo & 0x4)==0) { okChildString("argvA3", "Lnk"); } else todo_wine { okChildString("argvA3", "Lnk"); } sprintf(params, test->basename, tmpdir); if ((test->todo & 0x8)==0) { okChildPath("argvA4", params); } else { okChildPath("argvA4", params); } } test++; } } static void test_exes(void) { char filename[MAX_PATH]; char params[1024]; INT_PTR rc; sprintf(params, "shlexec \"%s\" Exec", child_file); /* We need NOZONECHECKS on Win2003 to block a dialog */ rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params, NULL, NULL); ok(rc > 32, "%s returned %lu\n", shell_call, rc); okChildInt("argcA", 4); okChildString("argvA3", "Exec"); if (! skip_noassoc_tests) { sprintf(filename, "%s\\test file.noassoc", tmpdir); if (CopyFile(argv0, filename, FALSE)) { rc=shell_execute(NULL, filename, params, NULL); todo_wine { ok(rc==SE_ERR_NOASSOC, "%s succeeded: rc=%lu\n", shell_call, rc); } } } else { win_skip("Skipping shellexecute of file with unassociated extension\n"); } } typedef struct { const char* command; const char* ddeexec; const char* application; const char* topic; const char* ifexec; int expectedArgs; const char* expectedDdeExec; int todo; } dde_tests_t; static dde_tests_t dde_tests[] = { /* Test passing and not passing command-line * argument, no DDE */ {"", NULL, NULL, NULL, NULL, FALSE, "", 0x0}, {"\"%1\"", NULL, NULL, NULL, NULL, TRUE, "", 0x0}, /* Test passing and not passing command-line * argument, with DDE */ {"", "[open(\"%1\")]", "shlexec", "dde", NULL, FALSE, "[open(\"%s\")]", 0x0}, {"\"%1\"", "[open(\"%1\")]", "shlexec", "dde", NULL, TRUE, "[open(\"%s\")]", 0x0}, /* Test unquoted %1 in command and ddeexec * (test filename has space) */ {"%1", "[open(%1)]", "shlexec", "dde", NULL, 2, "[open(%s)]", 0x0}, /* Test ifexec precedence over ddeexec */ {"", "[open(\"%1\")]", "shlexec", "dde", "[ifexec(\"%1\")]", FALSE, "[ifexec(\"%s\")]", 0x0}, /* Test default DDE topic */ {"", "[open(\"%1\")]", "shlexec", NULL, NULL, FALSE, "[open(\"%s\")]", 0x0}, /* Test default DDE application */ {"", "[open(\"%1\")]", NULL, "dde", NULL, FALSE, "[open(\"%s\")]", 0x0}, {NULL, NULL, NULL, NULL, NULL, 0, 0x0} }; static DWORD WINAPI hooked_WaitForInputIdle(HANDLE process, DWORD timeout) { return WaitForSingleObject(dde_ready_event, timeout); } /* * WaitForInputIdle() will normally return immediately for console apps. That's * a problem for us because ShellExecute will assume that an app is ready to * receive DDE messages after it has called WaitForInputIdle() on that app. * To work around that we install our own version of WaitForInputIdle() that * will wait for the child to explicitly tell us that it is ready. We do that * by changing the entry for WaitForInputIdle() in the shell32 import address * table. */ static void hook_WaitForInputIdle(DWORD (WINAPI *new_func)(HANDLE, DWORD)) { char *base; PIMAGE_NT_HEADERS nt_headers; DWORD import_directory_rva; PIMAGE_IMPORT_DESCRIPTOR import_descriptor; base = (char *) GetModuleHandleA("shell32.dll"); nt_headers = (PIMAGE_NT_HEADERS)(base + ((PIMAGE_DOS_HEADER) base)->e_lfanew); import_directory_rva = nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress; /* Search for the correct imported module by walking the import descriptors */ import_descriptor = (PIMAGE_IMPORT_DESCRIPTOR)(base + import_directory_rva); while (U(*import_descriptor).OriginalFirstThunk != 0) { char *import_module_name; import_module_name = base + import_descriptor->Name; if (lstrcmpiA(import_module_name, "user32.dll") == 0 || lstrcmpiA(import_module_name, "user32") == 0) { PIMAGE_THUNK_DATA int_entry; PIMAGE_THUNK_DATA iat_entry; /* The import name table and import address table are two parallel * arrays. We need the import name table to find the imported * routine and the import address table to patch the address, so * walk them side by side */ int_entry = (PIMAGE_THUNK_DATA)(base + U(*import_descriptor).OriginalFirstThunk); iat_entry = (PIMAGE_THUNK_DATA)(base + import_descriptor->FirstThunk); while (int_entry->u1.Ordinal != 0) { if (! IMAGE_SNAP_BY_ORDINAL(int_entry->u1.Ordinal)) { PIMAGE_IMPORT_BY_NAME import_by_name; import_by_name = (PIMAGE_IMPORT_BY_NAME)(base + int_entry->u1.AddressOfData); if (lstrcmpA((char *) import_by_name->Name, "WaitForInputIdle") == 0) { /* Found the correct routine in the correct imported module. Patch it. */ DWORD old_prot; VirtualProtect(&iat_entry->u1.Function, sizeof(ULONG_PTR), PAGE_READWRITE, &old_prot); iat_entry->u1.Function = (ULONG_PTR) new_func; VirtualProtect(&iat_entry->u1.Function, sizeof(ULONG_PTR), old_prot, &old_prot); break; } } int_entry++; iat_entry++; } break; } import_descriptor++; } } static void test_dde(void) { char filename[MAX_PATH], defApplication[MAX_PATH]; const dde_tests_t* test; char params[1024]; INT_PTR rc; HANDLE map; char *shared_block; hook_WaitForInputIdle(hooked_WaitForInputIdle); sprintf(filename, "%s\\test file.sde", tmpdir); /* Default service is application name minus path and extension */ strcpy(defApplication, strrchr(argv0, '\\')+1); *strchr(defApplication, '.') = 0; map = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_shlexec_dde_map"); shared_block = MapViewOfFile(map, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 4096); test = dde_tests; while (test->command) { if (!create_test_association(".sde")) { skip("Unable to create association for '.sde'\n"); return; } create_test_verb_dde(".sde", "Open", 0, test->command, test->ddeexec, test->application, test->topic, test->ifexec); if (test->application != NULL || test->topic != NULL) { strcpy(shared_block, test->application ? test->application : defApplication); strcpy(shared_block + strlen(shared_block) + 1, test->topic ? test->topic : SZDDESYS_TOPIC); } else { shared_block[0] = '\0'; shared_block[1] = '\0'; } ddeExec[0] = 0; dde_ready_event = CreateEventA(NULL, FALSE, FALSE, "winetest_shlexec_dde_ready"); rc = shell_execute_ex(SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI, NULL, filename, NULL, NULL, NULL); CloseHandle(dde_ready_event); if ((test->todo & 0x1)==0) { ok(32 < rc, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); } else todo_wine { ok(32 < rc, "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); } if (32 < rc) { if ((test->todo & 0x2)==0) { okChildInt("argcA", test->expectedArgs + 3); } else todo_wine { okChildInt("argcA", test->expectedArgs + 3); } if (test->expectedArgs == 1) { if ((test->todo & 0x4) == 0) { okChildPath("argvA3", filename); } else todo_wine { okChildPath("argvA3", filename); } } if ((test->todo & 0x8) == 0) { sprintf(params, test->expectedDdeExec, filename); okChildPath("ddeExec", params); } else todo_wine { sprintf(params, test->expectedDdeExec, filename); okChildPath("ddeExec", params); } } delete_test_association(".sde"); test++; } UnmapViewOfFile(shared_block); CloseHandle(map); hook_WaitForInputIdle((void *) WaitForInputIdle); } #define DDE_DEFAULT_APP_VARIANTS 2 typedef struct { const char* command; const char* expectedDdeApplication[DDE_DEFAULT_APP_VARIANTS]; int todo; int rc[DDE_DEFAULT_APP_VARIANTS]; } dde_default_app_tests_t; static dde_default_app_tests_t dde_default_app_tests[] = { /* Windows XP and 98 handle default DDE app names in different ways. * The application name we see in the first test determines the pattern * of application names and return codes we will look for. */ /* Test unquoted existing filename with a space */ {"%s\\test file.exe", {"test file", "test"}, 0x0, {33, 33}}, {"%s\\test file.exe param", {"test file", "test"}, 0x0, {33, 33}}, /* Test quoted existing filename with a space */ {"\"%s\\test file.exe\"", {"test file", "test file"}, 0x0, {33, 33}}, {"\"%s\\test file.exe\" param", {"test file", "test file"}, 0x0, {33, 33}}, /* Test unquoted filename with a space that doesn't exist, but * test2.exe does */ {"%s\\test2 file.exe", {"test2", "test2"}, 0x0, {33, 33}}, {"%s\\test2 file.exe param", {"test2", "test2"}, 0x0, {33, 33}}, /* Test quoted filename with a space that does not exist */ {"\"%s\\test2 file.exe\"", {"", "test2 file"}, 0x0, {5, 33}}, {"\"%s\\test2 file.exe\" param", {"", "test2 file"}, 0x0, {5, 33}}, /* Test filename supplied without the extension */ {"%s\\test2", {"test2", "test2"}, 0x0, {33, 33}}, {"%s\\test2 param", {"test2", "test2"}, 0x0, {33, 33}}, /* Test an unquoted nonexistent filename */ {"%s\\notexist.exe", {"", "notexist"}, 0x0, {5, 33}}, {"%s\\notexist.exe param", {"", "notexist"}, 0x0, {5, 33}}, /* Test an application that will be found on the path */ {"cmd", {"cmd", "cmd"}, 0x0, {33, 33}}, {"cmd param", {"cmd", "cmd"}, 0x0, {33, 33}}, /* Test an application that will not be found on the path */ {"xyzwxyzwxyz", {"", "xyzwxyzwxyz"}, 0x0, {5, 33}}, {"xyzwxyzwxyz param", {"", "xyzwxyzwxyz"}, 0x0, {5, 33}}, {NULL, {NULL}, 0, {0}} }; typedef struct { char *filename; DWORD threadIdParent; } dde_thread_info_t; static DWORD CALLBACK ddeThread(LPVOID arg) { dde_thread_info_t *info = arg; assert(info && info->filename); PostThreadMessage(info->threadIdParent, WM_QUIT, shell_execute_ex(SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI, NULL, info->filename, NULL, NULL, NULL), 0L); ExitThread(0); } static void test_dde_default_app(void) { char filename[MAX_PATH]; HSZ hszApplication; dde_thread_info_t info = { filename, GetCurrentThreadId() }; const dde_default_app_tests_t* test; char params[1024]; DWORD threadId; MSG msg; INT_PTR rc; int which = 0; post_quit_on_execute = FALSE; ddeInst = 0; rc = DdeInitializeA(&ddeInst, ddeCb, CBF_SKIP_ALLNOTIFICATIONS | CBF_FAIL_ADVISES | CBF_FAIL_POKES | CBF_FAIL_REQUESTS, 0L); assert(rc == DMLERR_NO_ERROR); sprintf(filename, "%s\\test file.sde", tmpdir); /* It is strictly not necessary to register an application name here, but wine's * DdeNameService implementation complains if 0L is passed instead of * hszApplication with DNS_FILTEROFF */ hszApplication = DdeCreateStringHandleA(ddeInst, "shlexec", CP_WINANSI); hszTopic = DdeCreateStringHandleA(ddeInst, "shlexec", CP_WINANSI); assert(hszApplication && hszTopic); assert(DdeNameService(ddeInst, hszApplication, 0L, DNS_REGISTER | DNS_FILTEROFF)); test = dde_default_app_tests; while (test->command) { if (!create_test_association(".sde")) { skip("Unable to create association for '.sde'\n"); return; } sprintf(params, test->command, tmpdir); create_test_verb_dde(".sde", "Open", 1, params, "[test]", NULL, "shlexec", NULL); ddeApplication[0] = 0; /* No application will be run as we will respond to the first DDE event, * so don't wait for it */ SetEvent(hEvent); assert(CreateThread(NULL, 0, ddeThread, &info, 0, &threadId)); while (GetMessage(&msg, NULL, 0, 0)) DispatchMessage(&msg); rc = msg.wParam > 32 ? 33 : msg.wParam; /* First test, find which set of test data we expect to see */ if (test == dde_default_app_tests) { int i; for (i=0; iexpectedDdeApplication[i])) { which = i; break; } } if (i == DDE_DEFAULT_APP_VARIANTS) skip("Default DDE application test does not match any available results, using first expected data set.\n"); } if ((test->todo & 0x1)==0) { ok(rc==test->rc[which], "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); } else todo_wine { ok(rc==test->rc[which], "%s failed: rc=%lu err=%u\n", shell_call, rc, GetLastError()); } if (rc == 33) { if ((test->todo & 0x2)==0) { ok(!strcmp(ddeApplication, test->expectedDdeApplication[which]), "Expected application '%s', got '%s'\n", test->expectedDdeApplication[which], ddeApplication); } else todo_wine { ok(!strcmp(ddeApplication, test->expectedDdeApplication[which]), "Expected application '%s', got '%s'\n", test->expectedDdeApplication[which], ddeApplication); } } delete_test_association(".sde"); test++; } assert(DdeNameService(ddeInst, hszApplication, 0L, DNS_UNREGISTER)); assert(DdeFreeStringHandle(ddeInst, hszTopic)); assert(DdeFreeStringHandle(ddeInst, hszApplication)); assert(DdeUninitialize(ddeInst)); } static void init_test(void) { HMODULE hdll; HRESULT (WINAPI *pDllGetVersion)(DLLVERSIONINFO*); char filename[MAX_PATH]; WCHAR lnkfile[MAX_PATH]; char params[1024]; const char* const * testfile; lnk_desc_t desc; DWORD rc; HRESULT r; hdll=GetModuleHandleA("shell32.dll"); pDllGetVersion=(void*)GetProcAddress(hdll, "DllGetVersion"); if (pDllGetVersion) { dllver.cbSize=sizeof(dllver); pDllGetVersion(&dllver); trace("major=%d minor=%d build=%d platform=%d\n", dllver.dwMajorVersion, dllver.dwMinorVersion, dllver.dwBuildNumber, dllver.dwPlatformID); } else { memset(&dllver, 0, sizeof(dllver)); } r = CoInitialize(NULL); ok(r == S_OK, "CoInitialize failed (0x%08x)\n", r); if (FAILED(r)) exit(1); rc=GetModuleFileName(NULL, argv0, sizeof(argv0)); assert(rc!=0 && rc 32, "%s returned %lu\n", shell_call, rc); okChildInt("argcA", 4); okChildString("argvA3", "Exec"); todo_wine okChildPath("longPath", path); SetCurrentDirectoryA(curdir); rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI, NULL, "test2.exe", params, NULL, NULL); ok(rc == SE_ERR_FNF, "%s returned %lu\n", shell_call, rc); /* Explicitly specify the directory to use */ rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI, NULL, "test2.exe", params, tmpdir, NULL); ok(rc > 32, "%s returned %lu\n", shell_call, rc); okChildInt("argcA", 4); okChildString("argvA3", "Exec"); todo_wine okChildPath("longPath", path); /* Specify it through an environment variable */ rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI, NULL, "test2.exe", params, "%TMPDIR%", NULL); todo_wine ok(rc == SE_ERR_FNF, "%s returned %lu\n", shell_call, rc); rc=shell_execute_ex(SEE_MASK_DOENVSUBST|SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI, NULL, "test2.exe", params, "%TMPDIR%", NULL); ok(rc > 32, "%s returned %lu\n", shell_call, rc); okChildInt("argcA", 4); okChildString("argvA3", "Exec"); todo_wine okChildPath("longPath", path); /* Not a colon-separated directory list */ sprintf(dirpath, "%s:%s", curdir, tmpdir); rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI, NULL, "test2.exe", params, dirpath, NULL); ok(rc == SE_ERR_FNF, "%s returned %lu\n", shell_call, rc); } START_TEST(shlexec) { myARGC = winetest_get_mainargs(&myARGV); if (myARGC >= 3) { doChild(myARGC, myARGV); exit(0); } init_test(); test_commandline2argv(); test_argify(); test_lpFile_parsed(); test_filename(); test_fileurls(); test_find_executable(); test_lnks(); test_exes(); test_dde(); test_dde_default_app(); test_directory(); cleanup_test(); }