programs/rundll32/rundll32.c

   1 /*
   2  * PURPOSE: Load a DLL and run an entry point with the specified parameters
   3  *
   4  * Copyright 2002 Alberto Massari
   5  * Copyright 2001-2003 Aric Stewart for CodeWeavers
   6  * Copyright 2003 Mike McCormack for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  */
  23
  24 /*
  25  *
  26  *  rundll32 dllname,entrypoint [arguments]
  27  *
  28  *  Documentation for this utility found on KB Q164787
  29  *
  30  */
  31
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <stdlib.h>
  35
  36 /* Exclude rarely-used stuff from Windows headers */
  37 #define WIN32_LEAN_AND_MEAN
  38 #include "windows.h"
  39 #include "wine/winbase16.h"
  40 #include "wine/unicode.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(rundll32);
  44
  45
  46 /*
  47  * Control_RunDLL has these parameters
  48  */
  49 typedef void (WINAPI *EntryPointW)(HWND hWnd, HINSTANCE hInst, LPWSTR lpszCmdLine, int nCmdShow);
  50 typedef void (WINAPI *EntryPointA)(HWND hWnd, HINSTANCE hInst, LPSTR lpszCmdLine, int nCmdShow);
  51
  52 /*
  53  * Control_RunDLL needs to have a window. So lets make us a very
  54  * simple window class.
  55  */
  56 static const WCHAR szTitle[] = {'r','u','n','d','l','l','3','2',0};
  57 static const WCHAR szWindowClass[] = {'c','l','a','s','s','_','r','u','n','d','l','l','3','2',0};
  58 static const WCHAR kernel32[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
  59 static const WCHAR shell32[] = {'s','h','e','l','l','3','2','.','d','l','l',0};
  60
  61 static HINSTANCE16 (WINAPI *pLoadLibrary16)(LPCSTR libname);
  62 static FARPROC16 (WINAPI *pGetProcAddress16)(HMODULE16 hModule, LPCSTR name);
  63 static void (WINAPI *pRunDLL_CallEntry16)( FARPROC proc, HWND hwnd, HINSTANCE inst,
  64                                            LPCSTR cmdline, INT cmdshow );
  65
  66 static ATOM register_class(void)
  67 {
  68     WNDCLASSEXW wcex;
  69
  70     wcex.cbSize = sizeof(WNDCLASSEXW);
  71
  72     wcex.style          = CS_HREDRAW | CS_VREDRAW;
  73     wcex.lpfnWndProc    = DefWindowProcW;
  74     wcex.cbClsExtra     = 0;
  75     wcex.cbWndExtra     = 0;
  76     wcex.hInstance      = NULL;
  77     wcex.hIcon          = NULL;
  78     wcex.hCursor        = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
  79     wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
  80     wcex.lpszMenuName   = NULL;
  81     wcex.lpszClassName  = szWindowClass;
  82     wcex.hIconSm        = NULL;
  83
  84     return RegisterClassExW(&wcex);
  85 }
  86
  87 static HINSTANCE16 load_dll16( LPCWSTR dll )
  88 {
  89     HINSTANCE16 ret = 0;
  90     DWORD len = WideCharToMultiByte( CP_ACP, 0, dll, -1, NULL, 0, NULL, NULL );
  91     char *dllA = HeapAlloc( GetProcessHeap(), 0, len );
  92
  93     if (dllA)
  94     {
  95         WideCharToMultiByte( CP_ACP, 0, dll, -1, dllA, len, NULL, NULL );
  96         pLoadLibrary16 = (void *)GetProcAddress( GetModuleHandleW(kernel32), (LPCSTR)35 );
  97         if (pLoadLibrary16) ret = pLoadLibrary16( dllA );
  98         HeapFree( GetProcessHeap(), 0, dllA );
  99     }
 100     return ret;
 101 }
 102
 103 static FARPROC16 get_entry_point16( HINSTANCE16 inst, LPCWSTR entry )
 104 {
 105     FARPROC16 ret = 0;
 106     DWORD len = WideCharToMultiByte( CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL );
 107     char *entryA = HeapAlloc( GetProcessHeap(), 0, len );
 108
 109     if (entryA)
 110     {
 111         WideCharToMultiByte( CP_ACP, 0, entry, -1, entryA, len, NULL, NULL );
 112         pGetProcAddress16 = (void *)GetProcAddress( GetModuleHandleW(kernel32), (LPCSTR)37 );
 113         if (pGetProcAddress16) ret = pGetProcAddress16( inst, entryA );
 114         HeapFree( GetProcessHeap(), 0, entryA );
 115     }
 116     return ret;
 117 }
 118
 119 static void *get_entry_point32( HMODULE module, LPCWSTR entry, BOOL *unicode )
 120 {
 121     void *ret;
 122
 123     /* determine if the entry point is an ordinal */
 124     if (entry[0] == '#')
 125     {
 126         INT_PTR ordinal = atoiW( entry + 1 );
 127         if (ordinal <= 0)
 128             return NULL;
 129
 130         *unicode = TRUE;
 131         ret = GetProcAddress( module, (LPCSTR)ordinal );
 132     }
 133     else
 134     {
 135         DWORD len = WideCharToMultiByte( CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL );
 136         char *entryA = HeapAlloc( GetProcessHeap(), 0, len + 1 );
 137
 138         if (!entryA)
 139             return NULL;
 140
 141         WideCharToMultiByte( CP_ACP, 0, entry, -1, entryA, len, NULL, NULL );
 142
 143         /* first try the W version */
 144         *unicode = TRUE;
 145         strcat( entryA, "W" );
 146         if (!(ret = GetProcAddress( module, entryA )))
 147         {
 148             /* now the A version */
 149             *unicode = FALSE;
 150             entryA[strlen(entryA)-1] = 'A';
 151             if (!(ret = GetProcAddress( module, entryA )))
 152             {
 153                 /* now the version without suffix */
 154                 entryA[strlen(entryA)-1] = 0;
 155                 ret = GetProcAddress( module, entryA );
 156             }
 157         }
 158         HeapFree( GetProcessHeap(), 0, entryA );
 159     }
 160     return ret;
 161 }
 162
 163 static LPWSTR get_next_arg(LPWSTR *cmdline)
 164 {
 165     LPWSTR s;
 166     LPWSTR arg,d;
 167     BOOL in_quotes;
 168     int bcount,len=0;
 169
 170     /* count the chars */
 171     bcount=0;
 172     in_quotes=FALSE;
 173     s=*cmdline;
 174     while (1) {
 175         if (*s==0 || ((*s=='\t' || *s==' ') && !in_quotes)) {
 176             /* end of this command line argument */
 177             break;
 178         } else if (*s=='\\') {
 179             /* '\', count them */
 180             bcount++;
 181         } else if ((*s=='"') && ((bcount & 1)==0)) {
 182             /* unescaped '"' */
 183             in_quotes=!in_quotes;
 184             bcount=0;
 185         } else {
 186             /* a regular character */
 187             bcount=0;
 188         }
 189         s++;
 190         len++;
 191     }
 192     arg=HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
 193     if (!arg)
 194         return NULL;
 195
 196     bcount=0;
 197     in_quotes=FALSE;
 198     d=arg;
 199     s=*cmdline;
 200     while (*s) {
 201         if ((*s=='\t' || *s==' ') && !in_quotes) {
 202             /* end of this command line argument */
 203             break;
 204         } else if (*s=='\\') {
 205             /* '\\' */
 206             *d++=*s++;
 207             bcount++;
 208         } else if (*s=='"') {
 209             /* '"' */
 210             if ((bcount & 1)==0) {
 211                 /* Preceded by an even number of '\', this is half that
 212                  * number of '\', plus a quote which we erase.
 213                  */
 214                 d-=bcount/2;
 215                 in_quotes=!in_quotes;
 216                 s++;
 217             } else {
 218                 /* Preceded by an odd number of '\', this is half that
 219                  * number of '\' followed by a '"'
 220                  */
 221                 d=d-bcount/2-1;
 222                 *d++='"';
 223                 s++;
 224             }
 225             bcount=0;
 226         } else {
 227             /* a regular character */
 228             *d++=*s++;
 229             bcount=0;
 230         }
 231     }
 232     *d=0;
 233     *cmdline=s;
 234
 235     /* skip the remaining spaces */
 236     while (**cmdline=='\t' || **cmdline==' ') {
 237         (*cmdline)++;
 238     }
 239
 240     return arg;
 241 }
 242
 243 int WINAPI wWinMain(HINSTANCE instance, HINSTANCE hOldInstance, LPWSTR szCmdLine, int nCmdShow)
 244 {
 245     HWND hWnd;
 246     LPWSTR szDllName,szEntryPoint;
 247     void *entry_point;
 248     BOOL unicode = FALSE, win16;
 249     STARTUPINFOW info;
 250     HMODULE hDll;
 251
 252     hWnd=NULL;
 253     hDll=NULL;
 254     szDllName=NULL;
 255
 256     /* Initialize the rundll32 class */
 257     register_class();
 258     hWnd = CreateWindowW(szWindowClass, szTitle,
 259           WS_OVERLAPPEDWINDOW|WS_VISIBLE,
 260           CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, NULL, NULL);
 261
 262     /* Get the dll name and API EntryPoint */
 263     WINE_TRACE("CmdLine=%s\n",wine_dbgstr_w(szCmdLine));
 264     szDllName = get_next_arg(&szCmdLine);
 265     if (!szDllName || *szDllName==0)
 266         goto CLEANUP;
 267     WINE_TRACE("DllName=%s\n",wine_dbgstr_w(szDllName));
 268     if ((szEntryPoint = strchrW(szDllName, ',' )))
 269         *szEntryPoint++=0;
 270     else
 271         szEntryPoint = get_next_arg(&szCmdLine);
 272     WINE_TRACE("EntryPoint=%s\n",wine_dbgstr_w(szEntryPoint));
 273
 274     /* Load the library */
 275     hDll=LoadLibraryW(szDllName);
 276     if (hDll)
 277     {
 278         win16 = FALSE;
 279         entry_point = get_entry_point32( hDll, szEntryPoint, &unicode );
 280     }
 281     else
 282     {
 283         HINSTANCE16 dll = load_dll16( szDllName );
 284         if (dll <= 32)
 285         {
 286             /* Windows has a MessageBox here... */
 287             WINE_ERR("Unable to load %s\n",wine_dbgstr_w(szDllName));
 288             goto CLEANUP;
 289         }
 290         win16 = TRUE;
 291         unicode = FALSE;
 292         entry_point = get_entry_point16( dll, szEntryPoint );
 293     }
 294
 295     if (!entry_point)
 296     {
 297         /* Windows has a MessageBox here... */
 298         WINE_ERR( "Unable to find the entry point %s in %s\n",
 299                   wine_dbgstr_w(szEntryPoint), wine_dbgstr_w(szDllName) );
 300         goto CLEANUP;
 301     }
 302
 303     GetStartupInfoW( &info );
 304     if (!(info.dwFlags & STARTF_USESHOWWINDOW)) info.wShowWindow = SW_SHOWDEFAULT;
 305
 306     if (unicode)
 307     {
 308         EntryPointW pEntryPointW = entry_point;
 309
 310         WINE_TRACE( "Calling %s (%p,%p,%s,%d)\n", wine_dbgstr_w(szEntryPoint),
 311                     hWnd, instance, wine_dbgstr_w(szCmdLine), info.wShowWindow );
 312
 313         pEntryPointW( hWnd, instance, szCmdLine, info.wShowWindow );
 314     }
 315     else
 316     {
 317         DWORD len = WideCharToMultiByte( CP_ACP, 0, szCmdLine, -1, NULL, 0, NULL, NULL );
 318         char *cmdline = HeapAlloc( GetProcessHeap(), 0, len );
 319
 320         if (!cmdline)
 321             goto CLEANUP;
 322
 323         WideCharToMultiByte( CP_ACP, 0, szCmdLine, -1, cmdline, len, NULL, NULL );
 324
 325         WINE_TRACE( "Calling %s (%p,%p,%s,%d)\n", wine_dbgstr_w(szEntryPoint),
 326                     hWnd, instance, wine_dbgstr_a(cmdline), info.wShowWindow );
 327
 328         if (win16)
 329         {
 330             HMODULE shell = LoadLibraryW( shell32 );
 331             if (shell) pRunDLL_CallEntry16 = (void *)GetProcAddress( shell, (LPCSTR)122 );
 332             if (pRunDLL_CallEntry16)
 333                 pRunDLL_CallEntry16( entry_point, hWnd, instance, cmdline, info.wShowWindow );
 334         }
 335         else
 336         {
 337             EntryPointA pEntryPointA = entry_point;
 338             pEntryPointA( hWnd, instance, cmdline, info.wShowWindow );
 339         }
 340         HeapFree( GetProcessHeap(), 0, cmdline );
 341     }
 342
 343 CLEANUP:
 344     if (hWnd)
 345         DestroyWindow(hWnd);
 346     if (hDll)
 347         FreeLibrary(hDll);
 348     HeapFree(GetProcessHeap(),0,szDllName);
 349     return 0; /* rundll32 always returns 0! */
 350 }