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