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