projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[SHELL32_WINETEST] Add a PCH.
[reactos.git] / modules / rostests / winetests / shell32 / shlexec.c
1 /*
2 * Unit test of the ShellExecute function.
3 *
4 * Copyright 2005, 2016 Francois Gouget for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 /* TODO:
22 * - test the default verb selection
23 * - test selection of an alternate class
24 * - try running executables in more ways
25 * - try passing arguments to executables
26 * - ShellExecute("foo.shlexec") with no path should work if foo.shlexec is
27 * in the PATH
28 * - test associations that use %l, %L or "%1" instead of %1
29 * - ShellExecuteEx() also calls SetLastError() with meaningful values which
30 * we could check
31 */
32
33 #include "precomp.h"
34
35 static char argv0[MAX_PATH];
36 static int myARGC;
37 static char** myARGV;
38 static char tmpdir[MAX_PATH];
39 static char child_file[MAX_PATH];
40 static DLLVERSIONINFO dllver;
41 static BOOL skip_shlexec_tests = FALSE;
42 static BOOL skip_noassoc_tests = FALSE;
43 static HANDLE dde_ready_event;
44
45
46 /***
47 *
48 * Helpers to read from / write to the child process results file.
49 * (borrowed from dlls/kernel32/tests/process.c)
50 *
51 ***/
52
53 static const char* encodeA(const char* str)
54 {
55 static char encoded[2*1024+1];
56 char* ptr;
57 size_t len,i;
58
59 if (!str) return "";
60 len = strlen(str) + 1;
61 if (len >= sizeof(encoded)/2)
62 {
63 fprintf(stderr, "string is too long!\n");
64 assert(0);
65 }
66 ptr = encoded;
67 for (i = 0; i < len; i++)
68 sprintf(&ptr[i * 2], "%02x", (unsigned char)str[i]);
69 ptr[2 * len] = '\0';
70 return ptr;
71 }
72
73 static unsigned decode_char(char c)
74 {
75 if (c >= '0' && c <= '9') return c - '0';
76 if (c >= 'a' && c <= 'f') return c - 'a' + 10;
77 assert(c >= 'A' && c <= 'F');
78 return c - 'A' + 10;
79 }
80
81 static char* decodeA(const char* str)
82 {
83 static char decoded[1024];
84 char* ptr;
85 size_t len,i;
86
87 len = strlen(str) / 2;
88 if (!len--) return NULL;
89 if (len >= sizeof(decoded))
90 {
91 fprintf(stderr, "string is too long!\n");
92 assert(0);
93 }
94 ptr = decoded;
95 for (i = 0; i < len; i++)
96 ptr[i] = (decode_char(str[2 * i]) << 4) | decode_char(str[2 * i + 1]);
97 ptr[len] = '\0';
98 return ptr;
99 }
100
101 static void WINETEST_PRINTF_ATTR(2,3) childPrintf(HANDLE h, const char* fmt, ...)
102 {
103 va_list valist;
104 char buffer[1024];
105 DWORD w;
106
107 va_start(valist, fmt);
108 vsprintf(buffer, fmt, valist);
109 va_end(valist);
110 WriteFile(h, buffer, strlen(buffer), &w, NULL);
111 }
112
113 static char* getChildString(const char* sect, const char* key)
114 {
115 char buf[1024];
116 char* ret;
117
118 GetPrivateProfileStringA(sect, key, "-", buf, sizeof(buf), child_file);
119 if (buf[0] == '\0' || (buf[0] == '-' && buf[1] == '\0')) return NULL;
120 assert(!(strlen(buf) & 1));
121 ret = decodeA(buf);
122 return ret;
123 }
124
125
126 /***
127 *
128 * Child code
129 *
130 ***/
131
132 #define CHILD_DDE_TIMEOUT 2500
133 static DWORD ddeInst;
134 static HSZ hszTopic;
135 static char ddeExec[MAX_PATH], ddeApplication[MAX_PATH];
136 static BOOL post_quit_on_execute;
137
138 /* Handle DDE for doChild() and test_dde_default_app() */
139 static HDDEDATA CALLBACK ddeCb(UINT uType, UINT uFmt, HCONV hConv,
140 HSZ hsz1, HSZ hsz2, HDDEDATA hData,
141 ULONG_PTR dwData1, ULONG_PTR dwData2)
142 {
143 DWORD size = 0;
144
145 if (winetest_debug > 2)
146 trace("dde_cb: %04x, %04x, %p, %p, %p, %p, %08lx, %08lx\n",
147 uType, uFmt, hConv, hsz1, hsz2, hData, dwData1, dwData2);
148
149 switch (uType)
150 {
151 case XTYP_CONNECT:
152 if (!DdeCmpStringHandles(hsz1, hszTopic))
153 {
154 size = DdeQueryStringA(ddeInst, hsz2, ddeApplication, MAX_PATH, CP_WINANSI);
155 ok(size < MAX_PATH, "got size %d\n", size);
156 assert(size < MAX_PATH);
157 return (HDDEDATA)TRUE;
158 }
159 return (HDDEDATA)FALSE;
160
161 case XTYP_EXECUTE:
162 size = DdeGetData(hData, (LPBYTE)ddeExec, MAX_PATH, 0);
163 ok(size < MAX_PATH, "got size %d\n", size);
164 assert(size < MAX_PATH);
165 DdeFreeDataHandle(hData);
166 if (post_quit_on_execute)
167 PostQuitMessage(0);
168 return (HDDEDATA)DDE_FACK;
169
170 default:
171 return NULL;
172 }
173 }
174
175 static HANDLE hEvent;
176 static void init_event(const char* child_file)
177 {
178 char* event_name;
179 event_name=strrchr(child_file, '\\')+1;
180 hEvent=CreateEventA(NULL, FALSE, FALSE, event_name);
181 }
182
183 /*
184 * This is just to make sure the child won't run forever stuck in a
185 * GetMessage() loop when DDE fails for some reason.
186 */
187 static void CALLBACK childTimeout(HWND wnd, UINT msg, UINT_PTR timer, DWORD time)
188 {
189 trace("childTimeout called\n");
190
191 PostQuitMessage(0);
192 }
193
194 static void doChild(int argc, char** argv)
195 {
196 char *filename, buffer[MAX_PATH];
197 HANDLE hFile, map;
198 int i;
199 UINT_PTR timer;
200
201 filename=argv[2];
202 hFile=CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
203 if (hFile == INVALID_HANDLE_VALUE)
204 return;
205
206 /* Arguments */
207 childPrintf(hFile, "[Child]\r\n");
208 if (winetest_debug > 2)
209 {
210 trace("cmdlineA='%s'\n", GetCommandLineA());
211 trace("argcA=%d\n", argc);
212 }
213 childPrintf(hFile, "cmdlineA=%s\r\n", encodeA(GetCommandLineA()));
214 childPrintf(hFile, "argcA=%d\r\n", argc);
215 for (i = 0; i < argc; i++)
216 {
217 if (winetest_debug > 2)
218 trace("argvA%d='%s'\n", i, argv[i]);
219 childPrintf(hFile, "argvA%d=%s\r\n", i, encodeA(argv[i]));
220 }
221 GetModuleFileNameA(GetModuleHandleA(NULL), buffer, sizeof(buffer));
222 childPrintf(hFile, "longPath=%s\r\n", encodeA(buffer));
223
224 /* Check environment variable inheritance */
225 *buffer = '\0';
226 SetLastError(0);
227 GetEnvironmentVariableA("ShlexecVar", buffer, sizeof(buffer));
228 childPrintf(hFile, "ShlexecVarLE=%d\r\n", GetLastError());
229 childPrintf(hFile, "ShlexecVar=%s\r\n", encodeA(buffer));
230
231 map = OpenFileMappingA(FILE_MAP_READ, FALSE, "winetest_shlexec_dde_map");
232 if (map != NULL)
233 {
234 HANDLE dde_ready;
235 char *shared_block = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 4096);
236 CloseHandle(map);
237 if (shared_block[0] != '\0' || shared_block[1] != '\0')
238 {
239 HDDEDATA hdde;
240 HSZ hszApplication;
241 MSG msg;
242 UINT rc;
243
244 post_quit_on_execute = TRUE;
245 ddeInst = 0;
246 rc = DdeInitializeA(&ddeInst, ddeCb, CBF_SKIP_ALLNOTIFICATIONS | CBF_FAIL_ADVISES |
247 CBF_FAIL_POKES | CBF_FAIL_REQUESTS, 0);
248 ok(rc == DMLERR_NO_ERROR, "DdeInitializeA() returned %d\n", rc);
249 hszApplication = DdeCreateStringHandleA(ddeInst, shared_block, CP_WINANSI);
250 ok(hszApplication != NULL, "DdeCreateStringHandleA(%s) = NULL\n", shared_block);
251 shared_block += strlen(shared_block) + 1;
252 hszTopic = DdeCreateStringHandleA(ddeInst, shared_block, CP_WINANSI);
253 ok(hszTopic != NULL, "DdeCreateStringHandleA(%s) = NULL\n", shared_block);
254 hdde = DdeNameService(ddeInst, hszApplication, 0, DNS_REGISTER | DNS_FILTEROFF);
255 ok(hdde != NULL, "DdeNameService() failed le=%u\n", GetLastError());
256
257 timer = SetTimer(NULL, 0, CHILD_DDE_TIMEOUT, childTimeout);
258
259 dde_ready = OpenEventA(EVENT_MODIFY_STATE, FALSE, "winetest_shlexec_dde_ready");
260 SetEvent(dde_ready);
261 CloseHandle(dde_ready);
262
263 while (GetMessageA(&msg, NULL, 0, 0))
264 {
265 if (winetest_debug > 2)
266 trace("msg %d lParam=%ld wParam=%lu\n", msg.message, msg.lParam, msg.wParam);
267 DispatchMessageA(&msg);
268 }
269
270 Sleep(500);
271 KillTimer(NULL, timer);
272 hdde = DdeNameService(ddeInst, hszApplication, 0, DNS_UNREGISTER);
273 ok(hdde != NULL, "DdeNameService() failed le=%u\n", GetLastError());
274 ok(DdeFreeStringHandle(ddeInst, hszTopic), "DdeFreeStringHandle(topic)\n");
275 ok(DdeFreeStringHandle(ddeInst, hszApplication), "DdeFreeStringHandle(application)\n");
276 ok(DdeUninitialize(ddeInst), "DdeUninitialize() failed\n");
277 }
278 else
279 {
280 dde_ready = OpenEventA(EVENT_MODIFY_STATE, FALSE, "winetest_shlexec_dde_ready");
281 SetEvent(dde_ready);
282 CloseHandle(dde_ready);
283 }
284
285 UnmapViewOfFile(shared_block);
286
287 childPrintf(hFile, "ddeExec=%s\r\n", encodeA(ddeExec));
288 }
289
290 childPrintf(hFile, "Failures=%d\r\n", winetest_get_failures());
291 CloseHandle(hFile);
292
293 init_event(filename);
294 SetEvent(hEvent);
295 CloseHandle(hEvent);
296 }
297
298 static void dump_child_(const char* file, int line)
299 {
300 if (winetest_debug > 1)
301 {
302 char key[18];
303 char* str;
304 int i, c;
305
306 str=getChildString("Child", "cmdlineA");
307 trace_(file, line)("cmdlineA='%s'\n", str);
308 c=GetPrivateProfileIntA("Child", "argcA", -1, child_file);
309 trace_(file, line)("argcA=%d\n",c);
310 for (i=0;i<c;i++)
311 {
312 sprintf(key, "argvA%d", i);
313 str=getChildString("Child", key);
314 trace_(file, line)("%s='%s'\n", key, str);
315 }
316
317 c=GetPrivateProfileIntA("Child", "ShlexecVarLE", -1, child_file);
318 trace_(file, line)("ShlexecVarLE=%d\n", c);
319 str=getChildString("Child", "ShlexecVar");
320 trace_(file, line)("ShlexecVar='%s'\n", str);
321
322 c=GetPrivateProfileIntA("Child", "Failures", -1, child_file);
323 trace_(file, line)("Failures=%d\n", c);
324 }
325 }
326
327
328 /***
329 *
330 * Helpers to check the ShellExecute() / child process results.
331 *
332 ***/
333
334 static char shell_call[2048];
335 static void WINETEST_PRINTF_ATTR(2,3) _okShell(int condition, const char *msg, ...)
336 {
337 va_list valist;
338 char buffer[2048];
339
340 strcpy(buffer, shell_call);
341 strcat(buffer, " ");
342 va_start(valist, msg);
343 vsprintf(buffer+strlen(buffer), msg, valist);
344 va_end(valist);
345 winetest_ok(condition, "%s", buffer);
346 }
347 #define okShell_(file, line) (winetest_set_location(file, line), 0) ? (void)0 : _okShell
348 #define okShell okShell_(__FILE__, __LINE__)
349
350 static char assoc_desc[2048];
351 static void reset_association_description(void)
352 {
353 *assoc_desc = '\0';
354 }
355
356 static void okChildString_(const char* file, int line, const char* key, const char* expected, const char* bad)
357 {
358 char* result;
359 result=getChildString("Child", key);
360 if (!result)
361 {
362 okShell_(file, line)(FALSE, "%s expected '%s', but key not found or empty\n", key, expected);
363 return;
364 }
365 okShell_(file, line)(lstrcmpiA(result, expected) == 0 ||
366 broken(lstrcmpiA(result, bad) == 0),
367 "%s expected '%s', got '%s'\n", key, expected, result);
368 }
369 #define okChildString(key, expected) okChildString_(__FILE__, __LINE__, (key), (expected), (expected))
370 #define okChildStringBroken(key, expected, broken) okChildString_(__FILE__, __LINE__, (key), (expected), (broken))
371
372 static int StrCmpPath(const char* s1, const char* s2)
373 {
374 if (!s1 && !s2) return 0;
375 if (!s2) return 1;
376 if (!s1) return -1;
377 while (*s1)
378 {
379 if (!*s2)
380 {
381 if (*s1=='.')
382 s1++;
383 return (*s1-*s2);
384 }
385 if ((*s1=='/' || *s1=='\\') && (*s2=='/' || *s2=='\\'))
386 {
387 while (*s1=='/' || *s1=='\\')
388 s1++;
389 while (*s2=='/' || *s2=='\\')
390 s2++;
391 }
392 else if (toupper(*s1)==toupper(*s2))
393 {
394 s1++;
395 s2++;
396 }
397 else
398 {
399 return (*s1-*s2);
400 }
401 }
402 if (*s2=='.')
403 s2++;
404 if (*s2)
405 return -1;
406 return 0;
407 }
408
409 static void okChildPath_(const char* file, int line, const char* key, const char* expected)
410 {
411 char* result;
412 int equal, shortequal;
413 result=getChildString("Child", key);
414 if (!result)
415 {
416 okShell_(file,line)(FALSE, "%s expected '%s', but key not found or empty\n", key, expected);
417 return;
418 }
419 shortequal = FALSE;
420 equal = (StrCmpPath(result, expected) == 0);
421 if (!equal)
422 {
423 char altpath[MAX_PATH];
424 DWORD rc = GetLongPathNameA(expected, altpath, sizeof(altpath));
425 if (0 < rc && rc < sizeof(altpath))
426 equal = (StrCmpPath(result, altpath) == 0);
427 if (!equal)
428 {
429 rc = GetShortPathNameA(expected, altpath, sizeof(altpath));
430 if (0 < rc && rc < sizeof(altpath))
431 shortequal = (StrCmpPath(result, altpath) == 0);
432 }
433 }
434 okShell_(file,line)(equal || broken(shortequal) /* XP SP1 */,
435 "%s expected '%s', got '%s'\n", key, expected, result);
436 }
437 #define okChildPath(key, expected) okChildPath_(__FILE__, __LINE__, (key), (expected))
438
439 static void okChildInt_(const char* file, int line, const char* key, int expected)
440 {
441 INT result;
442 result=GetPrivateProfileIntA("Child", key, expected, child_file);
443 okShell_(file,line)(result == expected,
444 "%s expected %d, but got %d\n", key, expected, result);
445 }
446 #define okChildInt(key, expected) okChildInt_(__FILE__, __LINE__, (key), (expected))
447
448 static void okChildIntBroken_(const char* file, int line, const char* key, int expected)
449 {
450 INT result;
451 result=GetPrivateProfileIntA("Child", key, expected, child_file);
452 okShell_(file,line)(result == expected || broken(result != expected),
453 "%s expected %d, but got %d\n", key, expected, result);
454 }
455 #define okChildIntBroken(key, expected) okChildIntBroken_(__FILE__, __LINE__, (key), (expected))
456
457
458 /***
459 *
460 * ShellExecute wrappers
461 *
462 ***/
463
464 static void strcat_param(char* str, const char* name, const char* param)
465 {
466 if (param)
467 {
468 if (str[strlen(str)-1] == '"')
469 strcat(str, ", ");
470 strcat(str, name);
471 strcat(str, "=\"");
472 strcat(str, param);
473 strcat(str, "\"");
474 }
475 }
476
477 static int _todo_wait = 0;
478 #define todo_wait for (_todo_wait = 1; _todo_wait; _todo_wait = 0)
479
480 static int bad_shellexecute = 0;
481
482 static INT_PTR shell_execute_(const char* file, int line, LPCSTR verb, LPCSTR filename, LPCSTR parameters, LPCSTR directory)
483 {
484 INT_PTR rc, rcEmpty = 0;
485
486 if(!verb)
487 rcEmpty = shell_execute_(file, line, "", filename, parameters, directory);
488
489 strcpy(shell_call, "ShellExecute(");
490 strcat_param(shell_call, "verb", verb);
491 strcat_param(shell_call, "file", filename);
492 strcat_param(shell_call, "params", parameters);
493 strcat_param(shell_call, "dir", directory);
494 strcat(shell_call, ")");
495 strcat(shell_call, assoc_desc);
496 if (winetest_debug > 1)
497 trace_(file, line)("Called %s\n", shell_call);
498
499 DeleteFileA(child_file);
500 SetLastError(0xcafebabe);
501
502 /* FIXME: We cannot use ShellExecuteEx() here because if there is no
503 * association it displays the 'Open With' dialog and I could not find
504 * a flag to prevent this.
505 */
506 rc=(INT_PTR)ShellExecuteA(NULL, verb, filename, parameters, directory, SW_HIDE);
507
508 if (rc > 32)
509 {
510 int wait_rc;
511 wait_rc=WaitForSingleObject(hEvent, 5000);
512 if (wait_rc == WAIT_TIMEOUT)
513 {
514 HWND wnd = FindWindowA("#32770", "Windows");
515 if (!wnd)
516 wnd = FindWindowA("Shell_Flyout", "");
517 if (wnd != NULL)
518 {
519 SendMessageA(wnd, WM_CLOSE, 0, 0);
520 win_skip("Skipping shellexecute of file with unassociated extension\n");
521 skip_noassoc_tests = TRUE;
522 rc = SE_ERR_NOASSOC;
523 }
524 }
525 todo_wine_if(_todo_wait)
526 okShell_(file, line)(wait_rc==WAIT_OBJECT_0 || rc <= 32,
527 "WaitForSingleObject returned %d\n", wait_rc);
528 }
529 /* The child process may have changed the result file, so let profile
530 * functions know about it
531 */
532 WritePrivateProfileStringA(NULL, NULL, NULL, child_file);
533 if (GetFileAttributesA(child_file) != INVALID_FILE_ATTRIBUTES)
534 {
535 int c;
536 dump_child_(file, line);
537 c = GetPrivateProfileIntA("Child", "Failures", -1, child_file);
538 if (c > 0)
539 winetest_add_failures(c);
540 okChildInt_(file, line, "ShlexecVarLE", 0);
541 okChildString_(file, line, "ShlexecVar", "Present", "Present");
542 }
543
544 if(!verb)
545 {
546 if (rc != rcEmpty && rcEmpty == SE_ERR_NOASSOC) /* NT4 */
547 bad_shellexecute = 1;
548 okShell_(file, line)(rc == rcEmpty ||
549 broken(rc != rcEmpty && rcEmpty == SE_ERR_NOASSOC) /* NT4 */,
550 "Got different return value with empty string: %lu %lu\n", rc, rcEmpty);
551 }
552
553 return rc;
554 }
555 #define shell_execute(verb, filename, parameters, directory) \
556 shell_execute_(__FILE__, __LINE__, verb, filename, parameters, directory)
557
558 static INT_PTR shell_execute_ex_(const char* file, int line,
559 DWORD mask, LPCSTR verb, LPCSTR filename,
560 LPCSTR parameters, LPCSTR directory,
561 LPCSTR class)
562 {
563 char smask[11];
564 SHELLEXECUTEINFOA sei;
565 BOOL success;
566 INT_PTR rc;
567
568 /* Add some flags so we can wait for the child process */
569 mask |= SEE_MASK_NOCLOSEPROCESS | SEE_MASK_NO_CONSOLE;
570
571 strcpy(shell_call, "ShellExecuteEx(");
572 sprintf(smask, "0x%x", mask);
573 strcat_param(shell_call, "mask", smask);
574 strcat_param(shell_call, "verb", verb);
575 strcat_param(shell_call, "file", filename);
576 strcat_param(shell_call, "params", parameters);
577 strcat_param(shell_call, "dir", directory);
578 strcat_param(shell_call, "class", class);
579 strcat(shell_call, ")");
580 strcat(shell_call, assoc_desc);
581 if (winetest_debug > 1)
582 trace_(file, line)("Called %s\n", shell_call);
583
584 sei.cbSize=sizeof(sei);
585 sei.fMask=mask;
586 sei.hwnd=NULL;
587 sei.lpVerb=verb;
588 sei.lpFile=filename;
589 sei.lpParameters=parameters;
590 sei.lpDirectory=directory;
591 sei.nShow=SW_SHOWNORMAL;
592 sei.hInstApp=NULL; /* Out */
593 sei.lpIDList=NULL;
594 sei.lpClass=class;
595 sei.hkeyClass=NULL;
596 sei.dwHotKey=0;
597 U(sei).hIcon=NULL;
598 sei.hProcess=(HANDLE)0xdeadbeef; /* Out */
599
600 DeleteFileA(child_file);
601 SetLastError(0xcafebabe);
602 success=ShellExecuteExA(&sei);
603 rc=(INT_PTR)sei.hInstApp;
604 okShell_(file, line)((success && rc > 32) || (!success && rc <= 32),
605 "rc=%d and hInstApp=%ld is not allowed\n",
606 success, rc);
607
608 if (rc > 32)
609 {
610 DWORD wait_rc, rc;
611 if (sei.hProcess!=NULL)
612 {
613 wait_rc=WaitForSingleObject(sei.hProcess, 5000);
614 okShell_(file, line)(wait_rc==WAIT_OBJECT_0,
615 "WaitForSingleObject(hProcess) returned %d\n",
616 wait_rc);
617 wait_rc = GetExitCodeProcess(sei.hProcess, &rc);
618 okShell_(file, line)(wait_rc, "GetExitCodeProcess() failed le=%u\n", GetLastError());
619 todo_wine_if(_todo_wait)
620 okShell_(file, line)(rc == 0, "child returned %u\n", rc);
621 CloseHandle(sei.hProcess);
622 }
623 wait_rc=WaitForSingleObject(hEvent, 5000);
624 todo_wine_if(_todo_wait)
625 okShell_(file, line)(wait_rc==WAIT_OBJECT_0,
626 "WaitForSingleObject returned %d\n", wait_rc);
627 }
628 else
629 okShell_(file, line)(sei.hProcess==NULL,
630 "returned a process handle %p\n", sei.hProcess);
631
632 /* The child process may have changed the result file, so let profile
633 * functions know about it
634 */
635 WritePrivateProfileStringA(NULL, NULL, NULL, child_file);
636 if (rc > 32 && GetFileAttributesA(child_file) != INVALID_FILE_ATTRIBUTES)
637 {
638 int c;
639 dump_child_(file, line);
640 c = GetPrivateProfileIntA("Child", "Failures", -1, child_file);
641 if (c > 0)
642 winetest_add_failures(c);
643 /* When NOZONECHECKS is specified the environment variables are not
644 * inherited if the process does not have elevated privileges.
645 */
646 if ((mask & SEE_MASK_NOZONECHECKS) && skip_shlexec_tests)
647 {
648 okChildInt_(file, line, "ShlexecVarLE", 203);
649 okChildString_(file, line, "ShlexecVar", "", "");
650 }
651 else
652 {
653 okChildInt_(file, line, "ShlexecVarLE", 0);
654 okChildString_(file, line, "ShlexecVar", "Present", "Present");
655 }
656 }
657
658 return rc;
659 }
660 #define shell_execute_ex(mask, verb, filename, parameters, directory, class) \
661 shell_execute_ex_(__FILE__, __LINE__, mask, verb, filename, parameters, directory, class)
662
663
664 /***
665 *
666 * Functions to create / delete associations wrappers
667 *
668 ***/
669
670 static BOOL create_test_class(const char* class, BOOL protocol)
671 {
672 HKEY hkey, hkey_shell;
673 LONG rc;
674
675 rc = RegCreateKeyExA(HKEY_CLASSES_ROOT, class, 0, NULL, 0,
676 KEY_CREATE_SUB_KEY | KEY_SET_VALUE, NULL,
677 &hkey, NULL);
678 ok(rc == ERROR_SUCCESS || rc == ERROR_ACCESS_DENIED,
679 "could not create class %s (rc=%d)\n", class, rc);
680 if (rc != ERROR_SUCCESS)
681 return FALSE;
682
683 if (protocol)
684 {
685 rc = RegSetValueExA(hkey, "URL Protocol", 0, REG_SZ, (LPBYTE)"", 1);
686 ok(rc == ERROR_SUCCESS, "RegSetValueEx '%s' failed, expected ERROR_SUCCESS, got %d\n", class, rc);
687 }
688
689 rc = RegCreateKeyExA(hkey, "shell", 0, NULL, 0,
690 KEY_CREATE_SUB_KEY, NULL, &hkey_shell, NULL);
691 ok(rc == ERROR_SUCCESS, "RegCreateKeyEx 'shell' failed, expected ERROR_SUCCESS, got %d\n", rc);
692
693 CloseHandle(hkey);
694 CloseHandle(hkey_shell);
695 return TRUE;
696 }
697
698 static BOOL create_test_association(const char* extension)
699 {
700 HKEY hkey;
701 char class[MAX_PATH];
702 LONG rc;
703
704 sprintf(class, "shlexec%s", extension);
705 rc=RegCreateKeyExA(HKEY_CLASSES_ROOT, extension, 0, NULL, 0, KEY_SET_VALUE,
706 NULL, &hkey, NULL);
707 ok(rc == ERROR_SUCCESS || rc == ERROR_ACCESS_DENIED,
708 "could not create association %s (rc=%d)\n", class, rc);
709 if (rc != ERROR_SUCCESS)
710 return FALSE;
711
712 rc=RegSetValueExA(hkey, NULL, 0, REG_SZ, (LPBYTE) class, strlen(class)+1);
713 ok(rc==ERROR_SUCCESS, "RegSetValueEx '%s' failed, expected ERROR_SUCCESS, got %d\n", class, rc);
714 CloseHandle(hkey);
715
716 return create_test_class(class, FALSE);
717 }
718
719 /* Based on RegDeleteTreeW from dlls/advapi32/registry.c */
720 static LSTATUS myRegDeleteTreeA(HKEY hKey, LPCSTR lpszSubKey)
721 {
722 LONG ret;
723 DWORD dwMaxSubkeyLen, dwMaxValueLen;
724 DWORD dwMaxLen, dwSize;
725 CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
726 HKEY hSubKey = hKey;
727
728 if(lpszSubKey)
729 {
730 ret = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
731 if (ret) return ret;
732 }
733
734 /* Get highest length for keys, values */
735 ret = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL,
736 &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
737 if (ret) goto cleanup;
738
739 dwMaxSubkeyLen++;
740 dwMaxValueLen++;
741 dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
742 if (dwMaxLen > sizeof(szNameBuf)/sizeof(CHAR))
743 {
744 /* Name too big: alloc a buffer for it */
745 if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(CHAR))))
746 {
747 ret = ERROR_NOT_ENOUGH_MEMORY;
748 goto cleanup;
749 }
750 }
751
752
753 /* Recursively delete all the subkeys */
754 while (TRUE)
755 {
756 dwSize = dwMaxLen;
757 if (RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL,
758 NULL, NULL, NULL)) break;
759
760 ret = myRegDeleteTreeA(hSubKey, lpszName);
761 if (ret) goto cleanup;
762 }
763
764 if (lpszSubKey)
765 ret = RegDeleteKeyA(hKey, lpszSubKey);
766 else
767 while (TRUE)
768 {
769 dwSize = dwMaxLen;
770 if (RegEnumValueA(hKey, 0, lpszName, &dwSize,
771 NULL, NULL, NULL, NULL)) break;
772
773 ret = RegDeleteValueA(hKey, lpszName);
774 if (ret) goto cleanup;
775 }
776
777 cleanup:
778 /* Free buffer if allocated */
779 if (lpszName != szNameBuf)
780 HeapFree( GetProcessHeap(), 0, lpszName);
781 if(lpszSubKey)
782 RegCloseKey(hSubKey);
783 return ret;
784 }
785
786 static void delete_test_class(const char* classname)
787 {
788 myRegDeleteTreeA(HKEY_CLASSES_ROOT, classname);
789 }
790
791 static void delete_test_association(const char* extension)
792 {
793 char classname[MAX_PATH];
794
795 sprintf(classname, "shlexec%s", extension);
796 delete_test_class(classname);
797 myRegDeleteTreeA(HKEY_CLASSES_ROOT, extension);
798 }
799
800 static void create_test_verb_dde(const char* classname, const char* verb,
801 int rawcmd, const char* cmdtail, const char *ddeexec,
802 const char *application, const char *topic,
803 const char *ifexec)
804 {
805 HKEY hkey_shell, hkey_verb, hkey_cmd;
806 char shell[MAX_PATH];
807 char* cmd;
808 LONG rc;
809
810 strcpy(assoc_desc, " Assoc ");
811 strcat_param(assoc_desc, "class", classname);
812 strcat_param(assoc_desc, "verb", verb);
813 sprintf(shell, "%d", rawcmd);
814 strcat_param(assoc_desc, "rawcmd", shell);
815 strcat_param(assoc_desc, "cmdtail", cmdtail);
816 strcat_param(assoc_desc, "ddeexec", ddeexec);
817 strcat_param(assoc_desc, "app", application);
818 strcat_param(assoc_desc, "topic", topic);
819 strcat_param(assoc_desc, "ifexec", ifexec);
820
821 sprintf(shell, "%s\\shell", classname);
822 rc=RegOpenKeyExA(HKEY_CLASSES_ROOT, shell, 0,
823 KEY_CREATE_SUB_KEY, &hkey_shell);
824 ok(rc == ERROR_SUCCESS, "%s key creation failed with %d\n", shell, rc);
825
826 rc=RegCreateKeyExA(hkey_shell, verb, 0, NULL, 0, KEY_CREATE_SUB_KEY,
827 NULL, &hkey_verb, NULL);
828 ok(rc == ERROR_SUCCESS, "%s verb key creation failed with %d\n", verb, rc);
829
830 rc=RegCreateKeyExA(hkey_verb, "command", 0, NULL, 0, KEY_SET_VALUE,
831 NULL, &hkey_cmd, NULL);
832 ok(rc == ERROR_SUCCESS, "\'command\' key creation failed with %d\n", rc);
833
834 if (rawcmd)
835 {
836 rc=RegSetValueExA(hkey_cmd, NULL, 0, REG_SZ, (LPBYTE)cmdtail, strlen(cmdtail)+1);
837 }
838 else
839 {
840 cmd=HeapAlloc(GetProcessHeap(), 0, strlen(argv0)+10+strlen(child_file)+2+strlen(cmdtail)+1);
841 sprintf(cmd,"%s shlexec \"%s\" %s", argv0, child_file, cmdtail);
842 rc=RegSetValueExA(hkey_cmd, NULL, 0, REG_SZ, (LPBYTE)cmd, strlen(cmd)+1);
843 ok(rc == ERROR_SUCCESS, "setting command failed with %d\n", rc);
844 HeapFree(GetProcessHeap(), 0, cmd);
845 }
846
847 if (ddeexec)
848 {
849 HKEY hkey_ddeexec, hkey_application, hkey_topic, hkey_ifexec;
850
851 rc=RegCreateKeyExA(hkey_verb, "ddeexec", 0, NULL, 0, KEY_SET_VALUE |
852 KEY_CREATE_SUB_KEY, NULL, &hkey_ddeexec, NULL);
853 ok(rc == ERROR_SUCCESS, "\'ddeexec\' key creation failed with %d\n", rc);
854 rc=RegSetValueExA(hkey_ddeexec, NULL, 0, REG_SZ, (LPBYTE)ddeexec,
855 strlen(ddeexec)+1);
856 ok(rc == ERROR_SUCCESS, "set value failed with %d\n", rc);
857
858 if (application)
859 {
860 rc=RegCreateKeyExA(hkey_ddeexec, "application", 0, NULL, 0, KEY_SET_VALUE,
861 NULL, &hkey_application, NULL);
862 ok(rc == ERROR_SUCCESS, "\'application\' key creation failed with %d\n", rc);
863
864 rc=RegSetValueExA(hkey_application, NULL, 0, REG_SZ, (LPBYTE)application,
865 strlen(application)+1);
866 ok(rc == ERROR_SUCCESS, "set value failed with %d\n", rc);
867 CloseHandle(hkey_application);
868 }
869 if (topic)
870 {
871 rc=RegCreateKeyExA(hkey_ddeexec, "topic", 0, NULL, 0, KEY_SET_VALUE,
872 NULL, &hkey_topic, NULL);
873 ok(rc == ERROR_SUCCESS, "\'topic\' key creation failed with %d\n", rc);
874 rc=RegSetValueExA(hkey_topic, NULL, 0, REG_SZ, (LPBYTE)topic,
875 strlen(topic)+1);
876 ok(rc == ERROR_SUCCESS, "set value failed with %d\n", rc);
877 CloseHandle(hkey_topic);
878 }
879 if (ifexec)
880 {
881 rc=RegCreateKeyExA(hkey_ddeexec, "ifexec", 0, NULL, 0, KEY_SET_VALUE,
882 NULL, &hkey_ifexec, NULL);
883 ok(rc == ERROR_SUCCESS, "\'ifexec\' key creation failed with %d\n", rc);
884 rc=RegSetValueExA(hkey_ifexec, NULL, 0, REG_SZ, (LPBYTE)ifexec,
885 strlen(ifexec)+1);
886 ok(rc == ERROR_SUCCESS, "set value failed with %d\n", rc);
887 CloseHandle(hkey_ifexec);
888 }
889 CloseHandle(hkey_ddeexec);
890 }
891
892 CloseHandle(hkey_shell);
893 CloseHandle(hkey_verb);
894 CloseHandle(hkey_cmd);
895 }
896
897 /* Creates a class' non-DDE test verb.
898 * This function is meant to be used to create long term test verbs and thus
899 * does not trace them.
900 */
901 static void create_test_verb(const char* classname, const char* verb,
902 int rawcmd, const char* cmdtail)
903 {
904 create_test_verb_dde(classname, verb, rawcmd, cmdtail, NULL, NULL,
905 NULL, NULL);
906 reset_association_description();
907 }
908
909
910 /***
911 *
912 * GetLongPathNameA equivalent that supports Win95 and WinNT
913 *
914 ***/
915
916 static DWORD get_long_path_name(const char* shortpath, char* longpath, DWORD longlen)
917 {
918 char tmplongpath[MAX_PATH];
919 const char* p;
920 DWORD sp = 0, lp = 0;
921 DWORD tmplen;
922 WIN32_FIND_DATAA wfd;
923 HANDLE goit;
924
925 if (!shortpath || !shortpath[0])
926 return 0;
927
928 if (shortpath[1] == ':')
929 {
930 tmplongpath[0] = shortpath[0];
931 tmplongpath[1] = ':';
932 lp = sp = 2;
933 }
934
935 while (shortpath[sp])
936 {
937 /* check for path delimiters and reproduce them */
938 if (shortpath[sp] == '\\' || shortpath[sp] == '/')
939 {
940 if (!lp || tmplongpath[lp-1] != '\\')
941 {
942 /* strip double "\\" */
943 tmplongpath[lp++] = '\\';
944 }
945 tmplongpath[lp] = 0; /* terminate string */
946 sp++;
947 continue;
948 }
949
950 p = shortpath + sp;
951 if (sp == 0 && p[0] == '.' && (p[1] == '/' || p[1] == '\\'))
952 {
953 tmplongpath[lp++] = *p++;
954 tmplongpath[lp++] = *p++;
955 }
956 for (; *p && *p != '/' && *p != '\\'; p++);
957 tmplen = p - (shortpath + sp);
958 lstrcpynA(tmplongpath + lp, shortpath + sp, tmplen + 1);
959 /* Check if the file exists and use the existing file name */
960 goit = FindFirstFileA(tmplongpath, &wfd);
961 if (goit == INVALID_HANDLE_VALUE)
962 return 0;
963 FindClose(goit);
964 strcpy(tmplongpath + lp, wfd.cFileName);
965 lp += strlen(tmplongpath + lp);
966 sp += tmplen;
967 }
968 tmplen = strlen(shortpath) - 1;
969 if ((shortpath[tmplen] == '/' || shortpath[tmplen] == '\\') &&
970 (tmplongpath[lp - 1] != '/' && tmplongpath[lp - 1] != '\\'))
971 tmplongpath[lp++] = shortpath[tmplen];
972 tmplongpath[lp] = 0;
973
974 tmplen = strlen(tmplongpath) + 1;
975 if (tmplen <= longlen)
976 {
977 strcpy(longpath, tmplongpath);
978 tmplen--; /* length without 0 */
979 }
980
981 return tmplen;
982 }
983
984
985 /***
986 *
987 * Tests
988 *
989 ***/
990
991 static const char* testfiles[]=
992 {
993 "%s\\test file.shlexec",
994 "%s\\%%nasty%% $file.shlexec",
995 "%s\\test file.noassoc",
996 "%s\\test file.noassoc.shlexec",
997 "%s\\test file.shlexec.noassoc",
998 "%s\\test_shortcut_shlexec.lnk",
999 "%s\\test_shortcut_exe.lnk",
1000 "%s\\test file.shl",
1001 "%s\\test file.shlfoo",
1002 "%s\\test file.sha",
1003 "%s\\test file.sfe",
1004 "%s\\test file.shlproto",
1005 "%s\\masked file.shlexec",
1006 "%s\\masked",
1007 "%s\\test file.sde",
1008 "%s\\test file.exe",
1009 "%s\\test2.exe",
1010 "%s\\simple.shlexec",
1011 "%s\\drawback_file.noassoc",
1012 "%s\\drawback_file.noassoc foo.shlexec",
1013 "%s\\drawback_nonexist.noassoc foo.shlexec",
1014 NULL
1015 };
1016
1017 typedef struct
1018 {
1019 const char* verb;
1020 const char* basename;
1021 int todo;
1022 INT_PTR rc;
1023 } filename_tests_t;
1024
1025 static filename_tests_t filename_tests[]=
1026 {
1027 /* Test bad / nonexistent filenames */
1028 {NULL, "%s\\nonexistent.shlexec", 0x0, SE_ERR_FNF},
1029 {NULL, "%s\\nonexistent.noassoc", 0x0, SE_ERR_FNF},
1030
1031 /* Standard tests */
1032 {NULL, "%s\\test file.shlexec", 0x0, 33},
1033 {NULL, "%s\\test file.shlexec.", 0x0, 33},
1034 {NULL, "%s\\%%nasty%% $file.shlexec", 0x0, 33},
1035 {NULL, "%s/test file.shlexec", 0x0, 33},
1036
1037 /* Test filenames with no association */
1038 {NULL, "%s\\test file.noassoc", 0x0, SE_ERR_NOASSOC},
1039
1040 /* Test double extensions */
1041 {NULL, "%s\\test file.noassoc.shlexec", 0x0, 33},
1042 {NULL, "%s\\test file.shlexec.noassoc", 0x0, SE_ERR_NOASSOC},
1043
1044 /* Test alternate verbs */
1045 {"LowerL", "%s\\nonexistent.shlexec", 0x0, SE_ERR_FNF},
1046 {"LowerL", "%s\\test file.noassoc", 0x0, SE_ERR_NOASSOC},
1047
1048 {"QuotedLowerL", "%s\\test file.shlexec", 0x0, 33},
1049 {"QuotedUpperL", "%s\\test file.shlexec", 0x0, 33},
1050
1051 {"notaverb", "%s\\test file.shlexec", 0x10, SE_ERR_NOASSOC},
1052
1053 {"averb", "%s\\test file.sha", 0x10, 33},
1054
1055 /* Test file masked due to space */
1056 {NULL, "%s\\masked file.shlexec", 0x0, 33},
1057 /* Test if quoting prevents the masking */
1058 {NULL, "%s\\masked file.shlexec", 0x40, 33},
1059 /* Test with incorrect quote */
1060 {NULL, "\"%s\\masked file.shlexec", 0x0, SE_ERR_FNF},
1061
1062 /* Test extension / URI protocol collision */
1063 {NULL, "%s\\test file.shlproto", 0x0, SE_ERR_NOASSOC},
1064
1065 {NULL, NULL, 0}
1066 };
1067
1068 static filename_tests_t noquotes_tests[]=
1069 {
1070 /* Test unquoted '%1' thingies */
1071 {"NoQuotes", "%s\\test file.shlexec", 0xa, 33},
1072 {"LowerL", "%s\\test file.shlexec", 0xa, 33},
1073 {"UpperL", "%s\\test file.shlexec", 0xa, 33},
1074
1075 {NULL, NULL, 0}
1076 };
1077
1078 static void test_lpFile_parsed(void)
1079 {
1080 char fileA[MAX_PATH];
1081 INT_PTR rc;
1082
1083 if (skip_shlexec_tests)
1084 {
1085 skip("No filename parsing tests due to lack of .shlexec association\n");
1086 return;
1087 }
1088
1089 /* existing "drawback_file.noassoc" prevents finding "drawback_file.noassoc foo.shlexec" on wine */
1090 sprintf(fileA, "%s\\drawback_file.noassoc foo.shlexec", tmpdir);
1091 rc=shell_execute(NULL, fileA, NULL, NULL);
1092 okShell(rc > 32, "failed: rc=%lu\n", rc);
1093
1094 /* if quoted, existing "drawback_file.noassoc" not prevents finding "drawback_file.noassoc foo.shlexec" on wine */
1095 sprintf(fileA, "\"%s\\drawback_file.noassoc foo.shlexec\"", tmpdir);
1096 rc=shell_execute(NULL, fileA, NULL, NULL);
1097 okShell(rc > 32 || broken(rc == SE_ERR_FNF) /* Win95/NT4 */,
1098 "failed: rc=%lu\n", rc);
1099
1100 /* error should be SE_ERR_FNF, not SE_ERR_NOASSOC */
1101 sprintf(fileA, "\"%s\\drawback_file.noassoc\" foo.shlexec", tmpdir);
1102 rc=shell_execute(NULL, fileA, NULL, NULL);
1103 okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
1104
1105 /* ""command"" not works on wine (and real win9x and w2k) */
1106 sprintf(fileA, "\"\"%s\\simple.shlexec\"\"", tmpdir);
1107 rc=shell_execute(NULL, fileA, NULL, NULL);
1108 todo_wine okShell(rc > 32 || broken(rc == SE_ERR_FNF) /* Win9x/2000 */,
1109 "failed: rc=%lu\n", rc);
1110
1111 /* nonexisting "drawback_nonexist.noassoc" not prevents finding "drawback_nonexist.noassoc foo.shlexec" on wine */
1112 sprintf(fileA, "%s\\drawback_nonexist.noassoc foo.shlexec", tmpdir);
1113 rc=shell_execute(NULL, fileA, NULL, NULL);
1114 okShell(rc > 32, "failed: rc=%lu\n", rc);
1115
1116 /* is SEE_MASK_DOENVSUBST default flag? Should only be when XP emulates 9x (XP bug or real 95 or ME behavior ?) */
1117 rc=shell_execute(NULL, "%TMPDIR%\\simple.shlexec", NULL, NULL);
1118 todo_wine okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
1119
1120 /* quoted */
1121 rc=shell_execute(NULL, "\"%TMPDIR%\\simple.shlexec\"", NULL, NULL);
1122 todo_wine okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
1123
1124 /* test SEE_MASK_DOENVSUBST works */
1125 rc=shell_execute_ex(SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI,
1126 NULL, "%TMPDIR%\\simple.shlexec", NULL, NULL, NULL);
1127 okShell(rc > 32, "failed: rc=%lu\n", rc);
1128
1129 /* quoted lpFile does not work on real win95 and nt4 */
1130 rc=shell_execute_ex(SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI,
1131 NULL, "\"%TMPDIR%\\simple.shlexec\"", NULL, NULL, NULL);
1132 okShell(rc > 32 || broken(rc == SE_ERR_FNF) /* Win95/NT4 */,
1133 "failed: rc=%lu\n", rc);
1134 }
1135
1136 typedef struct
1137 {
1138 const char* cmd;
1139 const char* args[11];
1140 int todo;
1141 } cmdline_tests_t;
1142
1143 static const cmdline_tests_t cmdline_tests[] =
1144 {
1145 {"exe",
1146 {"exe", NULL}, 0},
1147
1148 {"exe arg1 arg2 \"arg three\" 'four five` six\\ $even)",
1149 {"exe", "arg1", "arg2", "arg three", "'four", "five`", "six\\", "$even)", NULL}, 0},
1150
1151 {"exe arg=1 arg-2 three\tfour\rfour\nfour ",
1152 {"exe", "arg=1", "arg-2", "three", "four\rfour\nfour", NULL}, 0},
1153
1154 {"exe arg\"one\" \"second\"arg thirdarg ",
1155 {"exe", "argone", "secondarg", "thirdarg", NULL}, 0},
1156
1157 /* Don't lose unclosed quoted arguments */
1158 {"exe arg1 \"unclosed",
1159 {"exe", "arg1", "unclosed", NULL}, 0},
1160
1161 {"exe arg1 \"",
1162 {"exe", "arg1", "", NULL}, 0},
1163
1164 /* cmd's metacharacters have no special meaning */
1165 {"exe \"one^\" \"arg\"&two three|four",
1166 {"exe", "one^", "arg&two", "three|four", NULL}, 0},
1167
1168 /* Environment variables are not interpreted either */
1169 {"exe %TMPDIR% %2",
1170 {"exe", "%TMPDIR%", "%2", NULL}, 0},
1171
1172 /* If not followed by a quote, backslashes go through as is */
1173 {"exe o\\ne t\\\\wo t\\\\\\ree f\\\\\\\\our ",
1174 {"exe", "o\\ne", "t\\\\wo", "t\\\\\\ree", "f\\\\\\\\our", NULL}, 0},
1175
1176 {"exe \"o\\ne\" \"t\\\\wo\" \"t\\\\\\ree\" \"f\\\\\\\\our\" ",
1177 {"exe", "o\\ne", "t\\\\wo", "t\\\\\\ree", "f\\\\\\\\our", NULL}, 0},
1178
1179 /* When followed by a quote their number is halved and the remainder
1180 * escapes the quote
1181 */
1182 {"exe \\\"one \\\\\"two\" \\\\\\\"three \\\\\\\\\"four\" end",
1183 {"exe", "\"one", "\\two", "\\\"three", "\\\\four", "end", NULL}, 0},
1184
1185 {"exe \"one\\\" still\" \"two\\\\\" \"three\\\\\\\" still\" \"four\\\\\\\\\" end",
1186 {"exe", "one\" still", "two\\", "three\\\" still", "four\\\\", "end", NULL}, 0},
1187
1188 /* One can put a quote in an unquoted string by tripling it, that is in
1189 * effect quoting it like so """ -> ". The general rule is as follows:
1190 * 3n quotes -> n quotes
1191 * 3n+1 quotes -> n quotes plus start of a quoted string
1192 * 3n+2 quotes -> n quotes (plus an empty string from the remaining pair)
1193 * Nicely, when n is 0 we get the standard rules back.
1194 */
1195 {"exe two\"\"quotes next",
1196 {"exe", "twoquotes", "next", NULL}, 0},
1197
1198 {"exe three\"\"\"quotes next",
1199 {"exe", "three\"quotes", "next", NULL}, 0},
1200
1201 {"exe four\"\"\"\" quotes\" next 4%3=1",
1202 {"exe", "four\" quotes", "next", "4%3=1", NULL}, 0},
1203
1204 {"exe five\"\"\"\"\"quotes next",
1205 {"exe", "five\"quotes", "next", NULL}, 0},
1206
1207 {"exe six\"\"\"\"\"\"quotes next",
1208 {"exe", "six\"\"quotes", "next", NULL}, 0},
1209
1210 {"exe seven\"\"\"\"\"\"\" quotes\" next 7%3=1",
1211 {"exe", "seven\"\" quotes", "next", "7%3=1", NULL}, 0},
1212
1213 {"exe twelve\"\"\"\"\"\"\"\"\"\"\"\"quotes next",
1214 {"exe", "twelve\"\"\"\"quotes", "next", NULL}, 0},
1215
1216 {"exe thirteen\"\"\"\"\"\"\"\"\"\"\"\"\" quotes\" next 13%3=1",
1217 {"exe", "thirteen\"\"\"\" quotes", "next", "13%3=1", NULL}, 0},
1218
1219 /* Inside a quoted string the opening quote is added to the set of
1220 * consecutive quotes to get the effective quotes count. This gives:
1221 * 1+3n quotes -> n quotes
1222 * 1+3n+1 quotes -> n quotes plus closes the quoted string
1223 * 1+3n+2 quotes -> n+1 quotes plus closes the quoted string
1224 */
1225 {"exe \"two\"\"quotes next",
1226 {"exe", "two\"quotes", "next", NULL}, 0},
1227
1228 {"exe \"two\"\" next",
1229 {"exe", "two\"", "next", NULL}, 0},
1230
1231 {"exe \"three\"\"\" quotes\" next 4%3=1",
1232 {"exe", "three\" quotes", "next", "4%3=1", NULL}, 0},
1233
1234 {"exe \"four\"\"\"\"quotes next",
1235 {"exe", "four\"quotes", "next", NULL}, 0},
1236
1237 {"exe \"five\"\"\"\"\"quotes next",
1238 {"exe", "five\"\"quotes", "next", NULL}, 0},
1239
1240 {"exe \"six\"\"\"\"\"\" quotes\" next 7%3=1",
1241 {"exe", "six\"\" quotes", "next", "7%3=1", NULL}, 0},
1242
1243 {"exe \"eleven\"\"\"\"\"\"\"\"\"\"\"quotes next",
1244 {"exe", "eleven\"\"\"\"quotes", "next", NULL}, 0},
1245
1246 {"exe \"twelve\"\"\"\"\"\"\"\"\"\"\"\" quotes\" next 13%3=1",
1247 {"exe", "twelve\"\"\"\" quotes", "next", "13%3=1", NULL}, 0},
1248
1249 /* Escaped consecutive quotes are fun */
1250 {"exe \"the crazy \\\\\"\"\"\\\\\" quotes",
1251 {"exe", "the crazy \\\"\\", "quotes", NULL}, 0},
1252
1253 /* The executable path has its own rules!!!
1254 * - Backslashes have no special meaning.
1255 * - If the first character is a quote, then the second quote ends the
1256 * executable path.
1257 * - The previous rule holds even if the next character is not a space!
1258 * - If the first character is not a quote, then quotes have no special
1259 * meaning either and the executable path stops at the first space.
1260 * - The consecutive quotes rules don't apply either.
1261 * - Even if there is no space between the executable path and the first
1262 * argument, the latter is parsed using the regular rules.
1263 */
1264 {"exe\"file\"path arg1",
1265 {"exe\"file\"path", "arg1", NULL}, 0},
1266
1267 {"exe\"file\"path\targ1",
1268 {"exe\"file\"path", "arg1", NULL}, 0},
1269
1270 {"exe\"path\\ arg1",
1271 {"exe\"path\\", "arg1", NULL}, 0},
1272
1273 {"\\\"exe \"arg one\"",
1274 {"\\\"exe", "arg one", NULL}, 0},
1275
1276 {"\"spaced exe\" \"next arg\"",
1277 {"spaced exe", "next arg", NULL}, 0},
1278
1279 {"\"spaced exe\"\t\"next arg\"",
1280 {"spaced exe", "next arg", NULL}, 0},
1281
1282 {"\"exe\"arg\" one\" argtwo",
1283 {"exe", "arg one", "argtwo", NULL}, 0},
1284
1285 {"\"spaced exe\\\"arg1 arg2",
1286 {"spaced exe\\", "arg1", "arg2", NULL}, 0},
1287
1288 {"\"two\"\" arg1 ",
1289 {"two", " arg1 ", NULL}, 0},
1290
1291 {"\"three\"\"\" arg2",
1292 {"three", "", "arg2", NULL}, 0},
1293
1294 {"\"four\"\"\"\"arg1",
1295 {"four", "\"arg1", NULL}, 0},
1296
1297 /* If the first character is a space then the executable path is empty */
1298 {" \"arg\"one argtwo",
1299 {"", "argone", "argtwo", NULL}, 0},
1300
1301 {NULL, {NULL}, 0}
1302 };
1303
1304 static BOOL test_one_cmdline(const cmdline_tests_t* test)
1305 {
1306 WCHAR cmdW[MAX_PATH], argW[MAX_PATH];
1307 LPWSTR *cl2a;
1308 int cl2a_count;
1309 LPWSTR *argsW;
1310 int i, count;
1311
1312 /* trace("----- cmd='%s'\n", test->cmd); */
1313 MultiByteToWideChar(CP_ACP, 0, test->cmd, -1, cmdW, sizeof(cmdW)/sizeof(*cmdW));
1314 argsW = cl2a = CommandLineToArgvW(cmdW, &cl2a_count);
1315 if (argsW == NULL && cl2a_count == -1)
1316 {
1317 win_skip("CommandLineToArgvW not implemented, skipping\n");
1318 return FALSE;
1319 }
1320 ok(!argsW[cl2a_count] || broken(argsW[cl2a_count] != NULL) /* before Vista */,
1321 "expected NULL-terminated list of commandline arguments\n");
1322
1323 count = 0;
1324 while (test->args[count])
1325 count++;
1326 todo_wine_if(test->todo & 0x1)
1327 ok(cl2a_count == count, "%s: expected %d arguments, but got %d\n", test->cmd, count, cl2a_count);
1328
1329 for (i = 0; i < cl2a_count; i++)
1330 {
1331 if (i < count)
1332 {
1333 MultiByteToWideChar(CP_ACP, 0, test->args[i], -1, argW, sizeof(argW)/sizeof(*argW));
1334 todo_wine_if(test->todo & (1 << (i+4)))
1335 ok(!lstrcmpW(*argsW, argW), "%s: arg[%d] expected %s but got %s\n", test->cmd, i, wine_dbgstr_w(argW), wine_dbgstr_w(*argsW));
1336 }
1337 else todo_wine_if(test->todo & 0x1)
1338 ok(0, "%s: got extra arg[%d]=%s\n", test->cmd, i, wine_dbgstr_w(*argsW));
1339 argsW++;
1340 }
1341 LocalFree(cl2a);
1342 return TRUE;
1343 }
1344
1345 static void test_commandline2argv(void)
1346 {
1347 static const WCHAR exeW[] = {'e','x','e',0};
1348 const cmdline_tests_t* test;
1349 WCHAR strW[MAX_PATH];
1350 LPWSTR *args;
1351 int numargs;
1352 DWORD le;
1353
1354 test = cmdline_tests;
1355 while (test->cmd)
1356 {
1357 if (!test_one_cmdline(test))
1358 return;
1359 test++;
1360 }
1361
1362 SetLastError(0xdeadbeef);
1363 args = CommandLineToArgvW(exeW, NULL);
1364 le = GetLastError();
1365 ok(args == NULL && le == ERROR_INVALID_PARAMETER, "expected NULL with ERROR_INVALID_PARAMETER got %p with %u\n", args, le);
1366
1367 SetLastError(0xdeadbeef);
1368 args = CommandLineToArgvW(NULL, NULL);
1369 le = GetLastError();
1370 ok(args == NULL && le == ERROR_INVALID_PARAMETER, "expected NULL with ERROR_INVALID_PARAMETER got %p with %u\n", args, le);
1371
1372 *strW = 0;
1373 args = CommandLineToArgvW(strW, &numargs);
1374 ok(numargs == 1 || broken(numargs > 1), "expected 1 args, got %d\n", numargs);
1375 ok(!args || (!args[numargs] || broken(args[numargs] != NULL) /* before Vista */),
1376 "expected NULL-terminated list of commandline arguments\n");
1377 if (numargs == 1)
1378 {
1379 GetModuleFileNameW(NULL, strW, sizeof(strW)/sizeof(*strW));
1380 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));
1381 }
1382 if (args) LocalFree(args);
1383 }
1384
1385 /* The goal here is to analyze how ShellExecute() builds the command that
1386 * will be run. The tricky part is that there are three transformation
1387 * steps between the 'parameters' string we pass to ShellExecute() and the
1388 * argument list we observe in the child process:
1389 * - The parsing of 'parameters' string into individual arguments. The tests
1390 * show this is done differently from both CreateProcess() and
1391 * CommandLineToArgv()!
1392 * - The way the command 'formatting directives' such as %1, %2, etc are
1393 * handled.
1394 * - And the way the resulting command line is then parsed to yield the
1395 * argument list we check.
1396 */
1397 typedef struct
1398 {
1399 const char* verb;
1400 const char* params;
1401 int todo;
1402 cmdline_tests_t cmd;
1403 cmdline_tests_t broken;
1404 } argify_tests_t;
1405
1406 static const argify_tests_t argify_tests[] =
1407 {
1408 /* Start with three simple parameters. Notice that one can reorder and
1409 * duplicate the parameters. Also notice how %* take the raw input
1410 * parameters string, including the trailing spaces, no matter what
1411 * arguments have already been used.
1412 */
1413 {"Params232S", "p2 p3 p4 ", 0xc2,
1414 {" p2 p3 \"p2\" \"p2 p3 p4 \"",
1415 {"", "p2", "p3", "p2", "p2 p3 p4 ", NULL}, 0}},
1416
1417 /* Unquoted argument references like %2 don't automatically quote their
1418 * argument. Similarly, when they are quoted they don't escape the quotes
1419 * that their argument may contain.
1420 */
1421 {"Params232S", "\"p two\" p3 p4 ", 0x3f3,
1422 {" p two p3 \"p two\" \"\"p two\" p3 p4 \"",
1423 {"", "p", "two", "p3", "p two", "p", "two p3 p4 ", NULL}, 0}},
1424
1425 /* Only single digits are supported so only %1 to %9. Shown here with %20
1426 * because %10 is a pain.
1427 */
1428 {"Params20", "p", 0,
1429 {" \"p0\"",
1430 {"", "p0", NULL}, 0}},
1431
1432 /* Only (double-)quotes have a special meaning. */
1433 {"Params23456", "'p2 p3` p4\\ $even", 0x40,
1434 {" \"'p2\" \"p3`\" \"p4\\\" \"$even\" \"\"",
1435 {"", "'p2", "p3`", "p4\" $even \"", NULL}, 0}},
1436
1437 {"Params23456", "p=2 p-3 p4\tp4\rp4\np4", 0x1c2,
1438 {" \"p=2\" \"p-3\" \"p4\tp4\rp4\np4\" \"\" \"\"",
1439 {"", "p=2", "p-3", "p4\tp4\rp4\np4", "", "", NULL}, 0}},
1440
1441 /* In unquoted strings, quotes are treated are a parameter separator just
1442 * like spaces! However they can be doubled to get a literal quote.
1443 * Specifically:
1444 * 2n quotes -> n quotes
1445 * 2n+1 quotes -> n quotes and a parameter separator
1446 */
1447 {"Params23456789", "one\"quote \"p four\" one\"quote p7", 0xff3,
1448 {" \"one\" \"quote\" \"p four\" \"one\" \"quote\" \"p7\" \"\" \"\"",
1449 {"", "one", "quote", "p four", "one", "quote", "p7", "", "", NULL}, 0}},
1450
1451 {"Params23456789", "two\"\"quotes \"p three\" two\"\"quotes p5", 0xf2,
1452 {" \"two\"quotes\" \"p three\" \"two\"quotes\" \"p5\" \"\" \"\" \"\" \"\"",
1453 {"", "twoquotes p", "three twoquotes", "p5", "", "", "", "", NULL}, 0}},
1454
1455 {"Params23456789", "three\"\"\"quotes \"p four\" three\"\"\"quotes p6", 0xff3,
1456 {" \"three\"\" \"quotes\" \"p four\" \"three\"\" \"quotes\" \"p6\" \"\" \"\"",
1457 {"", "three\"", "quotes", "p four", "three\"", "quotes", "p6", "", "", NULL}, 0}},
1458
1459 {"Params23456789", "four\"\"\"\"quotes \"p three\" four\"\"\"\"quotes p5", 0xf3,
1460 {" \"four\"\"quotes\" \"p three\" \"four\"\"quotes\" \"p5\" \"\" \"\" \"\" \"\"",
1461 {"", "four\"quotes p", "three fourquotes p5 \"", "", "", "", NULL}, 0}},
1462
1463 /* Quoted strings cannot be continued by tacking on a non space character
1464 * either.
1465 */
1466 {"Params23456", "\"p two\"p3 \"p four\"p5 p6", 0x1f3,
1467 {" \"p two\" \"p3\" \"p four\" \"p5\" \"p6\"",
1468 {"", "p two", "p3", "p four", "p5", "p6", NULL}, 0}},
1469
1470 /* In quoted strings, the quotes are halved and an odd number closes the
1471 * string. Specifically:
1472 * 2n quotes -> n quotes
1473 * 2n+1 quotes -> n quotes and closes the string and hence the parameter
1474 */
1475 {"Params23456789", "\"one q\"uote \"p four\" \"one q\"uote p7", 0xff3,
1476 {" \"one q\" \"uote\" \"p four\" \"one q\" \"uote\" \"p7\" \"\" \"\"",
1477 {"", "one q", "uote", "p four", "one q", "uote", "p7", "", "", NULL}, 0}},
1478
1479 {"Params23456789", "\"two \"\" quotes\" \"p three\" \"two \"\" quotes\" p5", 0x1ff3,
1480 {" \"two \" quotes\" \"p three\" \"two \" quotes\" \"p5\" \"\" \"\" \"\" \"\"",
1481 {"", "two ", "quotes p", "three two", " quotes", "p5", "", "", "", "", NULL}, 0}},
1482
1483 {"Params23456789", "\"three q\"\"\"uotes \"p four\" \"three q\"\"\"uotes p7", 0xff3,
1484 {" \"three q\"\" \"uotes\" \"p four\" \"three q\"\" \"uotes\" \"p7\" \"\" \"\"",
1485 {"", "three q\"", "uotes", "p four", "three q\"", "uotes", "p7", "", "", NULL}, 0}},
1486
1487 {"Params23456789", "\"four \"\"\"\" quotes\" \"p three\" \"four \"\"\"\" quotes\" p5", 0xff3,
1488 {" \"four \"\" quotes\" \"p three\" \"four \"\" quotes\" \"p5\" \"\" \"\" \"\" \"\"",
1489 {"", "four \"", "quotes p", "three four", "", "quotes p5 \"", "", "", "", NULL}, 0}},
1490
1491 /* The quoted string rules also apply to consecutive quotes at the start
1492 * of a parameter but don't count the opening quote!
1493 */
1494 {"Params23456789", "\"\"twoquotes \"p four\" \"\"twoquotes p7", 0xbf3,
1495 {" \"\" \"twoquotes\" \"p four\" \"\" \"twoquotes\" \"p7\" \"\" \"\"",
1496 {"", "", "twoquotes", "p four", "", "twoquotes", "p7", "", "", NULL}, 0}},
1497
1498 {"Params23456789", "\"\"\"three quotes\" \"p three\" \"\"\"three quotes\" p5", 0x6f3,
1499 {" \"\"three quotes\" \"p three\" \"\"three quotes\" \"p5\" \"\" \"\" \"\" \"\"",
1500 {"", "three", "quotes p", "three \"three", "quotes p5 \"", "", "", "", NULL}, 0}},
1501
1502 {"Params23456789", "\"\"\"\"fourquotes \"p four\" \"\"\"\"fourquotes p7", 0xbf3,
1503 {" \"\"\" \"fourquotes\" \"p four\" \"\"\" \"fourquotes\" \"p7\" \"\" \"\"",
1504 {"", "\"", "fourquotes", "p four", "\"", "fourquotes", "p7", "", "", NULL}, 0}},
1505
1506 /* An unclosed quoted string gets lost! */
1507 {"Params23456", "p2 \"p3\" \"p4 is lost", 0x1c3,
1508 {" \"p2\" \"p3\" \"\" \"\" \"\"",
1509 {"", "p2", "p3", "", "", "", NULL}, 0},
1510 {" \"p2\" \"p3\" \"p3\" \"\" \"\"",
1511 {"", "p2", "p3", "p3", "", "", NULL}, 0}},
1512
1513 /* Backslashes have no special meaning even when preceding quotes. All
1514 * they do is start an unquoted string.
1515 */
1516 {"Params23456", "\\\"p\\three \"pfour\\\" pfive", 0x73,
1517 {" \"\\\" \"p\\three\" \"pfour\\\" \"pfive\" \"\"",
1518 {"", "\" p\\three pfour\"", "pfive", "", NULL}, 0}},
1519
1520 /* Environment variables are left untouched. */
1521 {"Params23456", "%TMPDIR% %t %c", 0,
1522 {" \"%TMPDIR%\" \"%t\" \"%c\" \"\" \"\"",
1523 {"", "%TMPDIR%", "%t", "%c", "", "", NULL}, 0}},
1524
1525 /* %~2 is equivalent to %*. However %~3 and higher include the spaces
1526 * before the parameter!
1527 * (but not the previous parameter's closing quote fortunately)
1528 */
1529 {"Params2345Etc", "p2 p3 \"p4\" p5 p6 ", 0x3f3,
1530 {" ~2=\"p2 p3 \"p4\" p5 p6 \" ~3=\" p3 \"p4\" p5 p6 \" ~4=\" \"p4\" p5 p6 \" ~5= p5 p6 ",
1531 {"", "~2=p2 p3 p4 p5 p6 ", "~3= p3 p4 p5 p6 ", "~4= p4 p5 p6 ", "~5=", "p5", "p6", NULL}, 0}},
1532
1533 /* %~n works even if there is no nth parameter. */
1534 {"Params9Etc", "p2 p3 p4 p5 p6 p7 p8 ", 0x12,
1535 {" ~9=\" \"",
1536 {"", "~9= ", NULL}, 0}},
1537
1538 {"Params9Etc", "p2 p3 p4 p5 p6 p7 ", 0x12,
1539 {" ~9=\"\"",
1540 {"", "~9=", NULL}, 0}},
1541
1542 /* The %~n directives also transmit the tenth parameter and beyond. */
1543 {"Params9Etc", "p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 and beyond!", 0x12,
1544 {" ~9=\" p9 p10 p11 and beyond!\"",
1545 {"", "~9= p9 p10 p11 and beyond!", NULL}, 0}},
1546
1547 /* Bad formatting directives lose their % sign, except those followed by
1548 * a tilde! Environment variables are not expanded but lose their % sign.
1549 */
1550 {"ParamsBad", "p2 p3 p4 p5", 0x12,
1551 {" \"% - %~ %~0 %~1 %~a %~* a b c TMPDIR\"",
1552 {"", "% - %~ %~0 %~1 %~a %~* a b c TMPDIR", NULL}, 0}},
1553
1554 {NULL, NULL, 0, {NULL, {NULL}, 0}}
1555 };
1556
1557 static void test_argify(void)
1558 {
1559 BOOL has_cl2a = TRUE;
1560 char fileA[MAX_PATH], params[2*MAX_PATH+12];
1561 INT_PTR rc;
1562 const argify_tests_t* test;
1563 const cmdline_tests_t *bad;
1564 const char* cmd;
1565 unsigned i, count;
1566
1567 /* Test with a long parameter */
1568 for (rc = 0; rc < MAX_PATH; rc++)
1569 fileA[rc] = 'a' + rc % 26;
1570 fileA[MAX_PATH-1] = '\0';
1571 sprintf(params, "shlexec \"%s\" %s", child_file, fileA);
1572
1573 /* We need NOZONECHECKS on Win2003 to block a dialog */
1574 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params, NULL, NULL);
1575 okShell(rc > 32, "failed: rc=%lu\n", rc);
1576 okChildInt("argcA", 4);
1577 okChildPath("argvA3", fileA);
1578
1579 if (skip_shlexec_tests)
1580 {
1581 skip("No argify tests due to lack of .shlexec association\n");
1582 return;
1583 }
1584
1585 create_test_verb("shlexec.shlexec", "Params232S", 0, "Params232S %2 %3 \"%2\" \"%*\"");
1586 create_test_verb("shlexec.shlexec", "Params23456", 0, "Params23456 \"%2\" \"%3\" \"%4\" \"%5\" \"%6\"");
1587 create_test_verb("shlexec.shlexec", "Params23456789", 0, "Params23456789 \"%2\" \"%3\" \"%4\" \"%5\" \"%6\" \"%7\" \"%8\" \"%9\"");
1588 create_test_verb("shlexec.shlexec", "Params2345Etc", 0, "Params2345Etc ~2=\"%~2\" ~3=\"%~3\" ~4=\"%~4\" ~5=%~5");
1589 create_test_verb("shlexec.shlexec", "Params9Etc", 0, "Params9Etc ~9=\"%~9\"");
1590 create_test_verb("shlexec.shlexec", "Params20", 0, "Params20 \"%20\"");
1591 create_test_verb("shlexec.shlexec", "ParamsBad", 0, "ParamsBad \"%% %- %~ %~0 %~1 %~a %~* %a %b %c %TMPDIR%\"");
1592
1593 sprintf(fileA, "%s\\test file.shlexec", tmpdir);
1594
1595 test = argify_tests;
1596 while (test->params)
1597 {
1598 bad = test->broken.cmd ? &test->broken : &test->cmd;
1599
1600 /* trace("***** verb='%s' params='%s'\n", test->verb, test->params); */
1601 rc = shell_execute_ex(SEE_MASK_DOENVSUBST, test->verb, fileA, test->params, NULL, NULL);
1602 okShell(rc > 32, "failed: rc=%lu\n", rc);
1603
1604 count = 0;
1605 while (test->cmd.args[count])
1606 count++;
1607 /* +4 for the shlexec arguments, -1 because of the added ""
1608 * argument for the CommandLineToArgvW() tests.
1609 */
1610 todo_wine_if(test->todo & 0x1)
1611 okChildInt("argcA", 4 + count - 1);
1612
1613 cmd = getChildString("Child", "cmdlineA");
1614 /* Our commands are such that the verb immediately precedes the
1615 * part we are interested in.
1616 */
1617 if (cmd) cmd = strstr(cmd, test->verb);
1618 if (cmd) cmd += strlen(test->verb);
1619 if (!cmd) cmd = "(null)";
1620 todo_wine_if(test->todo & 0x2)
1621 okShell(!strcmp(cmd, test->cmd.cmd) || broken(!strcmp(cmd, bad->cmd)),
1622 "the cmdline is '%s' instead of '%s'\n", cmd, test->cmd.cmd);
1623
1624 for (i = 0; i < count - 1; i++)
1625 {
1626 char argname[18];
1627 sprintf(argname, "argvA%d", 4 + i);
1628 todo_wine_if(test->todo & (1 << (i+4)))
1629 okChildStringBroken(argname, test->cmd.args[i+1], bad->args[i+1]);
1630 }
1631
1632 if (has_cl2a)
1633 has_cl2a = test_one_cmdline(&(test->cmd));
1634 test++;
1635 }
1636 }
1637
1638 static void test_filename(void)
1639 {
1640 char filename[MAX_PATH];
1641 const filename_tests_t* test;
1642 char* c;
1643 INT_PTR rc;
1644
1645 if (skip_shlexec_tests)
1646 {
1647 skip("No ShellExecute/filename tests due to lack of .shlexec association\n");
1648 return;
1649 }
1650
1651 test=filename_tests;
1652 while (test->basename)
1653 {
1654 BOOL quotedfile = FALSE;
1655
1656 if (skip_noassoc_tests && test->rc == SE_ERR_NOASSOC)
1657 {
1658 win_skip("Skipping shellexecute of file with unassociated extension\n");
1659 test++;
1660 continue;
1661 }
1662
1663 sprintf(filename, test->basename, tmpdir);
1664 if (strchr(filename, '/'))
1665 {
1666 c=filename;
1667 while (*c)
1668 {
1669 if (*c=='\\')
1670 *c='/';
1671 c++;
1672 }
1673 }
1674 if ((test->todo & 0x40)==0)
1675 {
1676 rc=shell_execute(test->verb, filename, NULL, NULL);
1677 }
1678 else
1679 {
1680 char quoted[MAX_PATH + 2];
1681
1682 quotedfile = TRUE;
1683 sprintf(quoted, "\"%s\"", filename);
1684 rc=shell_execute(test->verb, quoted, NULL, NULL);
1685 }
1686 if (rc > 32)
1687 rc=33;
1688 okShell(rc==test->rc ||
1689 broken(quotedfile && rc == SE_ERR_FNF), /* NT4 */
1690 "failed: rc=%ld err=%u\n", rc, GetLastError());
1691 if (rc == 33)
1692 {
1693 const char* verb;
1694 todo_wine_if(test->todo & 0x2)
1695 okChildInt("argcA", 5);
1696 verb=(test->verb ? test->verb : "Open");
1697 todo_wine_if(test->todo & 0x4)
1698 okChildString("argvA3", verb);
1699 todo_wine_if(test->todo & 0x8)
1700 okChildPath("argvA4", filename);
1701 }
1702 test++;
1703 }
1704
1705 test=noquotes_tests;
1706 while (test->basename)
1707 {
1708 sprintf(filename, test->basename, tmpdir);
1709 rc=shell_execute(test->verb, filename, NULL, NULL);
1710 if (rc > 32)
1711 rc=33;
1712 todo_wine_if(test->todo & 0x1)
1713 okShell(rc==test->rc, "failed: rc=%ld err=%u\n", rc, GetLastError());
1714 if (rc==0)
1715 {
1716 int count;
1717 const char* verb;
1718 char* str;
1719
1720 verb=(test->verb ? test->verb : "Open");
1721 todo_wine_if(test->todo & 0x4)
1722 okChildString("argvA3", verb);
1723
1724 count=4;
1725 str=filename;
1726 while (1)
1727 {
1728 char attrib[18];
1729 char* space;
1730 space=strchr(str, ' ');
1731 if (space)
1732 *space='\0';
1733 sprintf(attrib, "argvA%d", count);
1734 todo_wine_if(test->todo & 0x8)
1735 okChildPath(attrib, str);
1736 count++;
1737 if (!space)
1738 break;
1739 str=space+1;
1740 }
1741 todo_wine_if(test->todo & 0x2)
1742 okChildInt("argcA", count);
1743 }
1744 test++;
1745 }
1746
1747 if (dllver.dwMajorVersion != 0)
1748 {
1749 /* The more recent versions of shell32.dll accept quoted filenames
1750 * while older ones (e.g. 4.00) don't. Still we want to test this
1751 * because IE 6 depends on the new behavior.
1752 * One day we may need to check the exact version of the dll but for
1753 * now making sure DllGetVersion() is present is sufficient.
1754 */
1755 sprintf(filename, "\"%s\\test file.shlexec\"", tmpdir);
1756 rc=shell_execute(NULL, filename, NULL, NULL);
1757 okShell(rc > 32, "failed: rc=%ld err=%u\n", rc, GetLastError());
1758 okChildInt("argcA", 5);
1759 okChildString("argvA3", "Open");
1760 sprintf(filename, "%s\\test file.shlexec", tmpdir);
1761 okChildPath("argvA4", filename);
1762 }
1763
1764 sprintf(filename, "\"%s\\test file.sha\"", tmpdir);
1765 rc=shell_execute(NULL, filename, NULL, NULL);
1766 todo_wine okShell(rc > 32, "failed: rc=%ld err=%u\n", rc, GetLastError());
1767 okChildInt("argcA", 5);
1768 todo_wine okChildString("argvA3", "averb");
1769 sprintf(filename, "%s\\test file.sha", tmpdir);
1770 todo_wine okChildPath("argvA4", filename);
1771 }
1772
1773 typedef struct
1774 {
1775 const char* urlprefix;
1776 const char* basename;
1777 int flags;
1778 int todo;
1779 } fileurl_tests_t;
1780
1781 #define URL_SUCCESS 0x1
1782 #define USE_COLON 0x2
1783 #define USE_BSLASH 0x4
1784
1785 static fileurl_tests_t fileurl_tests[]=
1786 {
1787 /* How many slashes does it take... */
1788 {"file:", "%s\\test file.shlexec", URL_SUCCESS, 0},
1789 {"file:/", "%s\\test file.shlexec", URL_SUCCESS, 0},
1790 {"file://", "%s\\test file.shlexec", URL_SUCCESS, 0},
1791 {"file:///", "%s\\test file.shlexec", URL_SUCCESS, 0},
1792 {"File:///", "%s\\test file.shlexec", URL_SUCCESS, 0},
1793 {"file:////", "%s\\test file.shlexec", URL_SUCCESS, 0},
1794 {"file://///", "%s\\test file.shlexec", 0, 0},
1795
1796 /* Test with Windows-style paths */
1797 {"file:///", "%s\\test file.shlexec", URL_SUCCESS | USE_COLON, 0},
1798 {"file:///", "%s\\test file.shlexec", URL_SUCCESS | USE_BSLASH, 0},
1799
1800 /* Check handling of hostnames */
1801 {"file://localhost/", "%s\\test file.shlexec", URL_SUCCESS, 0},
1802 {"file://localhost:80/", "%s\\test file.shlexec", 0, 0},
1803 {"file://LocalHost/", "%s\\test file.shlexec", URL_SUCCESS, 0},
1804 {"file://127.0.0.1/", "%s\\test file.shlexec", 0, 0},
1805 {"file://::1/", "%s\\test file.shlexec", 0, 0},
1806 {"file://notahost/", "%s\\test file.shlexec", 0, 0},
1807
1808 /* Environment variables are not expanded in URLs */
1809 {"%urlprefix%", "%s\\test file.shlexec", 0, 0x1},
1810 {"file:///", "%%TMPDIR%%\\test file.shlexec", 0, 0},
1811
1812 /* Test shortcuts vs. URLs */
1813 {"file://///", "%s\\test_shortcut_shlexec.lnk", 0, 0x1c},
1814
1815 /* Confuse things by mixing protocols */
1816 {"file://", "shlproto://foo/bar", USE_COLON, 0},
1817
1818 {NULL, NULL, 0, 0}
1819 };
1820
1821 static void test_fileurls(void)
1822 {
1823 char filename[MAX_PATH], fileurl[MAX_PATH], longtmpdir[MAX_PATH];
1824 char command[MAX_PATH];
1825 const fileurl_tests_t* test;
1826 char *s;
1827 INT_PTR rc;
1828
1829 if (skip_shlexec_tests)
1830 {
1831 skip("No file URL tests due to lack of .shlexec association\n");
1832 return;
1833 }
1834
1835 rc = shell_execute_ex(SEE_MASK_FLAG_NO_UI, NULL,
1836 "file:///nosuchfile.shlexec", NULL, NULL, NULL);
1837 if (rc > 32)
1838 {
1839 win_skip("shell32 is too old (likely < 4.72). Skipping the file URL tests\n");
1840 return;
1841 }
1842
1843 get_long_path_name(tmpdir, longtmpdir, sizeof(longtmpdir)/sizeof(*longtmpdir));
1844 SetEnvironmentVariableA("urlprefix", "file:///");
1845
1846 test=fileurl_tests;
1847 while (test->basename)
1848 {
1849 /* Build the file URL */
1850 sprintf(filename, test->basename, longtmpdir);
1851 strcpy(fileurl, test->urlprefix);
1852 strcat(fileurl, filename);
1853 s = fileurl + strlen(test->urlprefix);
1854 while (*s)
1855 {
1856 if (!(test->flags & USE_COLON) && *s == ':')
1857 *s = '|';
1858 else if (!(test->flags & USE_BSLASH) && *s == '\\')
1859 *s = '/';
1860 s++;
1861 }
1862
1863 /* Test it first with FindExecutable() */
1864 rc = (INT_PTR)FindExecutableA(fileurl, NULL, command);
1865 ok(rc == SE_ERR_FNF, "FindExecutable(%s) failed: bad rc=%lu\n", fileurl, rc);
1866
1867 /* Then ShellExecute() */
1868 if ((test->todo & 0x10) == 0)
1869 rc = shell_execute(NULL, fileurl, NULL, NULL);
1870 else todo_wait
1871 rc = shell_execute(NULL, fileurl, NULL, NULL);
1872 if (bad_shellexecute)
1873 {
1874 win_skip("shell32 is too old (likely 4.72). Skipping the file URL tests\n");
1875 break;
1876 }
1877 if (test->flags & URL_SUCCESS)
1878 {
1879 todo_wine_if(test->todo & 0x1)
1880 okShell(rc > 32, "failed: bad rc=%lu\n", rc);
1881 }
1882 else
1883 {
1884 todo_wine_if(test->todo & 0x1)
1885 okShell(rc == SE_ERR_FNF || rc == SE_ERR_PNF ||
1886 broken(rc == SE_ERR_ACCESSDENIED) /* win2000 */,
1887 "failed: bad rc=%lu\n", rc);
1888 }
1889 if (rc == 33)
1890 {
1891 todo_wine_if(test->todo & 0x2)
1892 okChildInt("argcA", 5);
1893 todo_wine_if(test->todo & 0x4)
1894 okChildString("argvA3", "Open");
1895 todo_wine_if(test->todo & 0x8)
1896 okChildPath("argvA4", filename);
1897 }
1898 test++;
1899 }
1900
1901 SetEnvironmentVariableA("urlprefix", NULL);
1902 }
1903
1904 static void test_urls(void)
1905 {
1906 char url[MAX_PATH];
1907 INT_PTR rc;
1908
1909 if (!create_test_class("fakeproto", FALSE))
1910 {
1911 skip("Unable to create 'fakeproto' class for URL tests\n");
1912 return;
1913 }
1914 create_test_verb("fakeproto", "open", 0, "URL %1");
1915
1916 create_test_class("shlpaverb", TRUE);
1917 create_test_verb("shlpaverb", "averb", 0, "PAVerb \"%1\"");
1918
1919 /* Protocols must be properly declared */
1920 rc = shell_execute(NULL, "notaproto://foo", NULL, NULL);
1921 ok(rc == SE_ERR_NOASSOC || broken(rc == SE_ERR_ACCESSDENIED),
1922 "%s returned %lu\n", shell_call, rc);
1923
1924 rc = shell_execute(NULL, "fakeproto://foo/bar", NULL, NULL);
1925 todo_wine ok(rc == SE_ERR_NOASSOC || broken(rc == SE_ERR_ACCESSDENIED),
1926 "%s returned %lu\n", shell_call, rc);
1927
1928 /* Here's a real live one */
1929 rc = shell_execute(NULL, "shlproto://foo/bar", NULL, NULL);
1930 ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc);
1931 okChildInt("argcA", 5);
1932 okChildString("argvA3", "URL");
1933 okChildString("argvA4", "shlproto://foo/bar");
1934
1935 /* Check default verb detection */
1936 rc = shell_execute(NULL, "shlpaverb://foo/bar", NULL, NULL);
1937 todo_wine ok(rc > 32 || /* XP+IE7 - Win10 */
1938 broken(rc == SE_ERR_NOASSOC), /* XP+IE6 */
1939 "%s failed: rc=%lu\n", shell_call, rc);
1940 if (rc > 32)
1941 {
1942 okChildInt("argcA", 5);
1943 todo_wine okChildString("argvA3", "PAVerb");
1944 todo_wine okChildString("argvA4", "shlpaverb://foo/bar");
1945 }
1946
1947 /* But alternative verbs are a recent feature! */
1948 rc = shell_execute("averb", "shlproto://foo/bar", NULL, NULL);
1949 ok(rc > 32 || /* Win8 - Win10 */
1950 broken(rc == SE_ERR_ACCESSDENIED), /* XP - Win7 */
1951 "%s failed: rc=%lu\n", shell_call, rc);
1952 if (rc > 32)
1953 {
1954 okChildString("argvA3", "AVerb");
1955 okChildString("argvA4", "shlproto://foo/bar");
1956 }
1957
1958 /* A .lnk ending does not turn a URL into a shortcut */
1959 rc = shell_execute(NULL, "shlproto://foo/bar.lnk", NULL, NULL);
1960 ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc);
1961 okChildInt("argcA", 5);
1962 okChildString("argvA3", "URL");
1963 okChildString("argvA4", "shlproto://foo/bar.lnk");
1964
1965 /* Neither does a .exe extension */
1966 rc = shell_execute(NULL, "shlproto://foo/bar.exe", NULL, NULL);
1967 ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc);
1968 okChildInt("argcA", 5);
1969 okChildString("argvA3", "URL");
1970 okChildString("argvA4", "shlproto://foo/bar.exe");
1971
1972 /* But a class name overrides it */
1973 rc = shell_execute(NULL, "shlproto://foo/bar", "shlexec.shlexec", NULL);
1974 ok(rc > 32, "%s failed: rc=%lu\n", shell_call, rc);
1975 okChildInt("argcA", 5);
1976 okChildString("argvA3", "URL");
1977 okChildString("argvA4", "shlproto://foo/bar");
1978
1979 /* Environment variables are expanded in URLs (but not in file URLs!) */
1980 rc = shell_execute_ex(SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI,
1981 NULL, "shlproto://%TMPDIR%/bar", NULL, NULL, NULL);
1982 okShell(rc > 32, "failed: rc=%lu\n", rc);
1983 okChildInt("argcA", 5);
1984 sprintf(url, "shlproto://%s/bar", tmpdir);
1985 okChildString("argvA3", "URL");
1986 okChildStringBroken("argvA4", url, "shlproto://%TMPDIR%/bar");
1987
1988 /* But only after the path has been identified as a URL */
1989 SetEnvironmentVariableA("urlprefix", "shlproto:///");
1990 rc = shell_execute(NULL, "%urlprefix%foo", NULL, NULL);
1991 todo_wine ok(rc == SE_ERR_FNF, "%s returned %lu\n", shell_call, rc);
1992 SetEnvironmentVariableA("urlprefix", NULL);
1993
1994 delete_test_class("fakeproto");
1995 delete_test_class("shlpaverb");
1996 }
1997
1998 static void test_find_executable(void)
1999 {
2000 char notepad_path[MAX_PATH];
2001 char filename[MAX_PATH];
2002 char command[MAX_PATH];
2003 const filename_tests_t* test;
2004 INT_PTR rc;
2005
2006 if (!create_test_association(".sfe"))
2007 {
2008 skip("Unable to create association for '.sfe'\n");
2009 return;
2010 }
2011 create_test_verb("shlexec.sfe", "Open", 1, "%1");
2012
2013 /* Don't test FindExecutable(..., NULL), it always crashes */
2014
2015 strcpy(command, "your word");
2016 if (0) /* Can crash on Vista! */
2017 {
2018 rc=(INT_PTR)FindExecutableA(NULL, NULL, command);
2019 ok(rc == SE_ERR_FNF || rc > 32 /* nt4 */, "FindExecutable(NULL) returned %ld\n", rc);
2020 ok(strcmp(command, "your word") != 0, "FindExecutable(NULL) returned command=[%s]\n", command);
2021 }
2022
2023 GetSystemDirectoryA( notepad_path, MAX_PATH );
2024 strcat( notepad_path, "\\notepad.exe" );
2025
2026 /* Search for something that should be in the system-wide search path (no default directory) */
2027 strcpy(command, "your word");
2028 rc=(INT_PTR)FindExecutableA("notepad.exe", NULL, command);
2029 ok(rc > 32, "FindExecutable(%s) returned %ld\n", "notepad.exe", rc);
2030 ok(strcasecmp(command, notepad_path) == 0, "FindExecutable(%s) returned command=[%s]\n", "notepad.exe", command);
2031
2032 /* Search for something that should be in the system-wide search path (with default directory) */
2033 strcpy(command, "your word");
2034 rc=(INT_PTR)FindExecutableA("notepad.exe", tmpdir, command);
2035 ok(rc > 32, "FindExecutable(%s) returned %ld\n", "notepad.exe", rc);
2036 ok(strcasecmp(command, notepad_path) == 0, "FindExecutable(%s) returned command=[%s]\n", "notepad.exe", command);
2037
2038 strcpy(command, "your word");
2039 rc=(INT_PTR)FindExecutableA(tmpdir, NULL, command);
2040 ok(rc == SE_ERR_NOASSOC /* >= win2000 */ || rc > 32 /* win98, nt4 */, "FindExecutable(NULL) returned %ld\n", rc);
2041 ok(strcmp(command, "your word") != 0, "FindExecutable(NULL) returned command=[%s]\n", command);
2042
2043 sprintf(filename, "%s\\test file.sfe", tmpdir);
2044 rc=(INT_PTR)FindExecutableA(filename, NULL, command);
2045 ok(rc > 32, "FindExecutable(%s) returned %ld\n", filename, rc);
2046 /* Depending on the platform, command could be '%1' or 'test file.sfe' */
2047
2048 rc=(INT_PTR)FindExecutableA("test file.sfe", tmpdir, command);
2049 ok(rc > 32, "FindExecutable(%s) returned %ld\n", filename, rc);
2050
2051 rc=(INT_PTR)FindExecutableA("test file.sfe", NULL, command);
2052 ok(rc == SE_ERR_FNF, "FindExecutable(%s) returned %ld\n", filename, rc);
2053
2054 delete_test_association(".sfe");
2055
2056 if (!create_test_association(".shl"))
2057 {
2058 skip("Unable to create association for '.shl'\n");
2059 return;
2060 }
2061 create_test_verb("shlexec.shl", "Open", 0, "Open");
2062
2063 sprintf(filename, "%s\\test file.shl", tmpdir);
2064 rc=(INT_PTR)FindExecutableA(filename, NULL, command);
2065 ok(rc == SE_ERR_FNF /* NT4 */ || rc > 32, "FindExecutable(%s) returned %ld\n", filename, rc);
2066
2067 sprintf(filename, "%s\\test file.shlfoo", tmpdir);
2068 rc=(INT_PTR)FindExecutableA(filename, NULL, command);
2069
2070 delete_test_association(".shl");
2071
2072 if (rc > 32)
2073 {
2074 /* On Windows XP and 2003 FindExecutable() is completely broken.
2075 * Probably what it does is convert the filename to 8.3 format,
2076 * which as a side effect converts the '.shlfoo' extension to '.shl',
2077 * and then tries to find an association for '.shl'. This means it
2078 * will normally fail on most extensions with more than 3 characters,
2079 * like '.mpeg', etc.
2080 * Also it means we cannot do any other test.
2081 */
2082 win_skip("FindExecutable() is broken -> not running 4+ character extension tests\n");
2083 return;
2084 }
2085
2086 if (skip_shlexec_tests)
2087 {
2088 skip("No FindExecutable/filename tests due to lack of .shlexec association\n");
2089 return;
2090 }
2091
2092 test=filename_tests;
2093 while (test->basename)
2094 {
2095 sprintf(filename, test->basename, tmpdir);
2096 if (strchr(filename, '/'))
2097 {
2098 char* c;
2099 c=filename;
2100 while (*c)
2101 {
2102 if (*c=='\\')
2103 *c='/';
2104 c++;
2105 }
2106 }
2107 /* Win98 does not '\0'-terminate command! */
2108 memset(command, '\0', sizeof(command));
2109 rc=(INT_PTR)FindExecutableA(filename, NULL, command);
2110 if (rc > 32)
2111 rc=33;
2112 todo_wine_if(test->todo & 0x10)
2113 ok(rc==test->rc, "FindExecutable(%s) failed: rc=%ld\n", filename, rc);
2114 if (rc > 32)
2115 {
2116 BOOL equal;
2117 equal=strcmp(command, argv0) == 0 ||
2118 /* NT4 returns an extra 0x8 character! */
2119 (strlen(command) == strlen(argv0)+1 && strncmp(command, argv0, strlen(argv0)) == 0);
2120 todo_wine_if(test->todo & 0x20)
2121 ok(equal, "FindExecutable(%s) returned command='%s' instead of '%s'\n",
2122 filename, command, argv0);
2123 }
2124 test++;
2125 }
2126 }
2127
2128
2129 static filename_tests_t lnk_tests[]=
2130 {
2131 /* Pass bad / nonexistent filenames as a parameter */
2132 {NULL, "%s\\nonexistent.shlexec", 0xa, 33},
2133 {NULL, "%s\\nonexistent.noassoc", 0xa, 33},
2134
2135 /* Pass regular paths as a parameter */
2136 {NULL, "%s\\test file.shlexec", 0xa, 33},
2137 {NULL, "%s/%%nasty%% $file.shlexec", 0xa, 33},
2138
2139 /* Pass filenames with no association as a parameter */
2140 {NULL, "%s\\test file.noassoc", 0xa, 33},
2141
2142 {NULL, NULL, 0}
2143 };
2144
2145 static void test_lnks(void)
2146 {
2147 char filename[MAX_PATH];
2148 char params[MAX_PATH];
2149 const filename_tests_t* test;
2150 INT_PTR rc;
2151
2152 if (skip_shlexec_tests)
2153 skip("No FindExecutable/filename tests due to lack of .shlexec association\n");
2154 else
2155 {
2156 /* Should open through our association */
2157 sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
2158 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, NULL);
2159 okShell(rc > 32, "failed: rc=%lu err=%u\n", rc, GetLastError());
2160 okChildInt("argcA", 5);
2161 okChildString("argvA3", "Open");
2162 sprintf(params, "%s\\test file.shlexec", tmpdir);
2163 get_long_path_name(params, filename, sizeof(filename));
2164 okChildPath("argvA4", filename);
2165
2166 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_DOENVSUBST, NULL, "%TMPDIR%\\test_shortcut_shlexec.lnk", NULL, NULL, NULL);
2167 okShell(rc > 32, "failed: rc=%lu err=%u\n", rc, GetLastError());
2168 okChildInt("argcA", 5);
2169 okChildString("argvA3", "Open");
2170 sprintf(params, "%s\\test file.shlexec", tmpdir);
2171 get_long_path_name(params, filename, sizeof(filename));
2172 okChildPath("argvA4", filename);
2173 }
2174
2175 /* Should just run our executable */
2176 sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
2177 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, NULL);
2178 okShell(rc > 32, "failed: rc=%lu err=%u\n", rc, GetLastError());
2179 okChildInt("argcA", 4);
2180 okChildString("argvA3", "Lnk");
2181
2182 if (!skip_shlexec_tests)
2183 {
2184 /* An explicit class overrides lnk's ContextMenuHandler */
2185 rc=shell_execute_ex(SEE_MASK_CLASSNAME | SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, "shlexec.shlexec");
2186 okShell(rc > 32, "failed: rc=%lu err=%u\n", rc, GetLastError());
2187 okChildInt("argcA", 5);
2188 okChildString("argvA3", "Open");
2189 okChildPath("argvA4", filename);
2190 }
2191
2192 if (dllver.dwMajorVersion>=6)
2193 {
2194 char* c;
2195 /* Recent versions of shell32.dll accept '/'s in shortcut paths.
2196 * Older versions don't or are quite buggy in this regard.
2197 */
2198 sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
2199 c=filename;
2200 while (*c)
2201 {
2202 if (*c=='\\')
2203 *c='/';
2204 c++;
2205 }
2206 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, NULL, NULL, NULL);
2207 okShell(rc > 32, "failed: rc=%lu err=%u\n", rc, GetLastError());
2208 okChildInt("argcA", 4);
2209 okChildString("argvA3", "Lnk");
2210 }
2211
2212 sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
2213 test=lnk_tests;
2214 while (test->basename)
2215 {
2216 params[0]='\"';
2217 sprintf(params+1, test->basename, tmpdir);
2218 strcat(params,"\"");
2219 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, filename, params,
2220 NULL, NULL);
2221 if (rc > 32)
2222 rc=33;
2223 todo_wine_if(test->todo & 0x1)
2224 okShell(rc==test->rc, "failed: rc=%lu err=%u\n", rc, GetLastError());
2225 if (rc==0)
2226 {
2227 todo_wine_if(test->todo & 0x2)
2228 okChildInt("argcA", 5);
2229 todo_wine_if(test->todo & 0x4)
2230 okChildString("argvA3", "Lnk");
2231 sprintf(params, test->basename, tmpdir);
2232 okChildPath("argvA4", params);
2233 }
2234 test++;
2235 }
2236 }
2237
2238
2239 static void test_exes(void)
2240 {
2241 char filename[MAX_PATH];
2242 char params[1024];
2243 INT_PTR rc;
2244
2245 sprintf(params, "shlexec \"%s\" Exec", child_file);
2246
2247 /* We need NOZONECHECKS on Win2003 to block a dialog */
2248 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS, NULL, argv0, params,
2249 NULL, NULL);
2250 okShell(rc > 32, "returned %lu\n", rc);
2251 okChildInt("argcA", 4);
2252 okChildString("argvA3", "Exec");
2253
2254 if (! skip_noassoc_tests)
2255 {
2256 sprintf(filename, "%s\\test file.noassoc", tmpdir);
2257 if (CopyFileA(argv0, filename, FALSE))
2258 {
2259 rc=shell_execute(NULL, filename, params, NULL);
2260 todo_wine {
2261 okShell(rc==SE_ERR_NOASSOC, "returned %lu\n", rc);
2262 }
2263 }
2264 }
2265 else
2266 {
2267 win_skip("Skipping shellexecute of file with unassociated extension\n");
2268 }
2269
2270 /* test combining executable and parameters */
2271 sprintf(filename, "%s shlexec \"%s\" Exec", argv0, child_file);
2272 rc = shell_execute(NULL, filename, NULL, NULL);
2273 okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
2274
2275 sprintf(filename, "\"%s\" shlexec \"%s\" Exec", argv0, child_file);
2276 rc = shell_execute(NULL, filename, NULL, NULL);
2277 okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
2278
2279 /* A verb, even if invalid, overrides the normal handling of executables */
2280 todo_wait rc = shell_execute_ex(SEE_MASK_FLAG_NO_UI,
2281 "notaverb", argv0, NULL, NULL, NULL);
2282 todo_wine okShell(rc == SE_ERR_NOASSOC, "returned %lu\n", rc);
2283
2284 if (!skip_shlexec_tests)
2285 {
2286 /* A class overrides the normal handling of executables too */
2287 /* FIXME SEE_MASK_FLAG_NO_UI is only needed due to Wine's bug */
2288 rc = shell_execute_ex(SEE_MASK_CLASSNAME | SEE_MASK_FLAG_NO_UI,
2289 NULL, argv0, NULL, NULL, ".shlexec");
2290 todo_wine okShell(rc > 32, "returned %lu\n", rc);
2291 okChildInt("argcA", 5);
2292 todo_wine okChildString("argvA3", "Open");
2293 todo_wine okChildPath("argvA4", argv0);
2294 }
2295 }
2296
2297 typedef struct
2298 {
2299 const char* command;
2300 const char* ddeexec;
2301 const char* application;
2302 const char* topic;
2303 const char* ifexec;
2304 int expectedArgs;
2305 const char* expectedDdeExec;
2306 BOOL broken;
2307 } dde_tests_t;
2308
2309 static dde_tests_t dde_tests[] =
2310 {
2311 /* Test passing and not passing command-line
2312 * argument, no DDE */
2313 {"", NULL, NULL, NULL, NULL, 0, ""},
2314 {"\"%1\"", NULL, NULL, NULL, NULL, 1, ""},
2315
2316 /* Test passing and not passing command-line
2317 * argument, with DDE */
2318 {"", "[open(\"%1\")]", "shlexec", "dde", NULL, 0, "[open(\"%s\")]"},
2319 {"\"%1\"", "[open(\"%1\")]", "shlexec", "dde", NULL, 1, "[open(\"%s\")]"},
2320
2321 /* Test unquoted %1 in command and ddeexec
2322 * (test filename has space) */
2323 {"%1", "[open(%1)]", "shlexec", "dde", NULL, 2, "[open(%s)]", TRUE /* before vista */},
2324
2325 /* Test ifexec precedence over ddeexec */
2326 {"", "[open(\"%1\")]", "shlexec", "dde", "[ifexec(\"%1\")]", 0, "[ifexec(\"%s\")]"},
2327
2328 /* Test default DDE topic */
2329 {"", "[open(\"%1\")]", "shlexec", NULL, NULL, 0, "[open(\"%s\")]"},
2330
2331 /* Test default DDE application */
2332 {"", "[open(\"%1\")]", NULL, "dde", NULL, 0, "[open(\"%s\")]"},
2333
2334 {NULL}
2335 };
2336
2337 static int waitforinputidle_count;
2338 static DWORD WINAPI hooked_WaitForInputIdle(HANDLE process, DWORD timeout)
2339 {
2340 waitforinputidle_count++;
2341 if (winetest_debug > 1)
2342 trace("WaitForInputIdle() waiting for dde event timeout=min(%u,5s)\n", timeout);
2343 timeout = timeout < 5000 ? timeout : 5000;
2344 return WaitForSingleObject(dde_ready_event, timeout);
2345 }
2346
2347 /*
2348 * WaitForInputIdle() will normally return immediately for console apps. That's
2349 * a problem for us because ShellExecute will assume that an app is ready to
2350 * receive DDE messages after it has called WaitForInputIdle() on that app.
2351 * To work around that we install our own version of WaitForInputIdle() that
2352 * will wait for the child to explicitly tell us that it is ready. We do that
2353 * by changing the entry for WaitForInputIdle() in the shell32 import address
2354 * table.
2355 */
2356 static void hook_WaitForInputIdle(DWORD (WINAPI *new_func)(HANDLE, DWORD))
2357 {
2358 char *base;
2359 PIMAGE_NT_HEADERS nt_headers;
2360 DWORD import_directory_rva;
2361 PIMAGE_IMPORT_DESCRIPTOR import_descriptor;
2362 int hook_count = 0;
2363
2364 base = (char *) GetModuleHandleA("shell32.dll");
2365 nt_headers = (PIMAGE_NT_HEADERS)(base + ((PIMAGE_DOS_HEADER) base)->e_lfanew);
2366 import_directory_rva = nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
2367
2368 /* Search for the correct imported module by walking the import descriptors */
2369 import_descriptor = (PIMAGE_IMPORT_DESCRIPTOR)(base + import_directory_rva);
2370 while (U(*import_descriptor).OriginalFirstThunk != 0)
2371 {
2372 char *import_module_name;
2373
2374 import_module_name = base + import_descriptor->Name;
2375 if (lstrcmpiA(import_module_name, "user32.dll") == 0 ||
2376 lstrcmpiA(import_module_name, "user32") == 0)
2377 {
2378 PIMAGE_THUNK_DATA int_entry;
2379 PIMAGE_THUNK_DATA iat_entry;
2380
2381 /* The import name table and import address table are two parallel
2382 * arrays. We need the import name table to find the imported
2383 * routine and the import address table to patch the address, so
2384 * walk them side by side */
2385 int_entry = (PIMAGE_THUNK_DATA)(base + U(*import_descriptor).OriginalFirstThunk);
2386 iat_entry = (PIMAGE_THUNK_DATA)(base + import_descriptor->FirstThunk);
2387 while (int_entry->u1.Ordinal != 0)
2388 {
2389 if (! IMAGE_SNAP_BY_ORDINAL(int_entry->u1.Ordinal))
2390 {
2391 PIMAGE_IMPORT_BY_NAME import_by_name;
2392 import_by_name = (PIMAGE_IMPORT_BY_NAME)(base + int_entry->u1.AddressOfData);
2393 if (lstrcmpA((char *) import_by_name->Name, "WaitForInputIdle") == 0)
2394 {
2395 /* Found the correct routine in the correct imported module. Patch it. */
2396 DWORD old_prot;
2397 VirtualProtect(&iat_entry->u1.Function, sizeof(ULONG_PTR), PAGE_READWRITE, &old_prot);
2398 iat_entry->u1.Function = (ULONG_PTR) new_func;
2399 VirtualProtect(&iat_entry->u1.Function, sizeof(ULONG_PTR), old_prot, &old_prot);
2400 if (winetest_debug > 1)
2401 trace("Hooked %s.WaitForInputIdle\n", import_module_name);
2402 hook_count++;
2403 break;
2404 }
2405 }
2406 int_entry++;
2407 iat_entry++;
2408 }
2409 break;
2410 }
2411
2412 import_descriptor++;
2413 }
2414 ok(hook_count, "Could not hook WaitForInputIdle()\n");
2415 }
2416
2417 static void test_dde(void)
2418 {
2419 char filename[MAX_PATH], defApplication[MAX_PATH];
2420 const dde_tests_t* test;
2421 char params[1024];
2422 INT_PTR rc;
2423 HANDLE map;
2424 char *shared_block;
2425 DWORD ddeflags;
2426
2427 hook_WaitForInputIdle(hooked_WaitForInputIdle);
2428
2429 sprintf(filename, "%s\\test file.sde", tmpdir);
2430
2431 /* Default service is application name minus path and extension */
2432 strcpy(defApplication, strrchr(argv0, '\\')+1);
2433 *strchr(defApplication, '.') = 0;
2434
2435 map = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
2436 4096, "winetest_shlexec_dde_map");
2437 shared_block = MapViewOfFile(map, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 4096);
2438
2439 ddeflags = SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI;
2440 test = dde_tests;
2441 while (test->command)
2442 {
2443 if (!create_test_association(".sde"))
2444 {
2445 skip("Unable to create association for '.sde'\n");
2446 return;
2447 }
2448 create_test_verb_dde("shlexec.sde", "Open", 0, test->command, test->ddeexec,
2449 test->application, test->topic, test->ifexec);
2450
2451 if (test->application != NULL || test->topic != NULL)
2452 {
2453 strcpy(shared_block, test->application ? test->application : defApplication);
2454 strcpy(shared_block + strlen(shared_block) + 1, test->topic ? test->topic : SZDDESYS_TOPIC);
2455 }
2456 else
2457 {
2458 shared_block[0] = '\0';
2459 shared_block[1] = '\0';
2460 }
2461 ddeExec[0] = 0;
2462
2463 waitforinputidle_count = 0;
2464 dde_ready_event = CreateEventA(NULL, TRUE, FALSE, "winetest_shlexec_dde_ready");
2465 rc = shell_execute_ex(ddeflags, NULL, filename, NULL, NULL, NULL);
2466 CloseHandle(dde_ready_event);
2467 if (!(ddeflags & SEE_MASK_WAITFORINPUTIDLE) && rc == SE_ERR_DDEFAIL &&
2468 GetLastError() == ERROR_FILE_NOT_FOUND &&
2469 strcmp(winetest_platform, "windows") == 0)
2470 {
2471 /* Windows 10 does not call WaitForInputIdle() for DDE which creates
2472 * a race condition as the DDE server may not have time to start up.
2473 * When that happens the test fails with the above results and we
2474 * compensate by forcing the WaitForInputIdle() call.
2475 */
2476 trace("Adding SEE_MASK_WAITFORINPUTIDLE for Windows 10\n");
2477 ddeflags |= SEE_MASK_WAITFORINPUTIDLE;
2478 delete_test_association(".sde");
2479 Sleep(CHILD_DDE_TIMEOUT);
2480 continue;
2481 }
2482 okShell(32 < rc, "failed: rc=%lu err=%u\n", rc, GetLastError());
2483 if (test->ddeexec)
2484 okShell(waitforinputidle_count == 1 ||
2485 broken(waitforinputidle_count == 0) /* Win10 race */,
2486 "WaitForInputIdle() was called %u times\n",
2487 waitforinputidle_count);
2488 else
2489 okShell(waitforinputidle_count == 0, "WaitForInputIdle() was called %u times for a non-DDE case\n", waitforinputidle_count);
2490
2491 if (32 < rc)
2492 {
2493 if (test->broken)
2494 okChildIntBroken("argcA", test->expectedArgs + 3);
2495 else
2496 okChildInt("argcA", test->expectedArgs + 3);
2497
2498 if (test->expectedArgs == 1) okChildPath("argvA3", filename);
2499
2500 sprintf(params, test->expectedDdeExec, filename);
2501 okChildPath("ddeExec", params);
2502 }
2503 reset_association_description();
2504
2505 delete_test_association(".sde");
2506 test++;
2507 }
2508
2509 UnmapViewOfFile(shared_block);
2510 CloseHandle(map);
2511 hook_WaitForInputIdle((void *) WaitForInputIdle);
2512 }
2513
2514 #define DDE_DEFAULT_APP_VARIANTS 3
2515 typedef struct
2516 {
2517 const char* command;
2518 const char* expectedDdeApplication[DDE_DEFAULT_APP_VARIANTS];
2519 int todo;
2520 int rc[DDE_DEFAULT_APP_VARIANTS];
2521 } dde_default_app_tests_t;
2522
2523 static dde_default_app_tests_t dde_default_app_tests[] =
2524 {
2525 /* There are three possible sets of results: Windows <= 2000, XP SP1 and
2526 * >= XP SP2. Use the first two tests to determine which results to expect.
2527 */
2528
2529 /* Test unquoted existing filename with a space */
2530 {"%s\\test file.exe", {"test file", "test file", "test"}, 0x0, {33, 33, 33}},
2531 {"%s\\test2 file.exe", {"test2", "", "test2"}, 0x0, {33, 5, 33}},
2532
2533 /* Test unquoted existing filename with a space */
2534 {"%s\\test file.exe param", {"test file", "test file", "test"}, 0x0, {33, 33, 33}},
2535
2536 /* Test quoted existing filename with a space */
2537 {"\"%s\\test file.exe\"", {"test file", "test file", "test file"}, 0x0, {33, 33, 33}},
2538 {"\"%s\\test file.exe\" param", {"test file", "test file", "test file"}, 0x0, {33, 33, 33}},
2539
2540 /* Test unquoted filename with a space that doesn't exist, but
2541 * test2.exe does */
2542 {"%s\\test2 file.exe param", {"test2", "", "test2"}, 0x0, {33, 5, 33}},
2543
2544 /* Test quoted filename with a space that does not exist */
2545 {"\"%s\\test2 file.exe\"", {"", "", "test2 file"}, 0x0, {5, 2, 33}},
2546 {"\"%s\\test2 file.exe\" param", {"", "", "test2 file"}, 0x0, {5, 2, 33}},
2547
2548 /* Test filename supplied without the extension */
2549 {"%s\\test2", {"test2", "", "test2"}, 0x0, {33, 5, 33}},
2550 {"%s\\test2 param", {"test2", "", "test2"}, 0x0, {33, 5, 33}},
2551
2552 /* Test an unquoted nonexistent filename */
2553 {"%s\\notexist.exe", {"", "", "notexist"}, 0x0, {5, 2, 33}},
2554 {"%s\\notexist.exe param", {"", "", "notexist"}, 0x0, {5, 2, 33}},
2555
2556 /* Test an application that will be found on the path */
2557 {"cmd", {"cmd", "cmd", "cmd"}, 0x0, {33, 33, 33}},
2558 {"cmd param", {"cmd", "cmd", "cmd"}, 0x0, {33, 33, 33}},
2559
2560 /* Test an application that will not be found on the path */
2561 {"xyzwxyzwxyz", {"", "", "xyzwxyzwxyz"}, 0x0, {5, 2, 33}},
2562 {"xyzwxyzwxyz param", {"", "", "xyzwxyzwxyz"}, 0x0, {5, 2, 33}},
2563
2564 {NULL, {NULL}, 0, {0}}
2565 };
2566
2567 typedef struct
2568 {
2569 char *filename;
2570 DWORD threadIdParent;
2571 } dde_thread_info_t;
2572
2573 static DWORD CALLBACK ddeThread(LPVOID arg)
2574 {
2575 dde_thread_info_t *info = arg;
2576 assert(info && info->filename);
2577 PostThreadMessageA(info->threadIdParent,
2578 WM_QUIT,
2579 shell_execute_ex(SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI, NULL, info->filename, NULL, NULL, NULL),
2580 0);
2581 ExitThread(0);
2582 }
2583
2584 static void test_dde_default_app(void)
2585 {
2586 char filename[MAX_PATH];
2587 HSZ hszApplication;
2588 dde_thread_info_t info = { filename, GetCurrentThreadId() };
2589 const dde_default_app_tests_t* test;
2590 char params[1024];
2591 DWORD threadId;
2592 MSG msg;
2593 INT_PTR rc;
2594 int which = 0;
2595 HDDEDATA ret;
2596 BOOL b;
2597
2598 post_quit_on_execute = FALSE;
2599 ddeInst = 0;
2600 rc = DdeInitializeA(&ddeInst, ddeCb, CBF_SKIP_ALLNOTIFICATIONS | CBF_FAIL_ADVISES |
2601 CBF_FAIL_POKES | CBF_FAIL_REQUESTS, 0);
2602 ok(rc == DMLERR_NO_ERROR, "got %lx\n", rc);
2603
2604 sprintf(filename, "%s\\test file.sde", tmpdir);
2605
2606 /* It is strictly not necessary to register an application name here, but wine's
2607 * DdeNameService implementation complains if 0 is passed instead of
2608 * hszApplication with DNS_FILTEROFF */
2609 hszApplication = DdeCreateStringHandleA(ddeInst, "shlexec", CP_WINANSI);
2610 hszTopic = DdeCreateStringHandleA(ddeInst, "shlexec", CP_WINANSI);
2611 ok(hszApplication && hszTopic, "got %p and %p\n", hszApplication, hszTopic);
2612 ret = DdeNameService(ddeInst, hszApplication, 0, DNS_REGISTER | DNS_FILTEROFF);
2613 ok(ret != 0, "got %p\n", ret);
2614
2615 test = dde_default_app_tests;
2616 while (test->command)
2617 {
2618 HANDLE thread;
2619
2620 if (!create_test_association(".sde"))
2621 {
2622 skip("Unable to create association for '.sde'\n");
2623 return;
2624 }
2625 sprintf(params, test->command, tmpdir);
2626 create_test_verb_dde("shlexec.sde", "Open", 1, params, "[test]", NULL,
2627 "shlexec", NULL);
2628 ddeApplication[0] = 0;
2629
2630 /* No application will be run as we will respond to the first DDE event,
2631 * so don't wait for it */
2632 SetEvent(hEvent);
2633
2634 thread = CreateThread(NULL, 0, ddeThread, &info, 0, &threadId);
2635 ok(thread != NULL, "got %p\n", thread);
2636 while (GetMessageA(&msg, NULL, 0, 0)) DispatchMessageA(&msg);
2637 rc = msg.wParam > 32 ? 33 : msg.wParam;
2638
2639 /* The first two tests determine which set of results to expect.
2640 * First check the platform as only the first set of results is
2641 * acceptable for Wine.
2642 */
2643 if (strcmp(winetest_platform, "wine"))
2644 {
2645 if (test == dde_default_app_tests)
2646 {
2647 if (strcmp(ddeApplication, test->expectedDdeApplication[0]))
2648 which = 2;
2649 }
2650 else if (test == dde_default_app_tests + 1)
2651 {
2652 if (which == 0 && rc == test->rc[1])
2653 which = 1;
2654 trace("DDE result variant %d\n", which);
2655 }
2656 }
2657
2658 todo_wine_if(test->todo & 0x1)
2659 okShell(rc==test->rc[which], "failed: rc=%lu err=%u\n",
2660 rc, GetLastError());
2661 if (rc == 33)
2662 {
2663 todo_wine_if(test->todo & 0x2)
2664 ok(!strcmp(ddeApplication, test->expectedDdeApplication[which]),
2665 "Expected application '%s', got '%s'\n",
2666 test->expectedDdeApplication[which], ddeApplication);
2667 }
2668 reset_association_description();
2669
2670 delete_test_association(".sde");
2671 test++;
2672 }
2673
2674 ret = DdeNameService(ddeInst, hszApplication, 0, DNS_UNREGISTER);
2675 ok(ret != 0, "got %p\n", ret);
2676 b = DdeFreeStringHandle(ddeInst, hszTopic);
2677 ok(b, "got %d\n", b);
2678 b = DdeFreeStringHandle(ddeInst, hszApplication);
2679 ok(b, "got %d\n", b);
2680 b = DdeUninitialize(ddeInst);
2681 ok(b, "got %d\n", b);
2682 }
2683
2684 static void init_test(void)
2685 {
2686 HMODULE hdll;
2687 HRESULT (WINAPI *pDllGetVersion)(DLLVERSIONINFO*);
2688 char filename[MAX_PATH];
2689 WCHAR lnkfile[MAX_PATH];
2690 char params[1024];
2691 const char* const * testfile;
2692 lnk_desc_t desc;
2693 DWORD rc;
2694 HRESULT r;
2695
2696 hdll=GetModuleHandleA("shell32.dll");
2697 pDllGetVersion=(void*)GetProcAddress(hdll, "DllGetVersion");
2698 if (pDllGetVersion)
2699 {
2700 dllver.cbSize=sizeof(dllver);
2701 pDllGetVersion(&dllver);
2702 trace("major=%d minor=%d build=%d platform=%d\n",
2703 dllver.dwMajorVersion, dllver.dwMinorVersion,
2704 dllver.dwBuildNumber, dllver.dwPlatformID);
2705 }
2706 else
2707 {
2708 memset(&dllver, 0, sizeof(dllver));
2709 }
2710
2711 r = CoInitialize(NULL);
2712 ok(r == S_OK, "CoInitialize failed (0x%08x)\n", r);
2713 if (FAILED(r))
2714 exit(1);
2715
2716 rc=GetModuleFileNameA(NULL, argv0, sizeof(argv0));
2717 ok(rc != 0 && rc < sizeof(argv0), "got %d\n", rc);
2718 if (GetFileAttributesA(argv0)==INVALID_FILE_ATTRIBUTES)
2719 {
2720 strcat(argv0, ".so");
2721 ok(GetFileAttributesA(argv0)!=INVALID_FILE_ATTRIBUTES,
2722 "unable to find argv0!\n");
2723 }
2724
2725 /* Older versions (win 2k) fail tests if there is a space in
2726 the path. */
2727 if (dllver.dwMajorVersion <= 5)
2728 strcpy(filename, "c:\\");
2729 else
2730 GetTempPathA(sizeof(filename), filename);
2731 GetTempFileNameA(filename, "wt", 0, tmpdir);
2732 GetLongPathNameA(tmpdir, tmpdir, sizeof(tmpdir));
2733 DeleteFileA( tmpdir );
2734 rc = CreateDirectoryA( tmpdir, NULL );
2735 ok( rc, "failed to create %s err %u\n", tmpdir, GetLastError() );
2736 /* Set %TMPDIR% for the tests */
2737 SetEnvironmentVariableA("TMPDIR", tmpdir);
2738
2739 rc = GetTempFileNameA(tmpdir, "wt", 0, child_file);
2740 ok(rc != 0, "got %d\n", rc);
2741 init_event(child_file);
2742
2743 /* Set up the test files */
2744 testfile=testfiles;
2745 while (*testfile)
2746 {
2747 HANDLE hfile;
2748
2749 sprintf(filename, *testfile, tmpdir);
2750 hfile=CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2751 FILE_ATTRIBUTE_NORMAL, NULL);
2752 if (hfile==INVALID_HANDLE_VALUE)
2753 {
2754 trace("unable to create '%s': err=%u\n", filename, GetLastError());
2755 assert(0);
2756 }
2757 CloseHandle(hfile);
2758 testfile++;
2759 }
2760
2761 /* Setup the test shortcuts */
2762 sprintf(filename, "%s\\test_shortcut_shlexec.lnk", tmpdir);
2763 MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
2764 desc.description=NULL;
2765 desc.workdir=NULL;
2766 sprintf(filename, "%s\\test file.shlexec", tmpdir);
2767 desc.path=filename;
2768 desc.pidl=NULL;
2769 desc.arguments="ignored";
2770 desc.showcmd=0;
2771 desc.icon=NULL;
2772 desc.icon_id=0;
2773 desc.hotkey=0;
2774 create_lnk(lnkfile, &desc, 0);
2775
2776 sprintf(filename, "%s\\test_shortcut_exe.lnk", tmpdir);
2777 MultiByteToWideChar(CP_ACP, 0, filename, -1, lnkfile, sizeof(lnkfile)/sizeof(*lnkfile));
2778 desc.description=NULL;
2779 desc.workdir=NULL;
2780 desc.path=argv0;
2781 desc.pidl=NULL;
2782 sprintf(params, "shlexec \"%s\" Lnk", child_file);
2783 desc.arguments=params;
2784 desc.showcmd=0;
2785 desc.icon=NULL;
2786 desc.icon_id=0;
2787 desc.hotkey=0;
2788 create_lnk(lnkfile, &desc, 0);
2789
2790 /* Create a basic association suitable for most tests */
2791 if (!create_test_association(".shlexec"))
2792 {
2793 skip_shlexec_tests = TRUE;
2794 skip("Unable to create association for '.shlexec'\n");
2795 return;
2796 }
2797 create_test_verb("shlexec.shlexec", "Open", 0, "Open \"%1\"");
2798 create_test_verb("shlexec.shlexec", "NoQuotes", 0, "NoQuotes %1");
2799 create_test_verb("shlexec.shlexec", "LowerL", 0, "LowerL %l");
2800 create_test_verb("shlexec.shlexec", "QuotedLowerL", 0, "QuotedLowerL \"%l\"");
2801 create_test_verb("shlexec.shlexec", "UpperL", 0, "UpperL %L");
2802 create_test_verb("shlexec.shlexec", "QuotedUpperL", 0, "QuotedUpperL \"%L\"");
2803
2804 create_test_association(".sha");
2805 create_test_verb("shlexec.sha", "averb", 0, "AVerb \"%1\"");
2806
2807 create_test_class("shlproto", TRUE);
2808 create_test_verb("shlproto", "open", 0, "URL \"%1\"");
2809 create_test_verb("shlproto", "averb", 0, "AVerb \"%1\"");
2810
2811 /* Set an environment variable to see if it is inherited */
2812 SetEnvironmentVariableA("ShlexecVar", "Present");
2813 }
2814
2815 static void cleanup_test(void)
2816 {
2817 char filename[MAX_PATH];
2818 const char* const * testfile;
2819
2820 /* Delete the test files */
2821 testfile=testfiles;
2822 while (*testfile)
2823 {
2824 sprintf(filename, *testfile, tmpdir);
2825 /* Make sure we can delete the files ('test file.noassoc' is read-only now) */
2826 SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL);
2827 DeleteFileA(filename);
2828 testfile++;
2829 }
2830 DeleteFileA(child_file);
2831 RemoveDirectoryA(tmpdir);
2832
2833 /* Delete the test association */
2834 delete_test_association(".shlexec");
2835 delete_test_association(".sha");
2836 delete_test_class("shlproto");
2837
2838 CloseHandle(hEvent);
2839
2840 CoUninitialize();
2841 }
2842
2843 static void test_directory(void)
2844 {
2845 char path[MAX_PATH], curdir[MAX_PATH];
2846 char params[1024], dirpath[1024];
2847 INT_PTR rc;
2848
2849 sprintf(path, "%s\\test2.exe", tmpdir);
2850 CopyFileA(argv0, path, FALSE);
2851
2852 sprintf(params, "shlexec \"%s\" Exec", child_file);
2853
2854 /* Test with the current directory */
2855 GetCurrentDirectoryA(sizeof(curdir), curdir);
2856 SetCurrentDirectoryA(tmpdir);
2857 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI,
2858 NULL, "test2.exe", params, NULL, NULL);
2859 okShell(rc > 32, "returned %lu\n", rc);
2860 okChildInt("argcA", 4);
2861 okChildString("argvA3", "Exec");
2862 todo_wine okChildPath("longPath", path);
2863 SetCurrentDirectoryA(curdir);
2864
2865 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI,
2866 NULL, "test2.exe", params, NULL, NULL);
2867 okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
2868
2869 /* Explicitly specify the directory to use */
2870 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI,
2871 NULL, "test2.exe", params, tmpdir, NULL);
2872 okShell(rc > 32, "returned %lu\n", rc);
2873 okChildInt("argcA", 4);
2874 okChildString("argvA3", "Exec");
2875 todo_wine okChildPath("longPath", path);
2876
2877 /* Specify it through an environment variable */
2878 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI,
2879 NULL, "test2.exe", params, "%TMPDIR%", NULL);
2880 todo_wine okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
2881
2882 rc=shell_execute_ex(SEE_MASK_DOENVSUBST|SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI,
2883 NULL, "test2.exe", params, "%TMPDIR%", NULL);
2884 okShell(rc > 32, "returned %lu\n", rc);
2885 okChildInt("argcA", 4);
2886 okChildString("argvA3", "Exec");
2887 todo_wine okChildPath("longPath", path);
2888
2889 /* Not a colon-separated directory list */
2890 sprintf(dirpath, "%s:%s", curdir, tmpdir);
2891 rc=shell_execute_ex(SEE_MASK_NOZONECHECKS|SEE_MASK_FLAG_NO_UI,
2892 NULL, "test2.exe", params, dirpath, NULL);
2893 okShell(rc == SE_ERR_FNF, "returned %lu\n", rc);
2894 }
2895
2896 START_TEST(shlexec)
2897 {
2898
2899 myARGC = winetest_get_mainargs(&myARGV);
2900 if (myARGC >= 3)
2901 {
2902 doChild(myARGC, myARGV);
2903 /* Skip the tests/failures trace for child processes */
2904 ExitProcess(winetest_get_failures());
2905 }
2906
2907 init_test();
2908
2909 test_commandline2argv();
2910 test_argify();
2911 test_lpFile_parsed();
2912 test_filename();
2913 test_fileurls();
2914 test_urls();
2915 test_find_executable();
2916 test_lnks();
2917 test_exes();
2918 test_dde();
2919 test_dde_default_app();
2920 test_directory();
2921
2922 cleanup_test();
2923 }
A free Windows-compatible Operating System