350ad7da0da6a2b12344bb31f70042a777971784
[reactos.git] / reactos / lib / shell32 / shlexec.c
1 /*
2 * Shell Library Functions
3 *
4 * Copyright 1998 Marcus Meissner
5 * Copyright 2002 Eric Pouech
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <ctype.h>
33 #include <assert.h>
34
35 #define COBJMACROS
36
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winerror.h"
40 #include "winreg.h"
41 #include "winuser.h"
42 #include "shlwapi.h"
43 #include "ddeml.h"
44
45 #include "wine/winbase16.h"
46 #include "shell32_main.h"
47 #include "pidl.h"
48
49 #include "wine/debug.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(exec);
52
53 static const WCHAR wszOpen[] = {'o','p','e','n',0};
54 static const WCHAR wszExe[] = {'.','e','x','e',0};
55 static const WCHAR wszILPtr[] = {':','%','p',0};
56 static const WCHAR wszShell[] = {'\\','s','h','e','l','l','\\',0};
57 static const WCHAR wszFolder[] = {'F','o','l','d','e','r',0};
58 static const WCHAR wszEmpty[] = {0};
59
60 #define SEE_MASK_CLASSALL (SEE_MASK_CLASSNAME | SEE_MASK_CLASSKEY)
61
62
63 /***********************************************************************
64 * SHELL_ArgifyW [Internal]
65 *
66 * this function is supposed to expand the escape sequences found in the registry
67 * some diving reported that the following were used:
68 * + %1, %2... seem to report to parameter of index N in ShellExecute pmts
69 * %1 file
70 * %2 printer
71 * %3 driver
72 * %4 port
73 * %I address of a global item ID (explorer switch /idlist)
74 * %L seems to be %1 as long filename followed by the 8+3 variation
75 * %S ???
76 * %* all following parameters (see batfile)
77 *
78 * FIXME: use 'len'
79 * FIXME: Careful of going over string boundaries. No checking is done to 'res'...
80 */
81 static BOOL SHELL_ArgifyW(WCHAR* out, int len, const WCHAR* fmt, const WCHAR* lpFile, LPITEMIDLIST pidl, LPCWSTR args)
82 {
83 WCHAR xlpFile[1024];
84 BOOL done = FALSE;
85 BOOL found_p1 = FALSE;
86 PWSTR res = out;
87 PCWSTR cmd;
88 LPVOID pv;
89
90 TRACE("%p, %d, %s, %s, %p, %p\n", out, len, debugstr_w(fmt),
91 debugstr_w(lpFile), pidl, args);
92
93 while (*fmt)
94 {
95 if (*fmt == '%')
96 {
97 switch (*++fmt)
98 {
99 case '\0':
100 case '%':
101 *res++ = '%';
102 break;
103
104 case '2':
105 case '3':
106 case '4':
107 case '5':
108 case '6':
109 case '7':
110 case '8':
111 case '9':
112 case '0':
113 case '*':
114 if (args)
115 {
116 if (*fmt == '*')
117 {
118 *res++ = '"';
119 while(*args)
120 *res++ = *args++;
121 *res++ = '"';
122 }
123 else
124 {
125 while(*args && !isspace(*args))
126 *res++ = *args++;
127
128 while(isspace(*args))
129 ++args;
130 }
131 break;
132 }
133 /* else fall through */
134 case '1':
135 if (!done || (*fmt == '1'))
136 {
137 /*FIXME Is the call to SearchPathW() really needed? We already have separated out the parameter string in args. */
138 if (SearchPathW(NULL, lpFile, wszExe, sizeof(xlpFile)/sizeof(WCHAR), xlpFile, NULL))
139 cmd = xlpFile;
140 else
141 cmd = lpFile;
142
143 /* Add double quotation marks unless we already have them
144 (e.g.: "file://%1" %* for exefile) or unless the arg is already
145 enclosed in double quotation marks */
146 if ((res == out || *(fmt + 1) != '"') && *cmd != '"')
147 {
148 *res++ = '"';
149 strcpyW(res, cmd);
150 res += strlenW(cmd);
151 *res++ = '"';
152 }
153 else
154 {
155 strcpyW(res, cmd);
156 res += strlenW(cmd);
157 }
158 }
159 found_p1 = TRUE;
160 break;
161
162 /*
163 * IE uses this a lot for activating things such as windows media
164 * player. This is not verified to be fully correct but it appears
165 * to work just fine.
166 */
167 case 'l':
168 case 'L':
169 if (lpFile) {
170 strcpyW(res, lpFile);
171 res += strlenW(lpFile);
172 }
173 found_p1 = TRUE;
174 break;
175
176 case 'i':
177 case 'I':
178 if (pidl) {
179 HGLOBAL hmem = SHAllocShared(pidl, ILGetSize(pidl), 0);
180 pv = SHLockShared(hmem, 0);
181 res += sprintfW(res, wszILPtr, pv);
182 SHUnlockShared(pv);
183 }
184 found_p1 = TRUE;
185 break;
186
187 default:
188 /*
189 * Check if this is an env-variable here...
190 */
191
192 /* Make sure that we have at least one more %.*/
193 if (strchrW(fmt, '%'))
194 {
195 WCHAR tmpBuffer[1024];
196 PWSTR tmpB = tmpBuffer;
197 WCHAR tmpEnvBuff[MAX_PATH];
198 DWORD envRet;
199
200 while (*fmt != '%')
201 *tmpB++ = *fmt++;
202 *tmpB++ = 0;
203
204 TRACE("Checking %s to be an env-var\n", debugstr_w(tmpBuffer));
205
206 envRet = GetEnvironmentVariableW(tmpBuffer, tmpEnvBuff, MAX_PATH);
207 if (envRet == 0 || envRet > MAX_PATH)
208 strcpyW( res, tmpBuffer );
209 else
210 strcpyW( res, tmpEnvBuff );
211 res += strlenW(res);
212 }
213 done = TRUE;
214 break;
215 }
216 /* Don't skip past terminator (catch a single '%' at the end) */
217 if (*fmt != '\0')
218 {
219 fmt++;
220 }
221 }
222 else
223 *res++ = *fmt++;
224 }
225
226 *res = '\0';
227
228 return found_p1;
229 }
230
231 HRESULT SHELL_GetPathFromIDListForExecuteA(LPCITEMIDLIST pidl, LPSTR pszPath, UINT uOutSize)
232 {
233 STRRET strret;
234 IShellFolder* desktop;
235
236 HRESULT hr = SHGetDesktopFolder(&desktop);
237
238 if (SUCCEEDED(hr)) {
239 hr = IShellFolder_GetDisplayNameOf(desktop, pidl, SHGDN_FORPARSING, &strret);
240
241 if (SUCCEEDED(hr))
242 StrRetToStrNA(pszPath, uOutSize, &strret, pidl);
243
244 IShellFolder_Release(desktop);
245 }
246
247 return hr;
248 }
249
250 HRESULT SHELL_GetPathFromIDListForExecuteW(LPCITEMIDLIST pidl, LPWSTR pszPath, UINT uOutSize)
251 {
252 STRRET strret;
253 IShellFolder* desktop;
254
255 HRESULT hr = SHGetDesktopFolder(&desktop);
256
257 if (SUCCEEDED(hr)) {
258 hr = IShellFolder_GetDisplayNameOf(desktop, pidl, SHGDN_FORPARSING, &strret);
259
260 if (SUCCEEDED(hr))
261 StrRetToStrNW(pszPath, uOutSize, &strret, pidl);
262
263 IShellFolder_Release(desktop);
264 }
265
266 return hr;
267 }
268
269 /*************************************************************************
270 * SHELL_ExecuteW [Internal]
271 *
272 */
273 static UINT_PTR SHELL_ExecuteW(const WCHAR *lpCmd, WCHAR *env, BOOL shWait,
274 LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out)
275 {
276 STARTUPINFOW startup;
277 PROCESS_INFORMATION info;
278 UINT_PTR retval = 31;
279 UINT gcdret = 0;
280 WCHAR curdir[MAX_PATH];
281
282 TRACE("Execute %s from directory %s\n", debugstr_w(lpCmd), debugstr_w(psei->lpDirectory));
283 /* ShellExecute specifies the command from psei->lpDirectory
284 * if present. Not from the current dir as CreateProcess does */
285 if( psei->lpDirectory && psei->lpDirectory[0] )
286 if( ( gcdret = GetCurrentDirectoryW( MAX_PATH, curdir)))
287 if( !SetCurrentDirectoryW( psei->lpDirectory))
288 ERR("cannot set directory %s\n", debugstr_w(psei->lpDirectory));
289 ZeroMemory(&startup,sizeof(STARTUPINFOW));
290 startup.cb = sizeof(STARTUPINFOW);
291 startup.dwFlags = STARTF_USESHOWWINDOW;
292 startup.wShowWindow = psei->nShow;
293 if (CreateProcessW(NULL, (LPWSTR)lpCmd, NULL, NULL, FALSE, CREATE_UNICODE_ENVIRONMENT,
294 env, *psei->lpDirectory? psei->lpDirectory: NULL, &startup, &info))
295 {
296 /* Give 30 seconds to the app to come up, if desired. Probably only needed
297 when starting app immediately before making a DDE connection. */
298 if (shWait)
299 if (WaitForInputIdle( info.hProcess, 30000 ) == WAIT_FAILED)
300 WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
301 retval = 33;
302 if (psei->fMask & SEE_MASK_NOCLOSEPROCESS)
303 psei_out->hProcess = info.hProcess;
304 else
305 CloseHandle( info.hProcess );
306 CloseHandle( info.hThread );
307 }
308 else if ((retval = GetLastError()) >= 32)
309 {
310 TRACE("CreateProcess returned error %d\n", retval);
311 retval = ERROR_BAD_FORMAT;
312 }
313
314 TRACE("returning %u\n", retval);
315
316 psei_out->hInstApp = (HINSTANCE)retval;
317 if( gcdret )
318 if( !SetCurrentDirectoryW( curdir))
319 ERR("cannot return to directory %s\n", debugstr_w(curdir));
320
321 return retval;
322 }
323
324
325 /***********************************************************************
326 * SHELL_BuildEnvW [Internal]
327 *
328 * Build the environment for the new process, adding the specified
329 * path to the PATH variable. Returned pointer must be freed by caller.
330 */
331 static void *SHELL_BuildEnvW( const WCHAR *path )
332 {
333 static const WCHAR wPath[] = {'P','A','T','H','=',0};
334 WCHAR *strings, *new_env;
335 WCHAR *p, *p2;
336 int total = strlenW(path) + 1;
337 BOOL got_path = FALSE;
338
339 if (!(strings = GetEnvironmentStringsW())) return NULL;
340 p = strings;
341 while (*p)
342 {
343 int len = strlenW(p) + 1;
344 if (!strncmpiW( p, wPath, 5 )) got_path = TRUE;
345 total += len;
346 p += len;
347 }
348 if (!got_path) total += 5; /* we need to create PATH */
349 total++; /* terminating null */
350
351 if (!(new_env = HeapAlloc( GetProcessHeap(), 0, total * sizeof(WCHAR) )))
352 {
353 FreeEnvironmentStringsW( strings );
354 return NULL;
355 }
356 p = strings;
357 p2 = new_env;
358 while (*p)
359 {
360 int len = strlenW(p) + 1;
361 memcpy( p2, p, len * sizeof(WCHAR) );
362 if (!strncmpiW( p, wPath, 5 ))
363 {
364 p2[len - 1] = ';';
365 strcpyW( p2 + len, path );
366 p2 += strlenW(path) + 1;
367 }
368 p += len;
369 p2 += len;
370 }
371 if (!got_path)
372 {
373 strcpyW( p2, wPath );
374 strcatW( p2, path );
375 p2 += strlenW(p2) + 1;
376 }
377 *p2 = 0;
378 FreeEnvironmentStringsW( strings );
379 return new_env;
380 }
381
382
383 /***********************************************************************
384 * SHELL_TryAppPathW [Internal]
385 *
386 * Helper function for SHELL_FindExecutable
387 * @param lpResult - pointer to a buffer of size MAX_PATH
388 * On entry: szName is a filename (probably without path separators).
389 * On exit: if szName found in "App Path", place full path in lpResult, and return true
390 */
391 static BOOL SHELL_TryAppPathW( LPCWSTR szName, LPWSTR lpResult, WCHAR **env)
392 {
393 static const WCHAR wszKeyAppPaths[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',
394 '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','A','p','p',' ','P','a','t','h','s','\\',0};
395 static const WCHAR wPath[] = {'P','a','t','h',0};
396 HKEY hkApp = 0;
397 WCHAR buffer[1024];
398 LONG len;
399 LONG res;
400 BOOL found = FALSE;
401
402 if (env) *env = NULL;
403 strcpyW(buffer, wszKeyAppPaths);
404 strcatW(buffer, szName);
405 res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, buffer, 0, KEY_READ, &hkApp);
406 if (res) goto end;
407
408 len = MAX_PATH*sizeof(WCHAR);
409 res = RegQueryValueW(hkApp, NULL, lpResult, &len);
410 if (res) goto end;
411 found = TRUE;
412
413 if (env)
414 {
415 DWORD count = sizeof(buffer);
416 if (!RegQueryValueExW(hkApp, wPath, NULL, NULL, (LPBYTE)buffer, &count) && buffer[0])
417 *env = SHELL_BuildEnvW( buffer );
418 }
419
420 end:
421 if (hkApp) RegCloseKey(hkApp);
422 return found;
423 }
424
425 static UINT SHELL_FindExecutableByOperation(LPCWSTR lpPath, LPCWSTR lpFile, LPCWSTR lpOperation, LPWSTR key, LPWSTR filetype, LPWSTR command, LONG commandlen)
426 {
427 static const WCHAR wCommand[] = {'\\','c','o','m','m','a','n','d',0};
428
429 /* Looking for ...buffer\shell\<verb>\command */
430 strcatW(filetype, wszShell);
431 strcatW(filetype, lpOperation);
432 strcatW(filetype, wCommand);
433
434 if (RegQueryValueW(HKEY_CLASSES_ROOT, filetype, command,
435 &commandlen) == ERROR_SUCCESS)
436 {
437 commandlen /= sizeof(WCHAR);
438 if (key) strcpyW(key, filetype);
439 #if 0
440 LPWSTR tmp;
441 WCHAR param[256];
442 LONG paramlen = sizeof(param);
443 static const WCHAR wSpace[] = {' ',0};
444
445 /* FIXME: it seems all Windows version don't behave the same here.
446 * the doc states that this ddeexec information can be found after
447 * the exec names.
448 * on Win98, it doesn't appear, but I think it does on Win2k
449 */
450 /* Get the parameters needed by the application
451 from the associated ddeexec key */
452 tmp = strstrW(filetype, wCommand);
453 tmp[0] = '\0';
454 strcatW(filetype, wDdeexec);
455 if (RegQueryValueW(HKEY_CLASSES_ROOT, filetype, param,
456 &paramlen) == ERROR_SUCCESS)
457 {
458 paramlen /= sizeof(WCHAR);
459 strcatW(command, wSpace);
460 strcatW(command, param);
461 commandlen += paramlen;
462 }
463 #endif
464
465 command[commandlen] = '\0';
466
467 return 33; /* FIXME see SHELL_FindExecutable() */
468 }
469
470 return 31; /* default - 'No association was found' */
471 }
472
473 /*************************************************************************
474 * SHELL_FindExecutable [Internal]
475 *
476 * Utility for code sharing between FindExecutable and ShellExecute
477 * in:
478 * lpFile the name of a file
479 * lpOperation the operation on it (open)
480 * out:
481 * lpResult a buffer, big enough :-(, to store the command to do the
482 * operation on the file
483 * key a buffer, big enough, to get the key name to do actually the
484 * command (it'll be used afterwards for more information
485 * on the operation)
486 */
487 UINT SHELL_FindExecutable(LPCWSTR lpPath, LPCWSTR lpFile, LPCWSTR lpOperation,
488 LPWSTR lpResult, int resultLen, LPWSTR key, WCHAR **env, LPITEMIDLIST pidl, LPCWSTR args)
489 {
490 static const WCHAR wWindows[] = {'w','i','n','d','o','w','s',0};
491 static const WCHAR wPrograms[] = {'p','r','o','g','r','a','m','s',0};
492 static const WCHAR wExtensions[] = {'e','x','e',' ','p','i','f',' ','b','a','t',' ','c','m','d',' ','c','o','m',0};
493 WCHAR *extension = NULL; /* pointer to file extension */
494 WCHAR filetype[256]; /* registry name for this filetype */
495 LONG filetypelen = sizeof(filetype); /* length of above */
496 WCHAR command[1024]; /* command from registry */
497 WCHAR wBuffer[256]; /* Used to GetProfileString */
498 UINT retval = 31; /* default - 'No association was found' */
499 WCHAR *tok; /* token pointer */
500 WCHAR xlpFile[256]; /* result of SearchPath */
501 DWORD attribs; /* file attributes */
502
503 TRACE("%s\n", (lpFile != NULL) ? debugstr_w(lpFile) : "-");
504
505 xlpFile[0] = '\0';
506 lpResult[0] = '\0'; /* Start off with an empty return string */
507 if (key) *key = '\0';
508
509 /* trap NULL parameters on entry */
510 if ((lpFile == NULL) || (lpResult == NULL) || (lpOperation == NULL))
511 {
512 WARN("(lpFile=%s,lpResult=%s,lpOperation=%s): NULL parameter\n",
513 debugstr_w(lpFile), debugstr_w(lpOperation), debugstr_w(lpResult));
514 return 2; /* File not found. Close enough, I guess. */
515 }
516
517 if (SHELL_TryAppPathW( lpFile, lpResult, env ))
518 {
519 TRACE("found %s via App Paths\n", debugstr_w(lpResult));
520 return 33;
521 }
522
523 if (SearchPathW(lpPath, lpFile, wszExe, sizeof(xlpFile)/sizeof(WCHAR), xlpFile, NULL))
524 {
525 TRACE("SearchPathW returned non-zero\n");
526 lpFile = xlpFile;
527 /* Hey, isn't this value ignored? Why make this call? Shouldn't we return here? --dank*/
528 }
529
530 attribs = GetFileAttributesW(lpFile);
531 if (attribs!=INVALID_FILE_ATTRIBUTES && (attribs&FILE_ATTRIBUTE_DIRECTORY))
532 {
533 strcpyW(filetype, wszFolder);
534 filetypelen = 6; /* strlen("Folder") */
535 }
536 else
537 {
538 /* First thing we need is the file's extension */
539 extension = strrchrW(xlpFile, '.'); /* Assume last "." is the one; */
540 /* File->Run in progman uses */
541 /* .\FILE.EXE :( */
542 TRACE("xlpFile=%s,extension=%s\n", debugstr_w(xlpFile), debugstr_w(extension));
543
544 if (extension == NULL || extension[1]==0)
545 {
546 WARN("Returning 31 - No association\n");
547 return 31; /* no association */
548 }
549
550 /* Three places to check: */
551 /* 1. win.ini, [windows], programs (NB no leading '.') */
552 /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */
553 /* 3. win.ini, [extensions], extension (NB no leading '.' */
554 /* All I know of the order is that registry is checked before */
555 /* extensions; however, it'd make sense to check the programs */
556 /* section first, so that's what happens here. */
557
558 /* See if it's a program - if GetProfileString fails, we skip this
559 * section. Actually, if GetProfileString fails, we've probably
560 * got a lot more to worry about than running a program... */
561 if (GetProfileStringW(wWindows, wPrograms, wExtensions, wBuffer, sizeof(wBuffer)/sizeof(WCHAR)) > 0)
562 {
563 CharLowerW(wBuffer);
564 tok = wBuffer;
565 while (*tok)
566 {
567 WCHAR *p = tok;
568 while (*p && *p != ' ' && *p != '\t') p++;
569 if (*p)
570 {
571 *p++ = 0;
572 while (*p == ' ' || *p == '\t') p++;
573 }
574
575 if (strcmpiW(tok, &extension[1]) == 0) /* have to skip the leading "." */
576 {
577 strcpyW(lpResult, xlpFile);
578 /* Need to perhaps check that the file has a path
579 * attached */
580 TRACE("found %s\n", debugstr_w(lpResult));
581 return 33;
582
583 /* Greater than 32 to indicate success FIXME According to the
584 * docs, I should be returning a handle for the
585 * executable. Does this mean I'm supposed to open the
586 * executable file or something? More RTFM, I guess... */
587 }
588 tok = p;
589 }
590 }
591
592 /* Check registry */
593 if (RegQueryValueW(HKEY_CLASSES_ROOT, extension, filetype,
594 &filetypelen) == ERROR_SUCCESS)
595 {
596 filetypelen /= sizeof(WCHAR);
597 filetype[filetypelen] = '\0';
598 TRACE("File type: %s\n", debugstr_w(filetype));
599 }
600 }
601
602 if (*filetype)
603 {
604 if (lpOperation)
605 {
606 /* pass the operation string to SHELL_FindExecutableByOperation() */
607 filetype[filetypelen] = '\0';
608 retval = SHELL_FindExecutableByOperation(lpPath, lpFile, lpOperation, key, filetype, command, sizeof(command));
609 }
610 else
611 {
612 WCHAR operation[MAX_PATH];
613 HKEY hkey;
614
615 /* Looking for ...buffer\shell\<operation>\command */
616 strcatW(filetype, wszShell);
617
618 /* enumerate the operation subkeys in the registry and search for one with an associated command */
619 if (RegOpenKeyW(HKEY_CLASSES_ROOT, filetype, &hkey) == ERROR_SUCCESS)
620 {
621 int idx = 0;
622 for(;; ++idx)
623 {
624 if (RegEnumKeyW(hkey, idx, operation, MAX_PATH) != ERROR_SUCCESS)
625 break;
626
627 filetype[filetypelen] = '\0';
628 retval = SHELL_FindExecutableByOperation(lpPath, lpFile, operation, key, filetype, command, sizeof(command));
629
630 if (retval > 32)
631 break;
632 }
633 RegCloseKey(hkey);
634 }
635 }
636
637 if (retval > 32)
638 {
639 SHELL_ArgifyW(lpResult, resultLen, command, xlpFile, pidl, args);
640
641 /* Remove double quotation marks and command line arguments */
642 if (*lpResult == '"')
643 {
644 WCHAR *p = lpResult;
645 while (*(p + 1) != '"')
646 {
647 *p = *(p + 1);
648 p++;
649 }
650 *p = '\0';
651 }
652 }
653 }
654 else /* Check win.ini */
655 {
656 static const WCHAR wExtensions[] = {'e','x','t','e','n','s','i','o','n','s',0};
657
658 /* Toss the leading dot */
659 extension++;
660 if (GetProfileStringW(wExtensions, extension, wszEmpty, command, sizeof(command)/sizeof(WCHAR)) > 0)
661 {
662 if (strlenW(command) != 0)
663 {
664 strcpyW(lpResult, command);
665 tok = strchrW(lpResult, '^'); /* should be ^.extension? */
666 if (tok != NULL)
667 {
668 tok[0] = '\0';
669 strcatW(lpResult, xlpFile); /* what if no dir in xlpFile? */
670 tok = strchrW(command, '^'); /* see above */
671 if ((tok != NULL) && (strlenW(tok)>5))
672 {
673 strcatW(lpResult, &tok[5]);
674 }
675 }
676 retval = 33; /* FIXME - see above */
677 }
678 }
679 }
680
681 TRACE("returning %s\n", debugstr_w(lpResult));
682 return retval;
683 }
684
685 /******************************************************************
686 * dde_cb
687 *
688 * callback for the DDE connection. not really useful
689 */
690 static HDDEDATA CALLBACK dde_cb(UINT uType, UINT uFmt, HCONV hConv,
691 HSZ hsz1, HSZ hsz2, HDDEDATA hData,
692 ULONG_PTR dwData1, ULONG_PTR dwData2)
693 {
694 TRACE("dde_cb: %04x, %04x, %p, %p, %p, %p, %08lx, %08lx\n",
695 uType, uFmt, hConv, hsz1, hsz2, hData, dwData1, dwData2);
696 return NULL;
697 }
698
699 /******************************************************************
700 * dde_connect
701 *
702 * ShellExecute helper. Used to do an operation with a DDE connection
703 *
704 * Handles both the direct connection (try #1), and if it fails,
705 * launching an application and trying (#2) to connect to it
706 *
707 */
708 static unsigned dde_connect(WCHAR* key, WCHAR* start, WCHAR* ddeexec,
709 const WCHAR* lpFile, WCHAR *env,
710 LPCWSTR szCommandline, LPITEMIDLIST pidl, SHELL_ExecuteW32 execfunc,
711 LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out)
712 {
713 static const WCHAR wApplication[] = {'\\','a','p','p','l','i','c','a','t','i','o','n',0};
714 static const WCHAR wTopic[] = {'\\','t','o','p','i','c',0};
715 WCHAR * endkey = key + strlenW(key);
716 WCHAR app[256], topic[256], ifexec[256], res[256];
717 LONG applen, topiclen, ifexeclen;
718 WCHAR * exec;
719 DWORD ddeInst = 0;
720 DWORD tid;
721 HSZ hszApp, hszTopic;
722 HCONV hConv;
723 HDDEDATA hDdeData;
724 unsigned ret = 31;
725 BOOL unicode = !(GetVersion() & 0x80000000);
726
727 strcpyW(endkey, wApplication);
728 applen = sizeof(app);
729 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, app, &applen) != ERROR_SUCCESS)
730 {
731 FIXME("default app name NIY %s\n", debugstr_w(key));
732 return 2;
733 }
734
735 strcpyW(endkey, wTopic);
736 topiclen = sizeof(topic);
737 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, topic, &topiclen) != ERROR_SUCCESS)
738 {
739 static const WCHAR wSystem[] = {'S','y','s','t','e','m',0};
740 strcpyW(topic, wSystem);
741 }
742
743 if (unicode)
744 {
745 if (DdeInitializeW(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR)
746 return 2;
747 }
748 else
749 {
750 if (DdeInitializeA(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR)
751 return 2;
752 }
753
754 hszApp = DdeCreateStringHandleW(ddeInst, app, CP_WINUNICODE);
755 hszTopic = DdeCreateStringHandleW(ddeInst, topic, CP_WINUNICODE);
756
757 hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
758 exec = ddeexec;
759 if (!hConv)
760 {
761 static const WCHAR wIfexec[] = {'\\','i','f','e','x','e','c',0};
762 TRACE("Launching '%s'\n", debugstr_w(start));
763 ret = execfunc(start, env, TRUE, psei, psei_out);
764 if (ret < 32)
765 {
766 TRACE("Couldn't launch\n");
767 goto error;
768 }
769 hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
770 if (!hConv)
771 {
772 TRACE("Couldn't connect. ret=%d\n", ret);
773 DdeUninitialize(ddeInst);
774 SetLastError(ERROR_DDE_FAIL);
775 return 30; /* whatever */
776 }
777 strcpyW(endkey, wIfexec);
778 ifexeclen = sizeof(ifexec);
779 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, ifexec, &ifexeclen) == ERROR_SUCCESS)
780 {
781 exec = ifexec;
782 }
783 }
784
785 SHELL_ArgifyW(res, sizeof(res)/sizeof(WCHAR), exec, lpFile, pidl, szCommandline);
786 TRACE("%s %s => %s\n", debugstr_w(exec), debugstr_w(lpFile), debugstr_w(res));
787
788 /* It's documented in the KB 330337 that IE has a bug and returns
789 * error DMLERR_NOTPROCESSED on XTYP_EXECUTE request.
790 */
791 if (unicode)
792 hDdeData = DdeClientTransaction((LPBYTE)res, (strlenW(res) + 1) * sizeof(WCHAR), hConv, 0L, 0,
793 XTYP_EXECUTE, 10000, &tid);
794 else
795 {
796 DWORD lenA = WideCharToMultiByte(CP_ACP, 0, res, -1, NULL, 0, NULL, NULL);
797 char *resA = HeapAlloc(GetProcessHeap(), 0, lenA);
798 WideCharToMultiByte(CP_ACP, 0, res, -1, resA, lenA, NULL, NULL);
799 hDdeData = DdeClientTransaction( (LPBYTE)resA, lenA, hConv, 0L, 0,
800 XTYP_EXECUTE, 10000, &tid );
801 HeapFree(GetProcessHeap(), 0, resA);
802 }
803 if (hDdeData)
804 DdeFreeDataHandle(hDdeData);
805 else
806 WARN("DdeClientTransaction failed with error %04x\n", DdeGetLastError(ddeInst));
807 ret = 33;
808
809 DdeDisconnect(hConv);
810
811 error:
812 DdeUninitialize(ddeInst);
813
814 return ret;
815 }
816
817 /*************************************************************************
818 * execute_from_key [Internal]
819 */
820 static UINT_PTR execute_from_key(LPWSTR key, LPCWSTR lpFile, WCHAR *env, LPCWSTR szCommandline,
821 SHELL_ExecuteW32 execfunc,
822 LPSHELLEXECUTEINFOW psei, LPSHELLEXECUTEINFOW psei_out)
823 {
824 WCHAR cmd[1024];
825 LONG cmdlen = sizeof(cmd);
826 UINT_PTR retval = 31;
827
828 cmd[0] = '\0';
829
830 /* Get the application for the registry */
831 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, cmd, &cmdlen) == ERROR_SUCCESS)
832 {
833 static const WCHAR wCommand[] = {'c','o','m','m','a','n','d',0};
834 static const WCHAR wDdeexec[] = {'d','d','e','e','x','e','c',0};
835 LPWSTR tmp;
836 WCHAR param[256];
837 LONG paramlen = sizeof(param);
838
839 param[0] = '\0';
840
841 /* Get the parameters needed by the application
842 from the associated ddeexec key */
843 tmp = strstrW(key, wCommand);
844 assert(tmp);
845 strcpyW(tmp, wDdeexec);
846
847 if (RegQueryValueW(HKEY_CLASSES_ROOT, key, param, &paramlen) == ERROR_SUCCESS)
848 {
849 TRACE("Got ddeexec %s => %s\n", debugstr_w(key), debugstr_w(param));
850 retval = dde_connect(key, cmd, param, lpFile, env, szCommandline, psei->lpIDList, execfunc, psei, psei_out);
851 }
852 else
853 {
854 /* Is there a replace() function anywhere? */
855 cmdlen /= sizeof(WCHAR);
856 cmd[cmdlen] = '\0';
857 SHELL_ArgifyW(param, sizeof(param)/sizeof(WCHAR), cmd, lpFile, psei->lpIDList, szCommandline);
858 retval = execfunc(param, env, FALSE, psei, psei_out);
859 }
860 }
861 else TRACE("ooch\n");
862
863 return retval;
864 }
865
866 /*************************************************************************
867 * FindExecutableA [SHELL32.@]
868 */
869 HINSTANCE WINAPI FindExecutableA(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult)
870 {
871 HINSTANCE retval;
872 WCHAR *wFile = NULL, *wDirectory = NULL;
873 WCHAR wResult[MAX_PATH];
874
875 if (lpFile) __SHCloneStrAtoW(&wFile, lpFile);
876 if (lpDirectory) __SHCloneStrAtoW(&wDirectory, lpDirectory);
877
878 retval = FindExecutableW(wFile, wDirectory, wResult);
879 WideCharToMultiByte(CP_ACP, 0, wResult, -1, lpResult, MAX_PATH, NULL, NULL);
880 if (wFile) SHFree( wFile );
881 if (wDirectory) SHFree( wDirectory );
882
883 TRACE("returning %s\n", lpResult);
884 return retval;
885 }
886
887 /*************************************************************************
888 * FindExecutableW [SHELL32.@]
889 */
890 HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult)
891 {
892 UINT_PTR retval = 31; /* default - 'No association was found' */
893 WCHAR old_dir[1024];
894
895 TRACE("File %s, Dir %s\n",
896 (lpFile != NULL ? debugstr_w(lpFile) : "-"), (lpDirectory != NULL ? debugstr_w(lpDirectory) : "-"));
897
898 lpResult[0] = '\0'; /* Start off with an empty return string */
899
900 /* trap NULL parameters on entry */
901 if ((lpFile == NULL) || (lpResult == NULL))
902 {
903 /* FIXME - should throw a warning, perhaps! */
904 return (HINSTANCE)2; /* File not found. Close enough, I guess. */
905 }
906
907 if (lpDirectory)
908 {
909 GetCurrentDirectoryW(sizeof(old_dir)/sizeof(WCHAR), old_dir);
910 SetCurrentDirectoryW(lpDirectory);
911 }
912
913 retval = SHELL_FindExecutable(lpDirectory, lpFile, wszOpen, lpResult, MAX_PATH, NULL, NULL, NULL, NULL);
914
915 TRACE("returning %s\n", debugstr_w(lpResult));
916 if (lpDirectory)
917 SetCurrentDirectoryW(old_dir);
918 return (HINSTANCE)retval;
919 }
920
921 /* FIXME: is this already implemented somewhere else? */
922 static HKEY ShellExecute_GetClassKey( LPSHELLEXECUTEINFOW sei )
923 {
924 LPCWSTR ext = NULL, lpClass = NULL;
925 LPWSTR cls = NULL;
926 DWORD type = 0, sz = 0;
927 HKEY hkey = 0;
928 LONG r;
929
930 if (sei->fMask & SEE_MASK_CLASSALL)
931 return sei->hkeyClass;
932
933 if (sei->fMask & SEE_MASK_CLASSNAME)
934 lpClass = sei->lpClass;
935 else
936 {
937 ext = PathFindExtensionW( sei->lpFile );
938 TRACE("ext = %s\n", debugstr_w( ext ) );
939 if (!ext)
940 return hkey;
941
942 r = RegOpenKeyW( HKEY_CLASSES_ROOT, ext, &hkey );
943 if (r != ERROR_SUCCESS )
944 return hkey;
945
946 r = RegQueryValueExW( hkey, NULL, 0, &type, NULL, &sz );
947 if ( r == ERROR_SUCCESS && type == REG_SZ )
948 {
949 sz += sizeof (WCHAR);
950 cls = HeapAlloc( GetProcessHeap(), 0, sz );
951 cls[0] = 0;
952 RegQueryValueExW( hkey, NULL, 0, &type, (LPBYTE) cls, &sz );
953 }
954
955 RegCloseKey( hkey );
956 lpClass = cls;
957 }
958
959 TRACE("class = %s\n", debugstr_w(lpClass) );
960
961 hkey = 0;
962 if ( lpClass )
963 RegOpenKeyW( HKEY_CLASSES_ROOT, lpClass, &hkey );
964
965 HeapFree( GetProcessHeap(), 0, cls );
966
967 return hkey;
968 }
969
970 static IDataObject *shellex_get_dataobj( LPSHELLEXECUTEINFOW sei )
971 {
972 LPCITEMIDLIST pidllast = NULL;
973 IDataObject *dataobj = NULL;
974 IShellFolder *shf = NULL;
975 LPITEMIDLIST pidl = NULL;
976 HRESULT r;
977
978 if (sei->fMask & SEE_MASK_CLASSALL)
979 pidl = sei->lpIDList;
980 else
981 {
982 WCHAR fullpath[MAX_PATH];
983
984 fullpath[0] = 0;
985 r = GetFullPathNameW( sei->lpFile, MAX_PATH, fullpath, NULL );
986 if (!r)
987 goto end;
988
989 pidl = ILCreateFromPathW( fullpath );
990 }
991
992 r = SHBindToParent( pidl, &IID_IShellFolder, (LPVOID*)&shf, &pidllast );
993 if ( FAILED( r ) )
994 goto end;
995
996 IShellFolder_GetUIObjectOf( shf, NULL, 1, &pidllast,
997 &IID_IDataObject, NULL, (LPVOID*) &dataobj );
998
999 end:
1000 if ( pidl != sei->lpIDList )
1001 ILFree( pidl );
1002 if ( shf )
1003 IShellFolder_Release( shf );
1004 return dataobj;
1005 }
1006
1007 static HRESULT shellex_run_context_menu_default( IShellExtInit *obj,
1008 LPSHELLEXECUTEINFOW sei )
1009 {
1010 IContextMenu *cm = NULL;
1011 CMINVOKECOMMANDINFOEX ici;
1012 MENUITEMINFOW info;
1013 WCHAR string[0x80];
1014 INT i, n, def = -1;
1015 HMENU hmenu = 0;
1016 HRESULT r;
1017
1018 TRACE("%p %p\n", obj, sei );
1019
1020 r = IShellExtInit_QueryInterface( obj, &IID_IContextMenu, (LPVOID*) &cm );
1021 if ( FAILED( r ) )
1022 return r;
1023
1024 hmenu = CreateMenu();
1025 if ( !hmenu )
1026 goto end;
1027
1028 /* the number of the last menu added is returned in r */
1029 r = IContextMenu_QueryContextMenu( cm, hmenu, 0, 0x20, 0x7fff, CMF_DEFAULTONLY );
1030 if ( FAILED( r ) )
1031 goto end;
1032
1033 n = GetMenuItemCount( hmenu );
1034 for ( i = 0; i < n; i++ )
1035 {
1036 memset( &info, 0, sizeof info );
1037 info.cbSize = sizeof info;
1038 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_DATA | MIIM_ID;
1039 info.dwTypeData = string;
1040 info.cch = sizeof string;
1041 string[0] = 0;
1042 GetMenuItemInfoW( hmenu, i, TRUE, &info );
1043
1044 TRACE("menu %d %s %08x %08lx %08x %08x\n", i, debugstr_w(string),
1045 info.fState, info.dwItemData, info.fType, info.wID );
1046 if ( ( !sei->lpVerb && (info.fState & MFS_DEFAULT) ) ||
1047 ( sei->lpVerb && !lstrcmpiW( sei->lpVerb, string ) ) )
1048 {
1049 def = i;
1050 break;
1051 }
1052 }
1053
1054 r = E_FAIL;
1055 if ( def == -1 )
1056 goto end;
1057
1058 memset( &ici, 0, sizeof ici );
1059 ici.cbSize = sizeof ici;
1060 ici.fMask = CMIC_MASK_UNICODE;
1061 ici.nShow = sei->nShow;
1062 ici.lpVerb = MAKEINTRESOURCEA( def );
1063 ici.hwnd = sei->hwnd;
1064 ici.lpParametersW = sei->lpParameters;
1065
1066 r = IContextMenu_InvokeCommand( cm, (LPCMINVOKECOMMANDINFO) &ici );
1067
1068 TRACE("invoke command returned %08lx\n", r );
1069
1070 end:
1071 if ( hmenu )
1072 DestroyMenu( hmenu );
1073 if ( cm )
1074 IContextMenu_Release( cm );
1075 return r;
1076 }
1077
1078 static HRESULT shellex_load_object_and_run( HKEY hkey, LPCGUID guid, LPSHELLEXECUTEINFOW sei )
1079 {
1080 IDataObject *dataobj = NULL;
1081 IObjectWithSite *ows = NULL;
1082 IShellExtInit *obj = NULL;
1083 HRESULT r;
1084
1085 TRACE("%p %s %p\n", hkey, debugstr_guid( guid ), sei );
1086
1087 r = CoInitialize( NULL );
1088 if ( FAILED( r ) )
1089 goto end;
1090
1091 r = CoCreateInstance( guid, NULL, CLSCTX_INPROC_SERVER,
1092 &IID_IShellExtInit, (LPVOID*)&obj );
1093 if ( FAILED( r ) )
1094 {
1095 ERR("failed %08lx\n", r );
1096 goto end;
1097 }
1098
1099 dataobj = shellex_get_dataobj( sei );
1100 if ( !dataobj )
1101 {
1102 ERR("failed to get data object\n");
1103 goto end;
1104 }
1105
1106 r = IShellExtInit_Initialize( obj, NULL, dataobj, hkey );
1107 if ( FAILED( r ) )
1108 goto end;
1109
1110 r = IShellExtInit_QueryInterface( obj, &IID_IObjectWithSite, (LPVOID*) &ows );
1111 if ( FAILED( r ) )
1112 goto end;
1113
1114 IObjectWithSite_SetSite( ows, NULL );
1115
1116 r = shellex_run_context_menu_default( obj, sei );
1117
1118 end:
1119 if ( ows )
1120 IObjectWithSite_Release( ows );
1121 if ( dataobj )
1122 IDataObject_Release( dataobj );
1123 if ( obj )
1124 IShellExtInit_Release( obj );
1125 CoUninitialize();
1126 return r;
1127 }
1128
1129
1130 /*************************************************************************
1131 * ShellExecute_FromContextMenu [Internal]
1132 */
1133 static LONG ShellExecute_FromContextMenu( LPSHELLEXECUTEINFOW sei )
1134 {
1135 static const WCHAR szcm[] = { 's','h','e','l','l','e','x','\\',
1136 'C','o','n','t','e','x','t','M','e','n','u','H','a','n','d','l','e','r','s',0 };
1137 HKEY hkey, hkeycm = 0;
1138 WCHAR szguid[39];
1139 HRESULT hr;
1140 GUID guid;
1141 DWORD i;
1142 LONG r;
1143
1144 TRACE("%s\n", debugstr_w(sei->lpFile) );
1145
1146 hkey = ShellExecute_GetClassKey( sei );
1147 if ( !hkey )
1148 return ERROR_FUNCTION_FAILED;
1149
1150 r = RegOpenKeyW( hkey, szcm, &hkeycm );
1151 if ( r == ERROR_SUCCESS )
1152 {
1153 i = 0;
1154 while ( 1 )
1155 {
1156 r = RegEnumKeyW( hkeycm, i++, szguid, 39 );
1157 if ( r != ERROR_SUCCESS )
1158 break;
1159
1160 hr = CLSIDFromString( szguid, &guid );
1161 if (SUCCEEDED(hr))
1162 {
1163 /* stop at the first one that succeeds in running */
1164 hr = shellex_load_object_and_run( hkey, &guid, sei );
1165 if ( SUCCEEDED( hr ) )
1166 break;
1167 }
1168 }
1169 RegCloseKey( hkeycm );
1170 }
1171
1172 if ( hkey != sei->hkeyClass )
1173 RegCloseKey( hkey );
1174 return r;
1175 }
1176
1177 /*************************************************************************
1178 * SHELL_execute [Internal]
1179 */
1180 BOOL SHELL_execute( LPSHELLEXECUTEINFOW sei, SHELL_ExecuteW32 execfunc )
1181 {
1182 static const WCHAR wQuote[] = {'"',0};
1183 static const WCHAR wSpace[] = {' ',0};
1184 static const WCHAR wWww[] = {'w','w','w',0};
1185 static const WCHAR wFile[] = {'f','i','l','e',0};
1186 static const WCHAR wHttp[] = {'h','t','t','p',':','/','/',0};
1187 static const WCHAR wExplorer[] = {'e','x','p','l','o','r','e','r','.','e','x','e',0};
1188 static const DWORD unsupportedFlags =
1189 SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
1190 SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI |
1191 SEE_MASK_UNICODE | SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK |
1192 SEE_MASK_HMONITOR;
1193
1194 WCHAR wszApplicationName[MAX_PATH+2], wszParameters[1024], wszDir[MAX_PATH];
1195 SHELLEXECUTEINFOW sei_tmp; /* modifiable copy of SHELLEXECUTEINFO struct */
1196 WCHAR wfileName[MAX_PATH];
1197 WCHAR *env;
1198 WCHAR lpstrProtocol[256];
1199 LPCWSTR lpFile;
1200 UINT_PTR retval = 31;
1201 WCHAR wcmd[1024];
1202 WCHAR buffer[MAX_PATH];
1203 BOOL done;
1204
1205 /* make a local copy of the LPSHELLEXECUTEINFO structure and work with this from now on */
1206 memcpy(&sei_tmp, sei, sizeof(sei_tmp));
1207
1208 TRACE("mask=0x%08lx hwnd=%p verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s\n",
1209 sei_tmp.fMask, sei_tmp.hwnd, debugstr_w(sei_tmp.lpVerb),
1210 debugstr_w(sei_tmp.lpFile), debugstr_w(sei_tmp.lpParameters),
1211 debugstr_w(sei_tmp.lpDirectory), sei_tmp.nShow,
1212 ((sei_tmp.fMask & SEE_MASK_CLASSALL) == SEE_MASK_CLASSNAME) ?
1213 debugstr_w(sei_tmp.lpClass) : "not used");
1214
1215 sei->hProcess = NULL;
1216
1217 /* make copies of all path/command strings */
1218 if (!sei_tmp.lpFile)
1219 *wszApplicationName = '\0';
1220 else if (*sei_tmp.lpFile == '\"')
1221 {
1222 UINT l;
1223 strcpyW(wszApplicationName, sei_tmp.lpFile+1);
1224 l=lstrlenW(wszApplicationName);
1225 if (wszApplicationName[l-1] == '\"')
1226 wszApplicationName[l-1] = '\0';
1227 TRACE("wszApplicationName=%s\n",debugstr_w(wszApplicationName));
1228 }
1229 else
1230 strcpyW(wszApplicationName, sei_tmp.lpFile);
1231
1232 if (sei_tmp.lpParameters)
1233 strcpyW(wszParameters, sei_tmp.lpParameters);
1234 else
1235 *wszParameters = '\0';
1236
1237 if (sei_tmp.lpDirectory)
1238 strcpyW(wszDir, sei_tmp.lpDirectory);
1239 else
1240 *wszDir = '\0';
1241
1242 /* adjust string pointers to point to the new buffers */
1243 sei_tmp.lpFile = wszApplicationName;
1244 sei_tmp.lpParameters = wszParameters;
1245 sei_tmp.lpDirectory = wszDir;
1246
1247 if (sei_tmp.fMask & unsupportedFlags)
1248 {
1249 FIXME("flags ignored: 0x%08lx\n", sei_tmp.fMask & unsupportedFlags);
1250 }
1251
1252 /* process the IDList */
1253 if (sei_tmp.fMask & SEE_MASK_IDLIST)
1254 {
1255 IShellExecuteHookW* pSEH;
1256
1257 HRESULT hr = SHBindToParent(sei_tmp.lpIDList, &IID_IShellExecuteHookW, (LPVOID*)&pSEH, NULL);
1258
1259 if (SUCCEEDED(hr))
1260 {
1261 hr = IShellExecuteHookW_Execute(pSEH, &sei_tmp);
1262
1263 IShellExecuteHookW_Release(pSEH);
1264
1265 if (hr == S_OK)
1266 return TRUE;
1267 }
1268
1269 SHGetPathFromIDListW(sei_tmp.lpIDList, wszApplicationName);
1270 TRACE("-- idlist=%p (%s)\n", sei_tmp.lpIDList, debugstr_w(wszApplicationName));
1271 }
1272
1273 if ( ERROR_SUCCESS == ShellExecute_FromContextMenu( &sei_tmp ) )
1274 {
1275 sei->hInstApp = (HINSTANCE) 33;
1276 return TRUE;
1277 }
1278
1279 if (sei_tmp.fMask & SEE_MASK_CLASSALL)
1280 {
1281 /* launch a document by fileclass like 'WordPad.Document.1' */
1282 /* the Commandline contains 'c:\Path\wordpad.exe "%1"' */
1283 /* FIXME: szCommandline should not be of a fixed size. Fixed to 1024, MAX_PATH is way too short! */
1284 ULONG cmask=(sei_tmp.fMask & SEE_MASK_CLASSALL);
1285 HCR_GetExecuteCommandW((cmask == SEE_MASK_CLASSKEY) ? sei_tmp.hkeyClass : NULL,
1286 (cmask == SEE_MASK_CLASSNAME) ? sei_tmp.lpClass: NULL,
1287 (sei_tmp.lpVerb) ? sei_tmp.lpVerb : wszOpen,
1288 wszParameters, sizeof(wszParameters)/sizeof(WCHAR));
1289
1290 /* FIXME: get the extension of lpFile, check if it fits to the lpClass */
1291 TRACE("SEE_MASK_CLASSNAME->'%s', doc->'%s'\n", debugstr_w(wszParameters), debugstr_w(wszApplicationName));
1292
1293 wcmd[0] = '\0';
1294 done = SHELL_ArgifyW(wcmd, sizeof(wcmd)/sizeof(WCHAR), wszParameters, wszApplicationName, sei_tmp.lpIDList, NULL);
1295 if (!done && wszApplicationName[0])
1296 {
1297 strcatW(wcmd, wSpace);
1298 strcatW(wcmd, wszApplicationName);
1299 }
1300 retval = execfunc(wcmd, NULL, FALSE, &sei_tmp, sei);
1301 if (retval > 32)
1302 return TRUE;
1303 else
1304 return FALSE;
1305 }
1306
1307 /* Has the IDList not yet been translated? */
1308 if (sei_tmp.fMask & SEE_MASK_IDLIST)
1309 {
1310 /* last chance to translate IDList: now also allow CLSID paths */
1311 if (SUCCEEDED(SHELL_GetPathFromIDListForExecuteW(sei_tmp.lpIDList, buffer, sizeof(buffer)))) {
1312 if (buffer[0]==':' && buffer[1]==':') {
1313 /* open shell folder for the specified class GUID */
1314 strcpyW(wszParameters, buffer);
1315 strcpyW(wszApplicationName, wExplorer);
1316
1317 sei_tmp.fMask &= ~SEE_MASK_INVOKEIDLIST;
1318 } else if (HCR_GetExecuteCommandW(0, wszFolder, sei_tmp.lpVerb?sei_tmp.lpVerb:wszOpen, buffer, sizeof(buffer))) {
1319 SHELL_ArgifyW(wszApplicationName, sizeof(wszApplicationName)/sizeof(WCHAR), buffer, NULL, sei_tmp.lpIDList, NULL);
1320
1321 sei_tmp.fMask &= ~SEE_MASK_INVOKEIDLIST;
1322 }
1323 }
1324 }
1325
1326 /* expand environment strings */
1327 if (ExpandEnvironmentStringsW(sei_tmp.lpFile, buffer, MAX_PATH))
1328 lstrcpyW(wszApplicationName, buffer);
1329
1330 if (*sei_tmp.lpParameters)
1331 if (ExpandEnvironmentStringsW(sei_tmp.lpParameters, buffer, MAX_PATH))
1332 lstrcpyW(wszParameters, buffer);
1333
1334 if (*sei_tmp.lpDirectory)
1335 if (ExpandEnvironmentStringsW(sei_tmp.lpDirectory, buffer, MAX_PATH))
1336 lstrcpyW(wszDir, buffer);
1337
1338 /* Else, try to execute the filename */
1339 TRACE("execute:%s,%s,%s\n", debugstr_w(wszApplicationName), debugstr_w(wszParameters), debugstr_w(wszDir));
1340
1341 /* separate out command line arguments from executable file name */
1342 if (!*sei_tmp.lpParameters) {
1343 /* If the executable path is quoted, handle the rest of the command line as parameters. */
1344 if (sei_tmp.lpFile[0] == '"') {
1345 LPWSTR src = wszApplicationName/*sei_tmp.lpFile*/ + 1;
1346 LPWSTR dst = wfileName;
1347 LPWSTR end;
1348
1349 /* copy the unquoted executable path to 'wfileName' */
1350 while(*src && *src!='"')
1351 *dst++ = *src++;
1352
1353 *dst = '\0';
1354
1355 if (*src == '"') {
1356 end = ++src;
1357
1358 while(isspace(*src))
1359 ++src;
1360 } else
1361 end = src;
1362
1363 /* copy the parameter string to 'wszParameters' */
1364 strcpyW(wszParameters, src);
1365
1366 /* terminate previous command string after the quote character */
1367 *end = '\0';
1368 }
1369 else
1370 {
1371 /* If the executable name is not quoted, we have to use this search loop here,
1372 that in CreateProcess() is not sufficient because it does not handle shell links. */
1373 WCHAR buffer[MAX_PATH], xlpFile[MAX_PATH];
1374 LPWSTR space, s;
1375
1376 LPWSTR beg = wszApplicationName/*sei_tmp.lpFile*/;
1377 for(s=beg; (space=strchrW(s, ' ')); s=space+1) {
1378 int idx = space-sei_tmp.lpFile;
1379 memcpy(buffer, sei_tmp.lpFile, idx * sizeof(WCHAR));
1380 buffer[idx] = '\0';
1381
1382 /*FIXME This finds directory paths if the targeted file name contains spaces. */
1383 if (SearchPathW(*sei_tmp.lpDirectory? sei_tmp.lpDirectory: NULL, buffer, wszExe, sizeof(xlpFile), xlpFile, NULL))
1384 {
1385 /* separate out command from parameter string */
1386 LPCWSTR p = space + 1;
1387
1388 while(isspaceW(*p))
1389 ++p;
1390
1391 strcpyW(wszParameters, p);
1392 *space = '\0';
1393
1394 break;
1395 }
1396 }
1397
1398 strcpyW(wfileName, sei_tmp.lpFile);
1399 }
1400 } else
1401 strcpyW(wfileName, sei_tmp.lpFile);
1402
1403 lpFile = wfileName;
1404
1405 strcpyW(wcmd, wszApplicationName);
1406 if (sei_tmp.lpParameters[0]) {
1407 strcatW(wcmd, wSpace);
1408 strcatW(wcmd, wszParameters);
1409 }
1410
1411 /* We set the default to open, and that should generally work.
1412 But that is not really the way the MS docs say to do it. */
1413 if (!sei_tmp.lpVerb)
1414 sei_tmp.lpVerb = wszOpen;
1415
1416 retval = execfunc(wcmd, NULL, FALSE, &sei_tmp, sei);
1417 if (retval > 32)
1418 return TRUE;
1419
1420 /* Else, try to find the executable */
1421 wcmd[0] = '\0';
1422 retval = SHELL_FindExecutable(sei_tmp.lpDirectory, lpFile, sei_tmp.lpVerb, wcmd, 1024, lpstrProtocol, &env, sei_tmp.lpIDList, sei_tmp.lpParameters);
1423 if (retval > 32) /* Found */
1424 {
1425 WCHAR wszQuotedCmd[MAX_PATH+2];
1426 /* Must quote to handle case where cmd contains spaces,
1427 * else security hole if malicious user creates executable file "C:\\Program"
1428 */
1429 strcpyW(wszQuotedCmd, wQuote);
1430 strcatW(wszQuotedCmd, wcmd);
1431 strcatW(wszQuotedCmd, wQuote);
1432 if (wszParameters[0]) {
1433 strcatW(wszQuotedCmd, wSpace);
1434 strcatW(wszQuotedCmd, wszParameters);
1435 }
1436 TRACE("%s/%s => %s/%s\n", debugstr_w(wszApplicationName), debugstr_w(sei_tmp.lpVerb), debugstr_w(wszQuotedCmd), debugstr_w(lpstrProtocol));
1437 if (*lpstrProtocol)
1438 retval = execute_from_key(lpstrProtocol, wszApplicationName, env, sei_tmp.lpParameters, execfunc, &sei_tmp, sei);
1439 else
1440 retval = execfunc(wszQuotedCmd, env, FALSE, &sei_tmp, sei);
1441 HeapFree( GetProcessHeap(), 0, env );
1442 }
1443 else if (PathIsURLW((LPWSTR)lpFile)) /* File not found, check for URL */
1444 {
1445 static const WCHAR wShell[] = {'\\','s','h','e','l','l','\\',0};
1446 static const WCHAR wCommand[] = {'\\','c','o','m','m','a','n','d',0};
1447 LPWSTR lpstrRes;
1448 INT iSize;
1449
1450 lpstrRes = strchrW(lpFile, ':');
1451 if (lpstrRes)
1452 iSize = lpstrRes - lpFile;
1453 else
1454 iSize = strlenW(lpFile);
1455
1456 TRACE("Got URL: %s\n", debugstr_w(lpFile));
1457 /* Looking for ...protocol\shell\lpOperation\command */
1458 memcpy(lpstrProtocol, lpFile, iSize*sizeof(WCHAR));
1459 lpstrProtocol[iSize] = '\0';
1460 strcatW(lpstrProtocol, wShell);
1461 strcatW(lpstrProtocol, sei_tmp.lpVerb? sei_tmp.lpVerb: wszOpen);
1462 strcatW(lpstrProtocol, wCommand);
1463
1464 /* Remove File Protocol from lpFile */
1465 /* In the case file://path/file */
1466 if (!strncmpiW(lpFile, wFile, iSize))
1467 {
1468 lpFile += iSize;
1469 while (*lpFile == ':') lpFile++;
1470 }
1471 retval = execute_from_key(lpstrProtocol, lpFile, NULL, sei_tmp.lpParameters, execfunc, &sei_tmp, sei);
1472 }
1473 /* Check if file specified is in the form www.??????.*** */
1474 else if (!strncmpiW(lpFile, wWww, 3))
1475 {
1476 /* if so, append lpFile http:// and call ShellExecute */
1477 WCHAR lpstrTmpFile[256];
1478 strcpyW(lpstrTmpFile, wHttp);
1479 strcatW(lpstrTmpFile, lpFile);
1480 retval = (UINT_PTR)ShellExecuteW(sei_tmp.hwnd, sei_tmp.lpVerb, lpstrTmpFile, NULL, NULL, 0);
1481 }
1482
1483 TRACE("retval %u\n", retval);
1484
1485 if (retval <= 32)
1486 {
1487 sei->hInstApp = (HINSTANCE)retval;
1488 return FALSE;
1489 }
1490
1491 sei->hInstApp = (HINSTANCE)33;
1492 return TRUE;
1493 }
1494
1495 /*************************************************************************
1496 * ShellExecuteA [SHELL32.290]
1497 */
1498 HINSTANCE WINAPI ShellExecuteA(HWND hWnd, LPCSTR lpOperation,LPCSTR lpFile,
1499 LPCSTR lpParameters,LPCSTR lpDirectory, INT iShowCmd)
1500 {
1501 SHELLEXECUTEINFOA sei;
1502
1503 TRACE("%p,%s,%s,%s,%s,%d\n",
1504 hWnd, debugstr_a(lpOperation), debugstr_a(lpFile),
1505 debugstr_a(lpParameters), debugstr_a(lpDirectory), iShowCmd);
1506
1507 sei.cbSize = sizeof(sei);
1508 sei.fMask = 0;
1509 sei.hwnd = hWnd;
1510 sei.lpVerb = lpOperation;
1511 sei.lpFile = lpFile;
1512 sei.lpParameters = lpParameters;
1513 sei.lpDirectory = lpDirectory;
1514 sei.nShow = iShowCmd;
1515 sei.lpIDList = 0;
1516 sei.lpClass = 0;
1517 sei.hkeyClass = 0;
1518 sei.dwHotKey = 0;
1519 sei.hProcess = 0;
1520
1521 ShellExecuteExA (&sei);
1522 return sei.hInstApp;
1523 }
1524
1525 /*************************************************************************
1526 * ShellExecuteExA [SHELL32.292]
1527 *
1528 */
1529 BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
1530 {
1531 SHELLEXECUTEINFOW seiW;
1532 BOOL ret;
1533 WCHAR *wVerb = NULL, *wFile = NULL, *wParameters = NULL, *wDirectory = NULL, *wClass = NULL;
1534
1535 TRACE("%p\n", sei);
1536
1537 memcpy(&seiW, sei, sizeof(SHELLEXECUTEINFOW));
1538
1539 if (sei->lpVerb)
1540 seiW.lpVerb = __SHCloneStrAtoW(&wVerb, sei->lpVerb);
1541
1542 if (sei->lpFile)
1543 seiW.lpFile = __SHCloneStrAtoW(&wFile, sei->lpFile);
1544
1545 if (sei->lpParameters)
1546 seiW.lpParameters = __SHCloneStrAtoW(&wParameters, sei->lpParameters);
1547
1548 if (sei->lpDirectory)
1549 seiW.lpDirectory = __SHCloneStrAtoW(&wDirectory, sei->lpDirectory);
1550
1551 if ((sei->fMask & SEE_MASK_CLASSALL) == SEE_MASK_CLASSNAME && sei->lpClass)
1552 seiW.lpClass = __SHCloneStrAtoW(&wClass, sei->lpClass);
1553 else
1554 seiW.lpClass = NULL;
1555
1556 ret = SHELL_execute( &seiW, SHELL_ExecuteW );
1557
1558 sei->hInstApp = seiW.hInstApp;
1559
1560 if (sei->fMask & SEE_MASK_NOCLOSEPROCESS)
1561 sei->hProcess = seiW.hProcess;
1562
1563 if (wVerb) SHFree(wVerb);
1564 if (wFile) SHFree(wFile);
1565 if (wParameters) SHFree(wParameters);
1566 if (wDirectory) SHFree(wDirectory);
1567 if (wClass) SHFree(wClass);
1568
1569 return ret;
1570 }
1571
1572 /*************************************************************************
1573 * ShellExecuteExW [SHELL32.293]
1574 *
1575 */
1576 BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
1577 {
1578 return SHELL_execute( sei, SHELL_ExecuteW );
1579 }
1580
1581 /*************************************************************************
1582 * ShellExecuteW [SHELL32.294]
1583 * from shellapi.h
1584 * WINSHELLAPI HINSTANCE APIENTRY ShellExecuteW(HWND hwnd, LPCWSTR lpOperation,
1585 * LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
1586 */
1587 HINSTANCE WINAPI ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile,
1588 LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd)
1589 {
1590 SHELLEXECUTEINFOW sei;
1591
1592 TRACE("\n");
1593 sei.cbSize = sizeof(sei);
1594 sei.fMask = 0;
1595 sei.hwnd = hwnd;
1596 sei.lpVerb = lpOperation;
1597 sei.lpFile = lpFile;
1598 sei.lpParameters = lpParameters;
1599 sei.lpDirectory = lpDirectory;
1600 sei.nShow = nShowCmd;
1601 sei.lpIDList = 0;
1602 sei.lpClass = 0;
1603 sei.hkeyClass = 0;
1604 sei.dwHotKey = 0;
1605 sei.hProcess = 0;
1606
1607 SHELL_execute( &sei, SHELL_ExecuteW );
1608 return sei.hInstApp;
1609 }