dlls/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
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <ctype.h>
  28 #include <assert.h>
  29
  30 #include "windef.h"
  31 #include "winerror.h"
  32 #include "winreg.h"
  33 #include "shellapi.h"
  34 #include "shlobj.h"
  35 #include "shlwapi.h"
  36 #include "ddeml.h"
  37
  38 #include "wine/winbase16.h"
  39 #include "shell32_main.h"
  40
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(exec);
  44
  45 /* this function is supposed to expand the escape sequences found in the registry
  46  * some diving reported that the following were used:
  47  * + %1, %2...  seem to report to parameter of index N in ShellExecute pmts
  48  + + %*         seem to report to all parameter (or all remaining, ie after removing
  49  *              the already used %1 %2...)
  50  * + %L         seems to be %1 as long filename followed by the 8+3 variation
  51  * + %l         unknown
  52  * + %S         unknown
  53  * + %I         unknown
  54  */
  55 static void argify(char* res, int len, const char* fmt, const char* lpFile)
  56 {
  57     char        xlpFile[1024];
  58
  59     while (*fmt)
  60     {
  61         if (*fmt == '%')
  62         {
  63             switch (*++fmt)
  64             {
  65             case '\0':
  66             case '%':
  67                 *res++ = '%';
  68                 break;
  69             case '1':
  70                 if (SearchPathA(NULL, lpFile, ".exe", sizeof(xlpFile), xlpFile, NULL))
  71                 {
  72                     strcpy(res, xlpFile);
  73                     res += strlen(xlpFile);
  74                 }
  75                 else
  76                 {
  77                     strcpy(res, lpFile);
  78                     res += strlen(lpFile);
  79                 }
  80                 break;
  81             default: FIXME("Unknown escape sequence %%%c\n", *fmt);
  82             }
  83             fmt++;
  84         }
  85         else
  86             *res++ = *fmt++;
  87     }
  88     *res = '\0';
  89 }
  90
  91 /*************************************************************************
  92  *      SHELL_FindExecutable [Internal]
  93  *
  94  * Utility for code sharing between FindExecutable and ShellExecute
  95  * in:
  96  *      lpFile the name of a file
  97  *      lpOperation the operation on it (open)
  98  * out:
  99  *      lpResult a buffer, big enough :-(, to store the command to do the
 100  *              operation on the file
 101  *      key a buffer, big enough, to get the key name to do actually the
 102  *              command (it'll be used afterwards for more information
 103  *              on the operation)
 104  */
 105 static HINSTANCE SHELL_FindExecutable(LPCSTR lpFile, LPCSTR lpOperation,
 106                                       LPSTR lpResult, LPSTR key)
 107 {
 108     char *extension = NULL; /* pointer to file extension */
 109     char tmpext[5];         /* local copy to mung as we please */
 110     char filetype[256];     /* registry name for this filetype */
 111     LONG filetypelen = 256; /* length of above */
 112     char command[256];      /* command from registry */
 113     LONG commandlen = 256;  /* This is the most DOS can handle :) */
 114     char buffer[256];       /* Used to GetProfileString */
 115     HINSTANCE retval = 31;  /* default - 'No association was found' */
 116     char *tok;              /* token pointer */
 117     int i;                  /* random counter */
 118     char xlpFile[256] = ""; /* result of SearchPath */
 119
 120     TRACE("%s\n", (lpFile != NULL) ? lpFile : "-");
 121
 122     lpResult[0] = '\0'; /* Start off with an empty return string */
 123
 124     /* trap NULL parameters on entry */
 125     if ((lpFile == NULL) || (lpResult == NULL) || (lpOperation == NULL))
 126     {
 127         WARN("(lpFile=%s,lpResult=%s,lpOperation=%s): NULL parameter\n",
 128              lpFile, lpOperation, lpResult);
 129         return 2; /* File not found. Close enough, I guess. */
 130     }
 131
 132     if (SearchPathA(NULL, lpFile, ".exe", sizeof(xlpFile), xlpFile, NULL))
 133     {
 134         TRACE("SearchPathA returned non-zero\n");
 135         lpFile = xlpFile;
 136     }
 137
 138     /* First thing we need is the file's extension */
 139     extension = strrchr(xlpFile, '.'); /* Assume last "." is the one; */
 140                                        /* File->Run in progman uses */
 141                                        /* .\FILE.EXE :( */
 142     TRACE("xlpFile=%s,extension=%s\n", xlpFile, extension);
 143
 144     if ((extension == NULL) || (extension == &xlpFile[strlen(xlpFile)]))
 145     {
 146         WARN("Returning 31 - No association\n");
 147         return 31; /* no association */
 148     }
 149
 150     /* Make local copy & lowercase it for reg & 'programs=' lookup */
 151     lstrcpynA(tmpext, extension, 5);
 152     CharLowerA(tmpext);
 153     TRACE("%s file\n", tmpext);
 154
 155     /* Three places to check: */
 156     /* 1. win.ini, [windows], programs (NB no leading '.') */
 157     /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */
 158     /* 3. win.ini, [extensions], extension (NB no leading '.' */
 159     /* All I know of the order is that registry is checked before */
 160     /* extensions; however, it'd make sense to check the programs */
 161     /* section first, so that's what happens here. */
 162
 163     if (key) *key = '\0';
 164
 165     /* See if it's a program - if GetProfileString fails, we skip this
 166      * section. Actually, if GetProfileString fails, we've probably
 167      * got a lot more to worry about than running a program... */
 168     if (GetProfileStringA("windows", "programs", "exe pif bat com",
 169                           buffer, sizeof(buffer)) > 0)
 170     {
 171         for (i = 0;i<strlen(buffer); i++) buffer[i] = tolower(buffer[i]);
 172
 173         tok = strtok(buffer, " \t"); /* ? */
 174         while (tok!= NULL)
 175         {
 176             if (strcmp(tok, &tmpext[1]) == 0) /* have to skip the leading "." */
 177             {
 178                 strcpy(lpResult, xlpFile);
 179                 /* Need to perhaps check that the file has a path
 180                  * attached */
 181                 TRACE("found %s\n", lpResult);
 182                 return 33;
 183
 184                 /* Greater than 32 to indicate success FIXME According to the
 185                  * docs, I should be returning a handle for the
 186                  * executable. Does this mean I'm supposed to open the
 187                  * executable file or something? More RTFM, I guess... */
 188             }
 189             tok = strtok(NULL, " \t");
 190         }
 191     }
 192
 193     /* Check registry */
 194     if (RegQueryValueA(HKEY_CLASSES_ROOT, tmpext, filetype,
 195                        &filetypelen) == ERROR_SUCCESS)
 196     {
 197         filetype[filetypelen] = '\0';
 198         TRACE("File type: %s\n", filetype);
 199
 200         /* Looking for ...buffer\shell\lpOperation\command */
 201         strcat(filetype, "\\shell\\");
 202         strcat(filetype, lpOperation);
 203         strcat(filetype, "\\command");
 204
 205         if (RegQueryValueA(HKEY_CLASSES_ROOT, filetype, command,
 206                            &commandlen) == ERROR_SUCCESS)
 207         {
 208             if (key) strcpy(key, filetype);
 209 #if 0
 210             LPSTR tmp;
 211             char param[256];
 212             LONG paramlen = 256;
 213
 214             /* FIXME: it seems all Windows version don't behave the same here.
 215              * the doc states that this ddeexec information can be found after
 216              * the exec names.
 217              * on Win98, it doesn't appear, but I think it does on Win2k
 218              */
 219             /* Get the parameters needed by the application
 220                from the associated ddeexec key */
 221             tmp = strstr(filetype, "command");
 222             tmp[0] = '\0';
 223             strcat(filetype, "ddeexec");
 224
 225             if (RegQueryValueA(HKEY_CLASSES_ROOT, filetype, param, &paramlen) == ERROR_SUCCESS)
 226             {
 227                 strcat(command, " ");
 228                 strcat(command, param);
 229                 commandlen += paramlen;
 230             }
 231 #endif
 232             command[commandlen] = '\0';
 233             argify(lpResult, sizeof(lpResult), command, xlpFile);
 234             retval = 33; /* FIXME see above */
 235         }
 236     }
 237     else /* Check win.ini */
 238     {
 239         /* Toss the leading dot */
 240         extension++;
 241         if (GetProfileStringA("extensions", extension, "", command,
 242                               sizeof(command)) > 0)
 243         {
 244             if (strlen(command) != 0)
 245             {
 246                 strcpy(lpResult, command);
 247                 tok = strstr(lpResult, "^"); /* should be ^.extension? */
 248                 if (tok != NULL)
 249                 {
 250                     tok[0] = '\0';
 251                     strcat(lpResult, xlpFile); /* what if no dir in xlpFile? */
 252                     tok = strstr(command, "^"); /* see above */
 253                     if ((tok != NULL) && (strlen(tok)>5))
 254                     {
 255                         strcat(lpResult, &tok[5]);
 256                     }
 257                 }
 258                 retval = 33; /* FIXME - see above */
 259             }
 260         }
 261     }
 262
 263     TRACE("returning %s\n", lpResult);
 264     return retval;
 265 }
 266
 267 /******************************************************************
 268  *              dde_cb
 269  *
 270  * callback for the DDE connection. not really usefull
 271  */
 272 static HDDEDATA CALLBACK dde_cb(UINT uType, UINT uFmt, HCONV hConv,
 273                                 HSZ hsz1, HSZ hsz2,
 274                                 HDDEDATA hData, DWORD dwData1, DWORD dwData2)
 275 {
 276     return (HDDEDATA)0;
 277 }
 278
 279 /******************************************************************
 280  *              dde_connect
 281  *
 282  * ShellExecute helper. Used to do an operation with a DDE connection
 283  *
 284  * Handles both the direct connection (try #1), and if it fails,
 285  * launching an application and trying (#2) to connect to it
 286  *
 287  */
 288 static unsigned dde_connect(char* key, char* start, char* ddeexec,
 289                             const char* lpFile,
 290                             int iCmdShow, BOOL is32)
 291 {
 292     char*       endkey = key + strlen(key);
 293     char        app[256], topic[256], ifexec[256], res[256];
 294     LONG        applen, topiclen, ifexeclen;
 295     char*       exec;
 296     DWORD       ddeInst = 0;
 297     DWORD       tid;
 298     HSZ         hszApp, hszTopic;
 299     HCONV       hConv;
 300     unsigned    ret = 31;
 301
 302     strcpy(endkey, "\\application");
 303     applen = sizeof(app);
 304     if (RegQueryValueA(HKEY_CLASSES_ROOT, key, app, &applen) != ERROR_SUCCESS)
 305     {
 306         FIXME("default app name NIY %s\n", key);
 307         return 2;
 308     }
 309
 310     strcpy(endkey, "\\topic");
 311     topiclen = sizeof(topic);
 312     if (RegQueryValueA(HKEY_CLASSES_ROOT, key, topic, &topiclen) != ERROR_SUCCESS)
 313     {
 314         strcpy(topic, "System");
 315     }
 316
 317     if (DdeInitializeA(&ddeInst, dde_cb, APPCMD_CLIENTONLY, 0L) != DMLERR_NO_ERROR)
 318     {
 319         return 2;
 320     }
 321
 322     hszApp = DdeCreateStringHandleA(ddeInst, app, CP_WINANSI);
 323     hszTopic = DdeCreateStringHandleA(ddeInst, topic, CP_WINANSI);
 324
 325     hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
 326     exec = ddeexec;
 327     if (!hConv)
 328     {
 329         TRACE("Launching '%s'\n", start);
 330         ret = (is32) ? WinExec(start, iCmdShow) : WinExec16(start, iCmdShow);
 331         if (ret < 32)
 332         {
 333             TRACE("Couldn't launch\n");
 334             goto error;
 335         }
 336         hConv = DdeConnect(ddeInst, hszApp, hszTopic, NULL);
 337         if (!hConv)
 338         {
 339             ret = 30; /* whatever */
 340             goto error;
 341         }
 342         strcpy(endkey, "\\ifexec");
 343         ifexeclen = sizeof(ifexec);
 344         if (RegQueryValueA(HKEY_CLASSES_ROOT, key, ifexec, &ifexeclen) == ERROR_SUCCESS)
 345         {
 346             exec = ifexec;
 347         }
 348     }
 349
 350     argify(res, sizeof(res), exec, lpFile);
 351     TRACE("%s %s => %s\n", exec, lpFile, res);
 352
 353     ret = (DdeClientTransaction(res, strlen(res) + 1, hConv, 0L, 0,
 354                                 XTYP_EXECUTE, 10000, &tid) != DMLERR_NO_ERROR) ? 31 : 32;
 355     DdeDisconnect(hConv);
 356  error:
 357     DdeUninitialize(ddeInst);
 358     return ret;
 359 }
 360
 361 static HINSTANCE execute_from_key(LPSTR key, LPCSTR lpFile, INT iShowCmd, BOOL is32)
 362 {
 363     char cmd[1024] = "";
 364     LONG cmdlen = sizeof(cmd);
 365     HINSTANCE retval = 31;
 366
 367     /* Get the application for the registry */
 368     if (RegQueryValueA(HKEY_CLASSES_ROOT, key, cmd, &cmdlen) == ERROR_SUCCESS)
 369     {
 370         LPSTR tmp;
 371         char param[256] = "";
 372         LONG paramlen = 256;
 373
 374         /* Get the parameters needed by the application
 375            from the associated ddeexec key */
 376         tmp = strstr(key, "command");
 377         assert(tmp);
 378         strcpy(tmp, "ddeexec");
 379
 380         if (RegQueryValueA(HKEY_CLASSES_ROOT, key, param, &paramlen) == ERROR_SUCCESS)
 381         {
 382             TRACE("Got ddeexec %s => %s\n", key, param);
 383             retval = dde_connect(key, cmd, param, lpFile, iShowCmd, is32);
 384         }
 385         else
 386         {
 387             /* Is there a replace() function anywhere? */
 388             cmd[cmdlen] = '\0';
 389             argify(param, sizeof(param), cmd, lpFile);
 390
 391             retval = (is32) ? WinExec(param, iShowCmd) : WinExec16(param, iShowCmd);
 392         }
 393     }
 394     else TRACE("ooch\n");
 395
 396     return retval;
 397 }
 398
 399 static HINSTANCE SHELL_Execute(HWND hWnd, LPCSTR lpOperation, LPCSTR lpFile,
 400                                LPCSTR lpParameters, LPCSTR lpDirectory,
 401                                INT iShowCmd, BOOL is32)
 402 {
 403     HINSTANCE retval = 31;
 404     char old_dir[1024];
 405     char cmd[1024];
 406
 407     TRACE("(%04x,'%s','%s','%s','%s',%x)\n",
 408           hWnd, lpOperation ? lpOperation:"<null>", lpFile ? lpFile:"<null>",
 409           lpParameters ? lpParameters : "<null>",
 410           lpDirectory ? lpDirectory : "<null>", iShowCmd);
 411
 412     if (lpFile == NULL) return 0; /* should not happen */
 413     if (lpOperation == NULL) /* default is open */
 414         lpOperation = "open";
 415
 416     if (lpDirectory)
 417     {
 418         GetCurrentDirectoryA(sizeof(old_dir), old_dir);
 419         SetCurrentDirectoryA(lpDirectory);
 420     }
 421
 422     /* First try to execute lpFile with lpParameters directly */
 423     strcpy(cmd, lpFile);
 424     if (lpParameters)
 425     {
 426         strcat(cmd, " ");
 427         strcat(cmd, lpParameters);
 428     }
 429
 430     retval = (is32) ? WinExec(cmd, iShowCmd) : WinExec16(cmd, iShowCmd);
 431
 432     /* Unable to execute lpFile directly
 433        Check if we can match an application to lpFile */
 434     if (retval < 32)
 435     {
 436         char lpstrProtocol[256];
 437
 438         cmd[0] = '\0';
 439         retval = SHELL_FindExecutable(lpFile, lpOperation, cmd, lpstrProtocol);
 440
 441         if (retval > 32)  /* Found */
 442         {
 443             TRACE("%s/%s => %s/%s\n", lpFile, lpOperation, cmd, lpstrProtocol);
 444             if (*lpstrProtocol)
 445                 retval = execute_from_key(lpstrProtocol, lpFile, iShowCmd, is32);
 446             else
 447                 retval = (is32) ? WinExec(cmd, iShowCmd) : WinExec16(cmd, iShowCmd);
 448         }
 449         else if (PathIsURLA((LPSTR)lpFile))    /* File not found, check for URL */
 450         {
 451             LPSTR lpstrRes;
 452             INT iSize;
 453
 454             lpstrRes = strchr(lpFile, ':');
 455             iSize = lpstrRes - lpFile;
 456
 457             TRACE("Got URL: %s\n", lpFile);
 458             /* Looking for ...protocol\shell\lpOperation\command */
 459             strncpy(lpstrProtocol, lpFile, iSize);
 460             lpstrProtocol[iSize] = '\0';
 461             strcat(lpstrProtocol, "\\shell\\");
 462             strcat(lpstrProtocol, lpOperation);
 463             strcat(lpstrProtocol, "\\command");
 464
 465             /* Remove File Protocol from lpFile */
 466             /* In the case file://path/file     */
 467             if (!strncasecmp(lpFile, "file", iSize))
 468             {
 469                 lpFile += iSize;
 470                 while (*lpFile == ':') lpFile++;
 471             }
 472
 473             retval = execute_from_key(lpstrProtocol, lpFile, iShowCmd, is32);
 474         }
 475         /* Check if file specified is in the form www.??????.*** */
 476         else if (!strncasecmp(lpFile, "www", 3))
 477         {
 478             /* if so, append lpFile http:// and call ShellExecute */
 479             char lpstrTmpFile[256] = "http://" ;
 480             strcat(lpstrTmpFile, lpFile);
 481             retval = ShellExecuteA(hWnd, lpOperation, lpstrTmpFile, NULL, NULL, 0);
 482         }
 483     }
 484     if (lpDirectory)
 485         SetCurrentDirectoryA(old_dir);
 486     return retval;
 487 }
 488
 489 /*************************************************************************
 490  * FindExecutableA                      [SHELL32.@]
 491  */
 492 HINSTANCE WINAPI FindExecutableA(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult)
 493 {
 494     HINSTANCE retval = 31;    /* default - 'No association was found' */
 495     char old_dir[1024];
 496
 497     TRACE("File %s, Dir %s\n",
 498           (lpFile != NULL ? lpFile : "-"), (lpDirectory != NULL ? lpDirectory : "-"));
 499
 500     lpResult[0] = '\0'; /* Start off with an empty return string */
 501
 502     /* trap NULL parameters on entry */
 503     if ((lpFile == NULL) || (lpResult == NULL))
 504     {
 505         /* FIXME - should throw a warning, perhaps! */
 506         return 2; /* File not found. Close enough, I guess. */
 507     }
 508
 509     if (lpDirectory)
 510     {
 511         GetCurrentDirectoryA(sizeof(old_dir), old_dir);
 512         SetCurrentDirectoryA(lpDirectory);
 513     }
 514
 515     retval = SHELL_FindExecutable(lpFile, "open", lpResult, NULL);
 516
 517     TRACE("returning %s\n", lpResult);
 518     if (lpDirectory)
 519         SetCurrentDirectoryA(old_dir);
 520     return retval;
 521 }
 522
 523 /*************************************************************************
 524  * FindExecutableW                      [SHELL32.@]
 525  */
 526 HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult)
 527 {
 528     FIXME("(%p,%p,%p): stub\n", lpFile, lpDirectory, lpResult);
 529     return 31;    /* default - 'No association was found' */
 530 }
 531
 532 /*************************************************************************
 533  *                              ShellExecute            [SHELL.20]
 534  */
 535 HINSTANCE16 WINAPI ShellExecute16( HWND16 hWnd, LPCSTR lpOperation,
 536                                    LPCSTR lpFile, LPCSTR lpParameters,
 537                                    LPCSTR lpDirectory, INT16 iShowCmd )
 538 {
 539     return (HINSTANCE16)SHELL_Execute(hWnd, lpOperation, lpFile,
 540                                       lpParameters, lpDirectory, iShowCmd, FALSE );
 541 }
 542
 543 /*************************************************************************
 544  * ShellExecuteA                        [SHELL32.290]
 545  */
 546 HINSTANCE WINAPI ShellExecuteA(HWND hWnd, LPCSTR lpOperation,LPCSTR lpFile,
 547                                LPCSTR lpParameters,LPCSTR lpDirectory, INT iShowCmd)
 548 {
 549     TRACE("\n");
 550     return SHELL_Execute( hWnd, lpOperation, lpFile, lpParameters,
 551                           lpDirectory, iShowCmd, TRUE );
 552 }
 553
 554 /*************************************************************************
 555  * ShellExecuteW                        [SHELL32.294]
 556  * from shellapi.h
 557  * WINSHELLAPI HINSTANCE APIENTRY ShellExecuteW(HWND hwnd, LPCWSTR lpOperation,
 558  * LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
 559  */
 560 HINSTANCE WINAPI ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile,
 561                                LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd)
 562 {
 563        FIXME(": stub\n");
 564        return 0;
 565 }
 566