ieframe: Moved dialog resources to ieframe.
[wine/testsucceed.git] / programs / winevdm / winevdm.c
blobaffac5189038d35ca831cd412a17de8217691423
1 /*
2 * Wine virtual DOS machine
4 * Copyright 2003 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "config.h"
22 #include "wine/port.h"
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <stdlib.h>
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wine/winbase16.h"
31 #include "winuser.h"
32 #include "wincon.h"
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(winevdm);
38 extern void __wine_load_dos_exe( LPCSTR filename, LPCSTR cmdline );
41 /*** PIF file structures ***/
42 #include "pshpack1.h"
44 /* header of a PIF file */
45 typedef struct {
46 BYTE unk1[2]; /* 0x00 */
47 CHAR windowtitle[ 30 ]; /* 0x02 seems to be padded with blanks*/
48 WORD memmax; /* 0x20 */
49 WORD memmin; /* 0x22 */
50 CHAR program[63]; /* 0x24 seems to be zero terminated */
51 BYTE hdrflags1; /* 0x63 various flags:
52 * 02 286: text mode selected
53 * 10 close window at exit
55 BYTE startdrive; /* 0x64 */
56 char startdir[64]; /* 0x65 */
57 char optparams[64]; /* 0xa5 seems to be zero terminated */
58 BYTE videomode; /* 0xe5 */
59 BYTE unkn2; /* 0xe6 ?*/
60 BYTE irqlow; /* 0xe7 */
61 BYTE irqhigh; /* 0xe8 */
62 BYTE rows; /* 0xe9 */
63 BYTE cols; /* 0xea */
64 BYTE winY; /* 0xeb */
65 BYTE winX; /* 0xec */
66 WORD unkn3; /* 0xed 7??? */
67 CHAR unkn4[64]; /* 0xef */
68 CHAR unkn5[64]; /* 0x12f */
69 BYTE hdrflags2; /* 0x16f */
70 BYTE hdrflags3; /* 0x170 */
71 } pifhead_t;
73 /* record header: present on every record */
74 typedef struct {
75 CHAR recordname[16]; /* zero terminated */
76 WORD posofnextrecord; /* file offset, 0xffff if last */
77 WORD startofdata; /* file offset */
78 WORD sizeofdata; /* data is expected to follow directly */
79 } recordhead_t;
81 /* 386 -enhanced mode- record */
82 typedef struct {
83 WORD memmax; /* memory desired, overrides the pif header*/
84 WORD memmin; /* memory required, overrides the pif header*/
85 WORD prifg; /* foreground priority */
86 WORD pribg; /* background priority */
87 WORD emsmax; /* EMS memory limit */
88 WORD emsmin; /* EMS memory required */
89 WORD xmsmax; /* XMS memory limit */
90 WORD xmsmin; /* XMS memory required */
91 WORD optflags; /* option flags:
92 * 0008 full screen
93 * 0004 exclusive
94 * 0002 background
95 * 0001 close when active
97 WORD memflags; /* various memory flags*/
98 WORD videoflags; /* video flags:
99 * 0010 text
100 * 0020 med. res. graphics
101 * 0040 hi. res. graphics
103 WORD hotkey[9]; /* Hot key info */
104 CHAR optparams[64]; /* optional params, replaces those in the pif header */
105 } pif386rec_t;
107 #include "poppack.h"
109 /***********************************************************************
110 * find_dosbox
112 static char *find_dosbox(void)
114 const char *envpath = getenv( "PATH" );
115 struct stat st;
116 char *path, *p, *buffer, *dir;
117 size_t envpath_len;
119 if (!envpath) return NULL;
121 envpath_len = strlen( envpath );
122 path = HeapAlloc( GetProcessHeap(), 0, envpath_len + 1 );
123 buffer = HeapAlloc( GetProcessHeap(), 0, envpath_len + sizeof("/dosbox") );
124 strcpy( path, envpath );
126 p = path;
127 while (*p)
129 while (*p == ':') p++;
130 if (!*p) break;
131 dir = p;
132 while (*p && *p != ':') p++;
133 if (*p == ':') *p++ = 0;
134 strcpy( buffer, dir );
135 strcat( buffer, "/dosbox" );
136 if (!stat( buffer, &st ))
138 HeapFree( GetProcessHeap(), 0, path );
139 return buffer;
142 HeapFree( GetProcessHeap(), 0, buffer );
143 HeapFree( GetProcessHeap(), 0, path );
144 return NULL;
148 /***********************************************************************
149 * start_dosbox
151 static void start_dosbox( const char *appname, const char *args )
153 static const WCHAR cfgW[] = {'c','f','g',0};
154 const char *config_dir = wine_get_config_dir();
155 WCHAR path[MAX_PATH], config[MAX_PATH];
156 HANDLE file;
157 char *p, *buffer;
158 int i;
159 int ret = 1;
160 DWORD written, drives = GetLogicalDrives();
161 char *dosbox = find_dosbox();
163 if (!dosbox) return;
164 if (!GetTempPathW( MAX_PATH, path )) return;
165 if (!GetTempFileNameW( path, cfgW, 0, config )) return;
166 if (!GetCurrentDirectoryW( MAX_PATH, path )) return;
167 file = CreateFileW( config, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
168 if (file == INVALID_HANDLE_VALUE) return;
170 buffer = HeapAlloc( GetProcessHeap(), 0, sizeof("[autoexec]") +
171 sizeof("mount -z c") + sizeof("config -securemode") +
172 25 * (strlen(config_dir) + sizeof("mount c /dosdevices/c:")) +
173 4 * strlenW( path ) +
174 6 + strlen( appname ) + strlen( args ) + 20 );
175 p = buffer;
176 p += sprintf( p, "[autoexec]\n" );
177 for (i = 25; i >= 0; i--)
178 if (!(drives & (1 << i)))
180 p += sprintf( p, "mount -z %c\n", 'a' + i );
181 break;
183 for (i = 0; i <= 25; i++)
184 if (drives & (1 << i))
185 p += sprintf( p, "mount %c %s/dosdevices/%c:\n", 'a' + i, config_dir, 'a' + i );
186 p += sprintf( p, "%c:\ncd ", path[0] );
187 p += WideCharToMultiByte( CP_UNIXCP, 0, path + 2, -1, p, 4 * strlenW(path), NULL, NULL ) - 1;
188 p += sprintf( p, "\nconfig -securemode\n" );
189 p += sprintf( p, "%s %s\n", appname, args );
190 p += sprintf( p, "exit\n" );
191 if (WriteFile( file, buffer, strlen(buffer), &written, NULL ) && written == strlen(buffer))
193 const char *args[4];
194 char *config_file = wine_get_unix_file_name( config );
195 args[0] = dosbox;
196 args[1] = "-conf";
197 args[2] = config_file;
198 args[3] = NULL;
199 ret = spawnvp( _P_WAIT, args[0], args );
201 CloseHandle( file );
202 DeleteFileW( config );
203 HeapFree( GetProcessHeap(), 0, buffer );
204 ExitProcess( ret );
208 /***********************************************************************
209 * start_dos_exe
211 static void start_dos_exe( LPCSTR filename, LPCSTR cmdline )
213 MEMORY_BASIC_INFORMATION mem_info;
214 const char *reason;
216 if (VirtualQuery( NULL, &mem_info, sizeof(mem_info) ) && mem_info.State != MEM_FREE)
218 __wine_load_dos_exe( filename, cmdline );
219 if (GetLastError() == ERROR_NOT_SUPPORTED)
220 reason = "because vm86 mode is not supported on this platform";
221 else
222 reason = wine_dbg_sprintf( "It failed with error code %u", GetLastError() );
224 else reason = "because the DOS memory range is unavailable";
226 start_dosbox( filename, cmdline );
228 WINE_MESSAGE( "winevdm: Cannot start DOS application %s\n", filename );
229 WINE_MESSAGE( " %s.\n", reason );
230 WINE_MESSAGE( " Try running this application with DOSBox.\n" );
231 ExitProcess(1);
234 /***********************************************************************
235 * read_pif_file
236 *pif386rec_tu
237 * Read a pif file and return the header and possibly the 286 (real mode)
238 * record or 386 (enhanced mode) record. Returns FALSE if the file is
239 * invalid otherwise TRUE.
241 static BOOL read_pif_file( HANDLE hFile, char *progname, char *title,
242 char *optparams, char *startdir, int *closeonexit, int *textmode)
244 DWORD nread;
245 LARGE_INTEGER filesize;
246 recordhead_t rhead;
247 BOOL found386rec = FALSE;
248 pif386rec_t pif386rec;
249 pifhead_t pifheader;
250 if( !GetFileSizeEx( hFile, &filesize) ||
251 filesize.QuadPart < (sizeof(pifhead_t) + sizeof(recordhead_t))) {
252 WINE_ERR("Invalid pif file: size error %d\n", (int)filesize.QuadPart);
253 return FALSE;
255 SetFilePointer( hFile, 0, NULL, FILE_BEGIN);
256 if( !ReadFile( hFile, &pifheader, sizeof(pifhead_t), &nread, NULL))
257 return FALSE;
258 WINE_TRACE("header: program %s title %s startdir %s params %s\n",
259 wine_dbgstr_a(pifheader.program),
260 wine_dbgstr_an(pifheader.windowtitle, sizeof(pifheader.windowtitle)),
261 wine_dbgstr_a(pifheader.startdir),
262 wine_dbgstr_a(pifheader.optparams));
263 WINE_TRACE("header: memory req'd %d desr'd %d drive %d videomode %d\n",
264 pifheader.memmin, pifheader.memmax, pifheader.startdrive,
265 pifheader.videomode);
266 WINE_TRACE("header: flags 0x%x 0x%x 0x%x\n",
267 pifheader.hdrflags1, pifheader.hdrflags2, pifheader.hdrflags3);
268 ReadFile( hFile, &rhead, sizeof(recordhead_t), &nread, NULL);
269 if( strncmp( rhead.recordname, "MICROSOFT PIFEX", 15)) {
270 WINE_ERR("Invalid pif file: magic string not found\n");
271 return FALSE;
273 /* now process the following records */
274 while( 1) {
275 WORD nextrecord = rhead.posofnextrecord;
276 if( (nextrecord & 0x8000) ||
277 filesize.QuadPart <( nextrecord + sizeof(recordhead_t))) break;
278 if( !SetFilePointer( hFile, nextrecord, NULL, FILE_BEGIN) ||
279 !ReadFile( hFile, &rhead, sizeof(recordhead_t), &nread, NULL))
280 return FALSE;
281 if( !rhead.recordname[0]) continue; /* deleted record */
282 WINE_TRACE("reading record %s size %d next 0x%x\n",
283 wine_dbgstr_a(rhead.recordname), rhead.sizeofdata,
284 rhead.posofnextrecord );
285 if( !strncmp( rhead.recordname, "WINDOWS 386", 11)) {
286 found386rec = TRUE;
287 ReadFile( hFile, &pif386rec, sizeof(pif386rec_t), &nread, NULL);
288 WINE_TRACE("386rec: memory req'd %d des'd %d EMS req'd %d des'd %d XMS req'd %d des'd %d\n",
289 pif386rec.memmin, pif386rec.memmax,
290 pif386rec.emsmin, pif386rec.emsmax,
291 pif386rec.xmsmin, pif386rec.xmsmax);
292 WINE_TRACE("386rec: option 0x%x memory 0x%x video 0x%x\n",
293 pif386rec.optflags, pif386rec.memflags,
294 pif386rec.videoflags);
295 WINE_TRACE("386rec: optional parameters %s\n",
296 wine_dbgstr_a(pif386rec.optparams));
299 /* prepare the return data */
300 strncpy( progname, pifheader.program, sizeof(pifheader.program));
301 memcpy( title, pifheader.windowtitle, sizeof(pifheader.windowtitle));
302 title[ sizeof(pifheader.windowtitle) ] = '\0';
303 if( found386rec)
304 strncpy( optparams, pif386rec.optparams, sizeof( pif386rec.optparams));
305 else
306 strncpy( optparams, pifheader.optparams, sizeof(pifheader.optparams));
307 strncpy( startdir, pifheader.startdir, sizeof(pifheader.startdir));
308 *closeonexit = pifheader.hdrflags1 & 0x10;
309 *textmode = found386rec ? pif386rec.videoflags & 0x0010
310 : pifheader.hdrflags1 & 0x0002;
311 return TRUE;
314 /***********************************************************************
315 * pif_cmd
317 * execute a pif file.
319 static VOID pif_cmd( char *filename, char *cmdline)
321 HANDLE hFile;
322 char progpath[MAX_PATH];
323 char buf[128];
324 char progname[64];
325 char title[31];
326 char optparams[64];
327 char startdir[64];
328 char *p;
329 int closeonexit;
330 int textmode;
331 if( (hFile = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ,
332 NULL, OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
334 WINE_ERR("open file %s failed\n", wine_dbgstr_a(filename));
335 return;
337 if( !read_pif_file( hFile, progname, title, optparams, startdir,
338 &closeonexit, &textmode)) {
339 WINE_ERR( "failed to read %s\n", wine_dbgstr_a(filename));
340 CloseHandle( hFile);
341 sprintf( buf, "%s\nInvalid file format. Check your pif file.",
342 filename);
343 MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONWARNING);
344 SetLastError( ERROR_BAD_FORMAT);
345 return;
347 CloseHandle( hFile);
348 if( (p = strrchr( progname, '.')) && !strcasecmp( p, ".bat"))
349 WINE_FIXME(".bat programs in pif files are not supported.\n");
350 /* first change dir, so the search below can start from there */
351 if( startdir[0] && !SetCurrentDirectoryA( startdir)) {
352 WINE_ERR("Cannot change directory %s\n", wine_dbgstr_a( startdir));
353 sprintf( buf, "%s\nInvalid startup directory. Check your pif file.",
354 filename);
355 MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONWARNING);
357 /* search for the program */
358 if( !SearchPathA( NULL, progname, NULL, MAX_PATH, progpath, NULL )) {
359 sprintf( buf, "%s\nInvalid program file name. Check your pif file.",
360 filename);
361 MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONERROR);
362 SetLastError( ERROR_FILE_NOT_FOUND);
363 return;
365 if( textmode)
366 if( AllocConsole())
367 SetConsoleTitleA( title) ;
368 /* if no arguments on the commandline, use them from the pif file */
369 if( !cmdline[0] && optparams[0])
370 cmdline = optparams;
371 /* FIXME: do something with:
372 * - close on exit
373 * - graphic modes
374 * - hot key's
375 * - etc.
377 start_dos_exe( progpath, cmdline );
380 /***********************************************************************
381 * build_command_line
383 * Build the command line of a process from the argv array.
384 * Copied from ENV_BuildCommandLine.
386 static char *build_command_line( char **argv )
388 int len;
389 char *p, **arg, *cmd_line;
391 len = 0;
392 for (arg = argv; *arg; arg++)
394 int has_space,bcount;
395 char* a;
397 has_space=0;
398 bcount=0;
399 a=*arg;
400 if( !*a ) has_space=1;
401 while (*a!='\0') {
402 if (*a=='\\') {
403 bcount++;
404 } else {
405 if (*a==' ' || *a=='\t') {
406 has_space=1;
407 } else if (*a=='"') {
408 /* doubling of '\' preceding a '"',
409 * plus escaping of said '"'
411 len+=2*bcount+1;
413 bcount=0;
415 a++;
417 len+=(a-*arg)+1 /* for the separating space */;
418 if (has_space)
419 len+=2; /* for the quotes */
422 if (!(cmd_line = HeapAlloc( GetProcessHeap(), 0, len ? len + 1 : 2 )))
423 return NULL;
425 p = cmd_line;
426 *p++ = (len < 256) ? len : 255;
427 for (arg = argv; *arg; arg++)
429 int has_space,has_quote;
430 char* a;
432 /* Check for quotes and spaces in this argument */
433 has_space=has_quote=0;
434 a=*arg;
435 if( !*a ) has_space=1;
436 while (*a!='\0') {
437 if (*a==' ' || *a=='\t') {
438 has_space=1;
439 if (has_quote)
440 break;
441 } else if (*a=='"') {
442 has_quote=1;
443 if (has_space)
444 break;
446 a++;
449 /* Now transfer it to the command line */
450 if (has_space)
451 *p++='"';
452 if (has_quote) {
453 int bcount;
454 char* a;
456 bcount=0;
457 a=*arg;
458 while (*a!='\0') {
459 if (*a=='\\') {
460 *p++=*a;
461 bcount++;
462 } else {
463 if (*a=='"') {
464 int i;
466 /* Double all the '\\' preceding this '"', plus one */
467 for (i=0;i<=bcount;i++)
468 *p++='\\';
469 *p++='"';
470 } else {
471 *p++=*a;
473 bcount=0;
475 a++;
477 } else {
478 strcpy(p,*arg);
479 p+=strlen(*arg);
481 if (has_space)
482 *p++='"';
483 *p++=' ';
485 if (len) p--; /* remove last space */
486 *p = '\0';
487 return cmd_line;
491 /***********************************************************************
492 * usage
494 static void usage(void)
496 WINE_MESSAGE( "Usage: winevdm.exe [--app-name app.exe] command line\n\n" );
497 ExitProcess(1);
501 /***********************************************************************
502 * main
504 int main( int argc, char *argv[] )
506 DWORD count;
507 HINSTANCE16 instance;
508 LOADPARAMS16 params;
509 WORD showCmd[2];
510 char buffer[MAX_PATH];
511 STARTUPINFOA info;
512 char *cmdline, *appname, **first_arg;
513 char *p;
515 if (!argv[1]) usage();
517 if (!strcmp( argv[1], "--app-name" ))
519 if (!(appname = argv[2])) usage();
520 first_arg = argv + 3;
522 else
524 if (!SearchPathA( NULL, argv[1], ".exe", sizeof(buffer), buffer, NULL ))
526 WINE_MESSAGE( "winevdm: unable to exec '%s': file not found\n", argv[1] );
527 ExitProcess(1);
529 appname = buffer;
530 first_arg = argv + 1;
533 if (*first_arg) first_arg++; /* skip program name */
534 cmdline = build_command_line( first_arg );
536 if (WINE_TRACE_ON(winevdm))
538 int i;
539 WINE_TRACE( "GetCommandLine = '%s'\n", GetCommandLineA() );
540 WINE_TRACE( "appname = '%s'\n", appname );
541 WINE_TRACE( "cmdline = '%.*s'\n", cmdline[0], cmdline+1 );
542 for (i = 0; argv[i]; i++) WINE_TRACE( "argv[%d]: '%s'\n", i, argv[i] );
545 GetStartupInfoA( &info );
546 showCmd[0] = 2;
547 showCmd[1] = (info.dwFlags & STARTF_USESHOWWINDOW) ? info.wShowWindow : SW_SHOWNORMAL;
549 params.hEnvironment = 0;
550 params.cmdLine = MapLS( cmdline );
551 params.showCmd = MapLS( showCmd );
552 params.reserved = 0;
554 RestoreThunkLock(1); /* grab the Win16 lock */
556 /* some programs assume mmsystem is always present */
557 LoadLibrary16( "gdi.exe" );
558 LoadLibrary16( "user.exe" );
559 LoadLibrary16( "mmsystem.dll" );
561 if ((instance = LoadModule16( appname, &params )) < 32)
563 if (instance == 11)
565 /* first see if it is a .pif file */
566 if( ( p = strrchr( appname, '.' )) && !strcasecmp( p, ".pif"))
567 pif_cmd( appname, cmdline + 1);
568 else
570 /* try DOS format */
571 /* loader expects arguments to be regular C strings */
572 start_dos_exe( appname, cmdline + 1 );
574 /* if we get back here it failed */
575 instance = GetLastError();
578 WINE_MESSAGE( "winevdm: can't exec '%s': ", appname );
579 switch (instance)
581 case 2: WINE_MESSAGE("file not found\n" ); break;
582 case 11: WINE_MESSAGE("invalid program file\n" ); break;
583 default: WINE_MESSAGE("error=%d\n", instance ); break;
585 ExitProcess(instance);
588 /* wait forever; the process will be killed when the last task exits */
589 ReleaseThunkLock( &count );
590 Sleep( INFINITE );
591 return 0;