msi: Implement session object directly on top of automation object.
[wine/multimedia.git] / programs / winevdm / winevdm.c
blob288fa019ef4b54410a8351659fcc3b7993e8d34d
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, app[MAX_PATH];
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 if (!GetShortPathNameA( appname, app, MAX_PATH )) return;
168 GetShortPathNameW( path, path, MAX_PATH );
169 file = CreateFileW( config, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
170 if (file == INVALID_HANDLE_VALUE) return;
172 buffer = HeapAlloc( GetProcessHeap(), 0, sizeof("[autoexec]") +
173 sizeof("mount -z c") + sizeof("config -securemode") +
174 25 * (strlen(config_dir) + sizeof("mount c /dosdevices/c:")) +
175 4 * strlenW( path ) +
176 6 + strlen( app ) + strlen( args ) + 20 );
177 p = buffer;
178 p += sprintf( p, "[autoexec]\n" );
179 for (i = 25; i >= 0; i--)
180 if (!(drives & (1 << i)))
182 p += sprintf( p, "mount -z %c\n", 'a' + i );
183 break;
185 for (i = 0; i <= 25; i++)
186 if (drives & (1 << i))
187 p += sprintf( p, "mount %c %s/dosdevices/%c:\n", 'a' + i, config_dir, 'a' + i );
188 p += sprintf( p, "%c:\ncd ", path[0] );
189 p += WideCharToMultiByte( CP_UNIXCP, 0, path + 2, -1, p, 4 * strlenW(path), NULL, NULL ) - 1;
190 p += sprintf( p, "\nconfig -securemode\n" );
191 p += sprintf( p, "%s %s\n", app, args );
192 p += sprintf( p, "exit\n" );
193 if (WriteFile( file, buffer, strlen(buffer), &written, NULL ) && written == strlen(buffer))
195 const char *args[4];
196 char *config_file = wine_get_unix_file_name( config );
197 args[0] = dosbox;
198 args[1] = "-conf";
199 args[2] = config_file;
200 args[3] = NULL;
201 ret = spawnvp( _P_WAIT, args[0], args );
203 CloseHandle( file );
204 DeleteFileW( config );
205 HeapFree( GetProcessHeap(), 0, buffer );
206 ExitProcess( ret );
210 /***********************************************************************
211 * start_dos_exe
213 static void start_dos_exe( LPCSTR filename, LPCSTR cmdline )
215 MEMORY_BASIC_INFORMATION mem_info;
216 const char *reason;
218 if (VirtualQuery( NULL, &mem_info, sizeof(mem_info) ) && mem_info.State != MEM_FREE)
220 __wine_load_dos_exe( filename, cmdline );
221 if (GetLastError() == ERROR_NOT_SUPPORTED)
222 reason = "because vm86 mode is not supported on this platform";
223 else
224 reason = wine_dbg_sprintf( "It failed with error code %u", GetLastError() );
226 else reason = "because the DOS memory range is unavailable";
228 start_dosbox( filename, cmdline );
230 WINE_MESSAGE( "winevdm: Cannot start DOS application %s\n", filename );
231 WINE_MESSAGE( " %s.\n", reason );
232 WINE_MESSAGE( " Try running this application with DOSBox.\n" );
233 ExitProcess(1);
236 /***********************************************************************
237 * read_pif_file
238 *pif386rec_tu
239 * Read a pif file and return the header and possibly the 286 (real mode)
240 * record or 386 (enhanced mode) record. Returns FALSE if the file is
241 * invalid otherwise TRUE.
243 static BOOL read_pif_file( HANDLE hFile, char *progname, char *title,
244 char *optparams, char *startdir, int *closeonexit, int *textmode)
246 DWORD nread;
247 LARGE_INTEGER filesize;
248 recordhead_t rhead;
249 BOOL found386rec = FALSE;
250 pif386rec_t pif386rec;
251 pifhead_t pifheader;
252 if( !GetFileSizeEx( hFile, &filesize) ||
253 filesize.QuadPart < (sizeof(pifhead_t) + sizeof(recordhead_t))) {
254 WINE_ERR("Invalid pif file: size error %d\n", (int)filesize.QuadPart);
255 return FALSE;
257 SetFilePointer( hFile, 0, NULL, FILE_BEGIN);
258 if( !ReadFile( hFile, &pifheader, sizeof(pifhead_t), &nread, NULL))
259 return FALSE;
260 WINE_TRACE("header: program %s title %s startdir %s params %s\n",
261 wine_dbgstr_a(pifheader.program),
262 wine_dbgstr_an(pifheader.windowtitle, sizeof(pifheader.windowtitle)),
263 wine_dbgstr_a(pifheader.startdir),
264 wine_dbgstr_a(pifheader.optparams));
265 WINE_TRACE("header: memory req'd %d desr'd %d drive %d videomode %d\n",
266 pifheader.memmin, pifheader.memmax, pifheader.startdrive,
267 pifheader.videomode);
268 WINE_TRACE("header: flags 0x%x 0x%x 0x%x\n",
269 pifheader.hdrflags1, pifheader.hdrflags2, pifheader.hdrflags3);
270 ReadFile( hFile, &rhead, sizeof(recordhead_t), &nread, NULL);
271 if( strncmp( rhead.recordname, "MICROSOFT PIFEX", 15)) {
272 WINE_ERR("Invalid pif file: magic string not found\n");
273 return FALSE;
275 /* now process the following records */
276 while( 1) {
277 WORD nextrecord = rhead.posofnextrecord;
278 if( (nextrecord & 0x8000) ||
279 filesize.QuadPart <( nextrecord + sizeof(recordhead_t))) break;
280 if( !SetFilePointer( hFile, nextrecord, NULL, FILE_BEGIN) ||
281 !ReadFile( hFile, &rhead, sizeof(recordhead_t), &nread, NULL))
282 return FALSE;
283 if( !rhead.recordname[0]) continue; /* deleted record */
284 WINE_TRACE("reading record %s size %d next 0x%x\n",
285 wine_dbgstr_a(rhead.recordname), rhead.sizeofdata,
286 rhead.posofnextrecord );
287 if( !strncmp( rhead.recordname, "WINDOWS 386", 11)) {
288 found386rec = TRUE;
289 ReadFile( hFile, &pif386rec, sizeof(pif386rec_t), &nread, NULL);
290 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",
291 pif386rec.memmin, pif386rec.memmax,
292 pif386rec.emsmin, pif386rec.emsmax,
293 pif386rec.xmsmin, pif386rec.xmsmax);
294 WINE_TRACE("386rec: option 0x%x memory 0x%x video 0x%x\n",
295 pif386rec.optflags, pif386rec.memflags,
296 pif386rec.videoflags);
297 WINE_TRACE("386rec: optional parameters %s\n",
298 wine_dbgstr_a(pif386rec.optparams));
301 /* prepare the return data */
302 strncpy( progname, pifheader.program, sizeof(pifheader.program));
303 memcpy( title, pifheader.windowtitle, sizeof(pifheader.windowtitle));
304 title[ sizeof(pifheader.windowtitle) ] = '\0';
305 if( found386rec)
306 strncpy( optparams, pif386rec.optparams, sizeof( pif386rec.optparams));
307 else
308 strncpy( optparams, pifheader.optparams, sizeof(pifheader.optparams));
309 strncpy( startdir, pifheader.startdir, sizeof(pifheader.startdir));
310 *closeonexit = pifheader.hdrflags1 & 0x10;
311 *textmode = found386rec ? pif386rec.videoflags & 0x0010
312 : pifheader.hdrflags1 & 0x0002;
313 return TRUE;
316 /***********************************************************************
317 * pif_cmd
319 * execute a pif file.
321 static VOID pif_cmd( char *filename, char *cmdline)
323 HANDLE hFile;
324 char progpath[MAX_PATH];
325 char buf[128];
326 char progname[64];
327 char title[31];
328 char optparams[64];
329 char startdir[64];
330 char *p;
331 int closeonexit;
332 int textmode;
333 if( (hFile = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ,
334 NULL, OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
336 WINE_ERR("open file %s failed\n", wine_dbgstr_a(filename));
337 return;
339 if( !read_pif_file( hFile, progname, title, optparams, startdir,
340 &closeonexit, &textmode)) {
341 WINE_ERR( "failed to read %s\n", wine_dbgstr_a(filename));
342 CloseHandle( hFile);
343 sprintf( buf, "%s\nInvalid file format. Check your pif file.",
344 filename);
345 MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONWARNING);
346 SetLastError( ERROR_BAD_FORMAT);
347 return;
349 CloseHandle( hFile);
350 if( (p = strrchr( progname, '.')) && !strcasecmp( p, ".bat"))
351 WINE_FIXME(".bat programs in pif files are not supported.\n");
352 /* first change dir, so the search below can start from there */
353 if( startdir[0] && !SetCurrentDirectoryA( startdir)) {
354 WINE_ERR("Cannot change directory %s\n", wine_dbgstr_a( startdir));
355 sprintf( buf, "%s\nInvalid startup directory. Check your pif file.",
356 filename);
357 MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONWARNING);
359 /* search for the program */
360 if( !SearchPathA( NULL, progname, NULL, MAX_PATH, progpath, NULL )) {
361 sprintf( buf, "%s\nInvalid program file name. Check your pif file.",
362 filename);
363 MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONERROR);
364 SetLastError( ERROR_FILE_NOT_FOUND);
365 return;
367 if( textmode)
368 if( AllocConsole())
369 SetConsoleTitleA( title) ;
370 /* if no arguments on the commandline, use them from the pif file */
371 if( !cmdline[0] && optparams[0])
372 cmdline = optparams;
373 /* FIXME: do something with:
374 * - close on exit
375 * - graphic modes
376 * - hot key's
377 * - etc.
379 start_dos_exe( progpath, cmdline );
382 /***********************************************************************
383 * build_command_line
385 * Build the command line of a process from the argv array.
386 * Copied from ENV_BuildCommandLine.
388 static char *build_command_line( char **argv )
390 int len;
391 char *p, **arg, *cmd_line;
393 len = 0;
394 for (arg = argv; *arg; arg++)
396 int has_space,bcount;
397 char* a;
399 has_space=0;
400 bcount=0;
401 a=*arg;
402 if( !*a ) has_space=1;
403 while (*a!='\0') {
404 if (*a=='\\') {
405 bcount++;
406 } else {
407 if (*a==' ' || *a=='\t') {
408 has_space=1;
409 } else if (*a=='"') {
410 /* doubling of '\' preceding a '"',
411 * plus escaping of said '"'
413 len+=2*bcount+1;
415 bcount=0;
417 a++;
419 len+=(a-*arg)+1 /* for the separating space */;
420 if (has_space)
421 len+=2; /* for the quotes */
424 if (!(cmd_line = HeapAlloc( GetProcessHeap(), 0, len ? len + 1 : 2 )))
425 return NULL;
427 p = cmd_line;
428 *p++ = (len < 256) ? len : 255;
429 for (arg = argv; *arg; arg++)
431 int has_space,has_quote;
432 char* a;
434 /* Check for quotes and spaces in this argument */
435 has_space=has_quote=0;
436 a=*arg;
437 if( !*a ) has_space=1;
438 while (*a!='\0') {
439 if (*a==' ' || *a=='\t') {
440 has_space=1;
441 if (has_quote)
442 break;
443 } else if (*a=='"') {
444 has_quote=1;
445 if (has_space)
446 break;
448 a++;
451 /* Now transfer it to the command line */
452 if (has_space)
453 *p++='"';
454 if (has_quote) {
455 int bcount;
456 char* a;
458 bcount=0;
459 a=*arg;
460 while (*a!='\0') {
461 if (*a=='\\') {
462 *p++=*a;
463 bcount++;
464 } else {
465 if (*a=='"') {
466 int i;
468 /* Double all the '\\' preceding this '"', plus one */
469 for (i=0;i<=bcount;i++)
470 *p++='\\';
471 *p++='"';
472 } else {
473 *p++=*a;
475 bcount=0;
477 a++;
479 } else {
480 strcpy(p,*arg);
481 p+=strlen(*arg);
483 if (has_space)
484 *p++='"';
485 *p++=' ';
487 if (len) p--; /* remove last space */
488 *p = '\0';
489 return cmd_line;
493 /***********************************************************************
494 * usage
496 static void usage(void)
498 WINE_MESSAGE( "Usage: winevdm.exe [--app-name app.exe] command line\n\n" );
499 ExitProcess(1);
503 /***********************************************************************
504 * main
506 int main( int argc, char *argv[] )
508 DWORD count;
509 HINSTANCE16 instance;
510 LOADPARAMS16 params;
511 WORD showCmd[2];
512 char buffer[MAX_PATH];
513 STARTUPINFOA info;
514 char *cmdline, *appname, **first_arg;
515 char *p;
517 if (!argv[1]) usage();
519 if (!strcmp( argv[1], "--app-name" ))
521 if (!(appname = argv[2])) usage();
522 first_arg = argv + 3;
524 else
526 if (!SearchPathA( NULL, argv[1], ".exe", sizeof(buffer), buffer, NULL ))
528 WINE_MESSAGE( "winevdm: unable to exec '%s': file not found\n", argv[1] );
529 ExitProcess(1);
531 appname = buffer;
532 first_arg = argv + 1;
535 if (*first_arg) first_arg++; /* skip program name */
536 cmdline = build_command_line( first_arg );
538 if (WINE_TRACE_ON(winevdm))
540 int i;
541 WINE_TRACE( "GetCommandLine = '%s'\n", GetCommandLineA() );
542 WINE_TRACE( "appname = '%s'\n", appname );
543 WINE_TRACE( "cmdline = '%.*s'\n", cmdline[0], cmdline+1 );
544 for (i = 0; argv[i]; i++) WINE_TRACE( "argv[%d]: '%s'\n", i, argv[i] );
547 GetStartupInfoA( &info );
548 showCmd[0] = 2;
549 showCmd[1] = (info.dwFlags & STARTF_USESHOWWINDOW) ? info.wShowWindow : SW_SHOWNORMAL;
551 params.hEnvironment = 0;
552 params.cmdLine = MapLS( cmdline );
553 params.showCmd = MapLS( showCmd );
554 params.reserved = 0;
556 RestoreThunkLock(1); /* grab the Win16 lock */
558 /* some programs assume mmsystem is always present */
559 LoadLibrary16( "gdi.exe" );
560 LoadLibrary16( "user.exe" );
561 LoadLibrary16( "mmsystem.dll" );
563 if ((instance = LoadModule16( appname, &params )) < 32)
565 if (instance == 11)
567 /* first see if it is a .pif file */
568 if( ( p = strrchr( appname, '.' )) && !strcasecmp( p, ".pif"))
569 pif_cmd( appname, cmdline + 1);
570 else
572 /* try DOS format */
573 /* loader expects arguments to be regular C strings */
574 start_dos_exe( appname, cmdline + 1 );
576 /* if we get back here it failed */
577 instance = GetLastError();
580 WINE_MESSAGE( "winevdm: can't exec '%s': ", appname );
581 switch (instance)
583 case 2: WINE_MESSAGE("file not found\n" ); break;
584 case 11: WINE_MESSAGE("invalid program file\n" ); break;
585 default: WINE_MESSAGE("error=%d\n", instance ); break;
587 ExitProcess(instance);
590 /* wait forever; the process will be killed when the last task exits */
591 ReleaseThunkLock( &count );
592 Sleep( INFINITE );
593 return 0;