Check for removable media and Partition length is 0, for DiskClassCheckReadWrite.
[reactos.git] / reactos / subsys / system / rundll32 / rundll32.c
1 /*
2 * ReactOS rundll32
3 * Copyright (C) 2003-2004 ReactOS Team
4 *
5 * COPYRIGHT: See COPYING in the top level directory
6 * PROJECT: ReactOS rundll32.exe
7 * FILE: apps/utils/rundll32/rundll32.c
8 * PURPOSE: Run a DLL as a program
9 * PROGRAMMER: ShadowFlare (blakflare@hotmail.com)
10 */
11
12 #define WIN32_LEAN_AND_MEAN
13
14 // Both UNICODE and _UNICODE must be either defined or undefined
15 // because some headers use UNICODE and others use _UNICODE
16 #ifdef UNICODE
17 #ifndef _UNICODE
18 #define _UNICODE
19 #endif
20 #else
21 #ifdef _UNICODE
22 #define UNICODE
23 #endif
24 #endif
25
26 #include <windows.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <malloc.h>
30 #include <tchar.h>
31
32 typedef int (WINAPI *DllWinMainW)(
33 HWND hWnd,
34 HINSTANCE hInstance,
35 LPWSTR lpwCmdLine,
36 int nCmdShow
37 );
38 typedef int (WINAPI *DllWinMainA)(
39 HWND hWnd,
40 HINSTANCE hInstance,
41 LPSTR lpCmdLine,
42 int nCmdShow
43 );
44
45 LPCTSTR DllNotLoaded = _T("LoadLibrary failed to load \"%s\"");
46 LPCTSTR MissingEntry = _T("Missing entry point:%s\nIn %s");
47 LPCTSTR rundll32_wtitle = _T("rundll32");
48 LPCTSTR rundll32_wclass = _T("rundll32_window");
49 TCHAR ModuleFileName[MAX_PATH+1];
50 LPTSTR ModuleTitle;
51
52 // CommandLineToArgv converts a command-line string to argc and
53 // argv similar to the ones in the standard main function.
54 // This is a specialized version coded specifically for rundll32
55 // and is not intended to be used in any other program.
56 LPTSTR *WINAPI CommandLineToArgv(LPCTSTR lpCmdLine, int *lpArgc)
57 {
58 LPTSTR *argv, lpSrc, lpDest, lpArg;
59 int argc, nBSlash, nNames;
60 BOOL bInQuotes, bFirstChar;
61
62 // If null was passed in for lpCmdLine, there are no arguments
63 if (!lpCmdLine) {
64 if (lpArgc)
65 *lpArgc = 0;
66 return 0;
67 }
68
69 lpSrc = (LPTSTR)lpCmdLine;
70 // Skip spaces at beginning
71 while (*lpSrc == _T(' ') || *lpSrc == _T('\t'))
72 lpSrc++;
73
74 // If command-line starts with null, there are no arguments
75 if (*lpSrc == 0) {
76 if (lpArgc)
77 *lpArgc = 0;
78 return 0;
79 }
80
81 lpArg = lpSrc;
82 argc = 0;
83 nBSlash = 0;
84 bInQuotes = FALSE;
85 bFirstChar = TRUE;
86 nNames = 0;
87
88 // Count the number of arguments
89 while (nNames < 4) {
90 if (*lpSrc == 0 || (*lpSrc == _T(',') && nNames == 2) || ((*lpSrc == _T(' ') || *lpSrc == _T('\t')) && !bInQuotes)) {
91 // Whitespace not enclosed in quotes signals the start of another argument
92 argc++;
93
94 // Skip whitespace between arguments
95 while (*lpSrc == _T(' ') || *lpSrc == _T('\t') || (*lpSrc == _T(',') && nNames == 2))
96 lpSrc++;
97 if (*lpSrc == 0)
98 break;
99 if (nNames >= 3) {
100 // Increment the count for the last argument
101 argc++;
102 break;
103 }
104 nBSlash = 0;
105 bFirstChar = TRUE;
106 continue;
107 }
108 else if (*lpSrc == _T('\\')) {
109 // Count consecutive backslashes
110 nBSlash++;
111 bFirstChar = FALSE;
112 }
113 else if (*lpSrc == _T('\"') && !(nBSlash & 1)) {
114 // Open or close quotes
115 bInQuotes = !bInQuotes;
116 nBSlash = 0;
117 }
118 else {
119 // Some other character
120 nBSlash = 0;
121 if (bFirstChar && ((*lpSrc != _T('/') && nNames <= 1) || nNames > 1))
122 nNames++;
123 bFirstChar = FALSE;
124 }
125 lpSrc++;
126 }
127
128 // Allocate space for the pointers in argv and the strings in one block
129 argv = (LPTSTR *)malloc(argc * sizeof(LPTSTR) + (_tcslen(lpArg) + 1) * sizeof(TCHAR));
130
131 if (!argv) {
132 // Memory allocation failed
133 if (lpArgc)
134 *lpArgc = 0;
135 return 0;
136 }
137
138 lpSrc = lpArg;
139 lpDest = lpArg = (LPTSTR)(argv + argc);
140 argc = 0;
141 nBSlash = 0;
142 bInQuotes = FALSE;
143 bFirstChar = TRUE;
144 nNames = 0;
145
146 // Fill the argument array
147 while (nNames < 4) {
148 if (*lpSrc == 0 || (*lpSrc == _T(',') && nNames == 2) || ((*lpSrc == _T(' ') || *lpSrc == _T('\t')) && !bInQuotes)) {
149 // Whitespace not enclosed in quotes signals the start of another argument
150 // Null-terminate argument
151 *lpDest++ = 0;
152 argv[argc++] = lpArg;
153
154 // Skip whitespace between arguments
155 while (*lpSrc == _T(' ') || *lpSrc == _T('\t') || (*lpSrc == _T(',') && nNames == 2))
156 lpSrc++;
157 if (*lpSrc == 0)
158 break;
159 lpArg = lpDest;
160 if (nNames >= 3) {
161 // Copy the rest of the command-line to the last argument
162 argv[argc++] = lpArg;
163 _tcscpy(lpArg,lpSrc);
164 break;
165 }
166 nBSlash = 0;
167 bFirstChar = TRUE;
168 continue;
169 }
170 else if (*lpSrc == _T('\\')) {
171 *lpDest++ = _T('\\');
172 lpSrc++;
173
174 // Count consecutive backslashes
175 nBSlash++;
176 bFirstChar = FALSE;
177 }
178 else if (*lpSrc == _T('\"')) {
179 if (!(nBSlash & 1)) {
180 // If an even number of backslashes are before the quotes,
181 // the quotes don't go in the output
182 lpDest -= nBSlash / 2;
183 bInQuotes = !bInQuotes;
184 }
185 else {
186 // If an odd number of backslashes are before the quotes,
187 // output a quote
188 lpDest -= (nBSlash + 1) / 2;
189 *lpDest++ = _T('\"');
190 bFirstChar = FALSE;
191 }
192 lpSrc++;
193 nBSlash = 0;
194 }
195 else {
196 // Copy other characters
197 if (bFirstChar && ((*lpSrc != _T('/') && nNames <= 1) || nNames > 1))
198 nNames++;
199 *lpDest++ = *lpSrc++;
200 nBSlash = 0;
201 bFirstChar = FALSE;
202 }
203 }
204
205 if (lpArgc)
206 *lpArgc = argc;
207 return argv;
208 }
209
210 void GetModuleTitle(void)
211 {
212 LPTSTR lpStr;
213
214 GetModuleFileName(0,ModuleFileName,MAX_PATH);
215 ModuleTitle = ModuleFileName;
216
217 for (lpStr = ModuleFileName;*lpStr;lpStr++) {
218 if (*lpStr == _T('\\'))
219 ModuleTitle = lpStr+1;
220 }
221
222 for (lpStr = ModuleTitle;*lpStr;lpStr++) {
223 if (_tcsicmp(lpStr,_T(".exe"))==0)
224 break;
225 }
226
227 *lpStr = 0;
228 }
229
230 // The macro ConvertToWideChar takes a tstring parameter and returns
231 // a pointer to a unicode string. A conversion is performed if
232 // neccessary. FreeConvertedWideChar string should be used on the
233 // return value of ConvertToWideChar when the string is no longer
234 // needed. The original string or the string that is returned
235 // should not be modified until FreeConvertedWideChar has been called.
236 #ifdef UNICODE
237 #define ConvertToWideChar(lptString) (lptString)
238 #define FreeConvertedWideChar(lpwString)
239 #else
240
241 LPWSTR ConvertToWideChar(LPCSTR lpString)
242 {
243 LPWSTR lpwString;
244 size_t nStrLen;
245
246 nStrLen = strlen(lpString) + 1;
247
248 lpwString = (LPWSTR)malloc(nStrLen * sizeof(WCHAR));
249 MultiByteToWideChar(0,0,lpString,nStrLen,lpwString,nStrLen);
250
251 return lpwString;
252 }
253
254 #define FreeConvertedWideChar(lpwString) free(lpwString)
255 #endif
256
257 // The macro ConvertToMultiByte takes a tstring parameter and returns
258 // a pointer to an ansi string. A conversion is performed if
259 // neccessary. FreeConvertedMultiByte string should be used on the
260 // return value of ConvertToMultiByte when the string is no longer
261 // needed. The original string or the string that is returned
262 // should not be modified until FreeConvertedMultiByte has been called.
263 #ifdef UNICODE
264 #define ConvertToMultiByte(lptString) DuplicateToMultiByte(lptString,0)
265 #define FreeConvertedMultiByte(lpaString) free(lpaString)
266 #else
267 #define ConvertToMultiByte(lptString) (lptString)
268 #define FreeConvertedMultiByte(lpaString)
269 #endif
270
271 // DuplicateToMultiByte takes a tstring parameter and always returns
272 // a pointer to a duplicate ansi string. If nBufferSize is zero,
273 // the buffer length is the exact size of the string plus the
274 // terminating null. If nBufferSize is nonzero, the buffer length
275 // is equal to nBufferSize. As with strdup, free should be called
276 // for the returned string when it is no longer needed.
277 LPSTR DuplicateToMultiByte(LPCTSTR lptString, size_t nBufferSize)
278 {
279 LPSTR lpString;
280 size_t nStrLen;
281
282 nStrLen = _tcslen(lptString) + 1;
283 if (nBufferSize == 0) nBufferSize = nStrLen;
284
285 lpString = (LPSTR)malloc(nBufferSize);
286 #ifdef UNICODE
287 WideCharToMultiByte(0,0,lptString,nStrLen,lpString,nBufferSize,0,0);
288 #else
289 strncpy(lpString,lptString,nBufferSize);
290 #endif
291
292 return lpString;
293 }
294
295 LRESULT CALLBACK EmptyWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
296 {
297 return DefWindowProc(hWnd, uMsg, wParam, lParam);
298 }
299
300 // Registers a minimal window class for passing to the dll function
301 ATOM RegisterBlankClass(HINSTANCE hInstance)
302 {
303 WNDCLASSEX wcex;
304
305 wcex.cbSize = sizeof(WNDCLASSEX);
306
307 wcex.style = 0;
308 wcex.lpfnWndProc = EmptyWindowProc;
309 wcex.cbClsExtra = 0;
310 wcex.cbWndExtra = 0;
311 wcex.hInstance = hInstance;
312 wcex.hIcon = 0;
313 wcex.hCursor = 0;
314 wcex.hbrBackground = 0;
315 wcex.lpszMenuName = 0;
316 wcex.lpszClassName = rundll32_wclass;
317 wcex.hIconSm = 0;
318
319 return RegisterClassEx(&wcex);
320 }
321
322 int WINAPI WinMain(
323 HINSTANCE hInstance,
324 HINSTANCE hPrevInstance,
325 LPSTR lpCmdLineA,
326 int nCmdShow
327 )
328 {
329 int argc;
330 LPTSTR *argv;
331 LPTSTR lptCmdLine,lptDllName,lptFuncName,lptMsgBuffer;
332 LPSTR lpFuncName,lpaCmdLine;
333 LPWSTR lpwCmdLine;
334 HMODULE hDll;
335 DllWinMainW fnDllWinMainW;
336 DllWinMainA fnDllWinMainA;
337 HWND hWindow;
338 int nRetVal,i;
339 size_t nStrLen;
340
341 // Get command-line in argc-argv format
342 argv = CommandLineToArgv(GetCommandLine(),&argc);
343
344 // Skip all beginning arguments starting with a slash (/)
345 for (i = 1; i < argc; i++)
346 if (*argv[i] != _T('/')) break;
347
348 // If no dll was specified, there is nothing to do
349 if (i >= argc) {
350 if (argv) free(argv);
351 return 0;
352 }
353
354 lptDllName = argv[i++];
355
356 // The next argument, which specifies the name of the dll function,
357 // can either have a comma between it and the dll filename or a space.
358 // Using a comma here is the preferred method
359 if (i < argc)
360 lptFuncName = argv[i++];
361 else
362 lptFuncName = _T("");
363
364 // If no function name was specified, nothing needs to be done
365 if (!*lptFuncName) {
366 if (argv) free(argv);
367 return 0;
368 }
369
370 // The rest of the arguments will be passed to dll function
371 if (i < argc)
372 lptCmdLine = argv[i];
373 else
374 lptCmdLine = _T("");
375
376 nRetVal = 0;
377
378 // Everything is all setup, so load the dll now
379 hDll = LoadLibrary(lptDllName);
380 if (hDll) {
381 nStrLen = _tcslen(lptFuncName);
382 // Make a non-unicode version of the function name,
383 // since that is all GetProcAddress accepts
384 lpFuncName = DuplicateToMultiByte(lptFuncName,nStrLen + 2);
385
386 #ifdef UNICODE
387 lpFuncName[nStrLen] = 'W';
388 lpFuncName[nStrLen+1] = 0;
389 // Get address of unicode version of the dll function if it exists
390 fnDllWinMainW = (DllWinMainW)GetProcAddress(hDll,lpFuncName);
391 fnDllWinMainA = 0;
392 if (!fnDllWinMainW) {
393 // If no unicode function was found, get the address of the non-unicode function
394 lpFuncName[nStrLen] = 'A';
395 fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
396 if (!fnDllWinMainA) {
397 // If first non-unicode function was not found, get the address
398 // of the other non-unicode function
399 lpFuncName[nStrLen] = 0;
400 fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
401 }
402 }
403 #else
404 // Get address of non-unicode version of the dll function if it exists
405 fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
406 fnDllWinMainW = 0;
407 if (!fnDllWinMainA) {
408 // If first non-unicode function was not found, get the address
409 // of the other non-unicode function
410 lpFuncName[nStrLen] = 'A';
411 lpFuncName[nStrLen+1] = 0;
412 fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
413 if (!fnDllWinMainA) {
414 // If non-unicode function was not found, get the address of the unicode function
415 lpFuncName[nStrLen] = 'W';
416 fnDllWinMainW = (DllWinMainW)GetProcAddress(hDll,lpFuncName);
417 }
418 }
419 #endif
420
421 free(lpFuncName);
422
423 RegisterBlankClass(hInstance);
424 // Create a window so we can pass a window handle to
425 // the dll function; this is required
426 hWindow = CreateWindowEx(0,rundll32_wclass,rundll32_wtitle,0,CW_USEDEFAULT,0,CW_USEDEFAULT,0,0,0,hInstance,0);
427
428 if (fnDllWinMainW) {
429 // Convert the command-line string to unicode and call the dll function
430 lpwCmdLine = ConvertToWideChar(lptCmdLine);
431 nRetVal = fnDllWinMainW(hWindow,hInstance,lpwCmdLine,nCmdShow);
432 FreeConvertedWideChar(lpwCmdLine);
433 }
434 else if (fnDllWinMainA) {
435 // Convert the command-line string to ansi and call the dll function
436 lpaCmdLine = ConvertToMultiByte(lptCmdLine);
437 nRetVal = fnDllWinMainA(hWindow,hInstance,lpaCmdLine,nCmdShow);
438 FreeConvertedMultiByte(lpaCmdLine);
439 }
440 else {
441 // The specified dll function was not found; display an error message
442 GetModuleTitle();
443 lptMsgBuffer = (LPTSTR)malloc((_tcslen(MissingEntry) - 4 + _tcslen(lptFuncName) + _tcslen(lptDllName) + 1) * sizeof(TCHAR));
444 _stprintf(lptMsgBuffer,MissingEntry,lptFuncName,lptDllName);
445 MessageBox(0,lptMsgBuffer,ModuleTitle,MB_ICONERROR);
446 free(lptMsgBuffer);
447 }
448
449 DestroyWindow(hWindow);
450 UnregisterClass(rundll32_wclass,hInstance);
451
452 // The dll function has finished executing, so unload it
453 FreeLibrary(hDll);
454 }
455 else {
456 // The dll could not be loaded; display an error message
457 GetModuleTitle();
458 lptMsgBuffer = (LPTSTR)malloc((_tcslen(DllNotLoaded) - 2 + _tcslen(lptDllName) + 1) * sizeof(TCHAR));
459 _stprintf(lptMsgBuffer,DllNotLoaded,lptDllName);
460 MessageBox(0,lptMsgBuffer,ModuleTitle,MB_ICONERROR);
461 free(lptMsgBuffer);
462 }
463
464 if (argv) free(argv);
465 return nRetVal;
466 }
467