source: trunk/src/winmm/mci.cpp@ 10366

Last change on this file since 10366 was 10173, checked in by sandervl, 22 years ago

KOM: fixed potential buffer overflows in *GetErrorString functions
File size: 31.9 KB
Line 
1/* $Id: mci.cpp,v 1.9 2003-07-16 15:47:23 sandervl Exp $ */
2
3/*
4 * MCI functions
5 *
6 * Copyright 1998 Joel Troster
7 * Copyright 1998/1999 Eric Pouech
8 * Copyright 2000 Chris Wohlgemuth
9 *
10 * Project Odin Software License can be found in LICENSE.TXT
11 *
12 */
13
14
15/****************************************************************************
16 * Includes *
17 ****************************************************************************/
18
19#define INCL_BASE
20#define INCL_OS2MM
21
22#include <os2win.h>
23#include <mmsystem.h>
24#include <odinwrap.h>
25#include <string.h>
26#include <stdio.h>
27#include "debugtools.h"
28
29#include <misc.h>
30#include <unicode.h>
31
32#include "mcimm.h"
33
34#include "winmm.h"
35
36#define DBG_LOCALLOG DBG_mci
37#include "dbglocal.h"
38
39
40/****************************************************************************
41 * Local functions *
42 ****************************************************************************/
43
44/* forward declaration */
45static DWORD MCI_SendCommand(UINT mciId,
46 UINT16 uMsg,
47 DWORD dwParam1,
48 DWORD dwParam2);
49
50static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) ;
51static UINT MCI_GetDriverFromString(LPCSTR lpstrName);
52
53/****************************************************************************/
54
55
56BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID, UINT uStatus)
57{
58 TRACE("Entering mciDriverNotify (%08X, %04x, %04X)\n", hwndCallback, uDeviceID, uStatus);
59
60 if (!IsWindow(hwndCallback)) {
61 WARN("bad hwnd for call back (0x%04x)\n", hwndCallback);
62 return FALSE;
63 }
64 TRACE("before PostMessage\n");
65 PostMessageA(hwndCallback, MM_MCINOTIFY, uStatus, uDeviceID);
66 return TRUE;
67}
68
69UINT WINAPI mciDriverYield(UINT uDeviceID)
70{
71 dprintf(("WINMM:mciDriverYield - stub\n"));
72 return 0;
73}
74
75BOOL WINAPI mciExecute(LPCSTR pszCommand)
76{
77 dprintf(("WINMM:mciExecute(%s) - stub\n", pszCommand));
78 return FALSE;
79}
80
81BOOL WINAPI mciFreeCommandResource(UINT uTable)
82{
83 dprintf(("WINMM:mciFreeCommandResource - stub\n"));
84 return FALSE;
85}
86
87HTASK mciGetCreatorTask(MCIDEVICEID mciId)
88{
89 dprintf(("WINMM:mciGetCreatorTask - stub\n"));
90 return 0;
91}
92
93MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR pszDevice)
94{
95 WARN(("WINMM:mciGetDeviceIDA - untested\n"));
96 return MCI_GetDriverFromString(pszDevice);
97}
98
99MCIDEVICEID WINAPI mciGetDeviceIDW(LPCWSTR pszDevice)
100{
101 dprintf(("WINMM:mciGetDeviceIDW - stub\n"));
102 return 0;
103}
104
105MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType)
106{
107 dprintf(("WINMM:mciGetDeviceIDFromElementIDA - stub\n"));
108 return 0;
109}
110
111MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
112{
113 dprintf(("WINMM:mciGetDeviceIDFromElementIDW - stub\n"));
114 return 0;
115}
116
117/*****************************************************************************
118 * Queries driver data
119 * Parameters: UINT uDeviceID
120 * Variables :
121 * @return : Pointer to driver data (as a DWORD)
122 * Remark :
123 * @status : Completely
124 *
125 * @author : Chris Wohlgemuth [Sun, 2000/11/19]
126 *****************************************************************************/
127DWORD WINAPI mciGetDriverData(UINT uDeviceID)
128{
129 LPWINE_MCIDRIVER wmd;
130
131 wmd = MCI_GetDriver(uDeviceID);
132
133 if (!wmd) {
134 dprintf(("WARNING: Bad uDeviceID (mciGetDriverData (mci.cpp line %d)\n",__LINE__));
135 return 0L; /* Error */
136 }
137
138 return wmd->dwPrivate;
139}
140
141/*****************************************************************************
142 * Converts an error to an error string
143 * Parameters: MCIERROR mcierr,
144 * LPSTR pszText,
145 * UINT cchText
146 * Variables :
147 * @return : API returncode (TRUE/FALSE)
148 * Remark :
149 * @status : Completely
150 *
151 * @author : Wine
152 *****************************************************************************/
153BOOL WINAPI mciGetErrorStringA(MCIERROR mcierr, LPSTR pszText, UINT cchText)
154{
155 dprintf(("WINMM:mciGetErrorStringA(%d)\n", mcierr ));
156 char * theMsg = getWinmmMsg( mcierr );
157 if ( theMsg )
158 strncpy( pszText, theMsg, cchText );
159 else
160 {
161 char errMsg[100];
162 sprintf( errMsg, "Unknown error number %d", mcierr );
163 strncpy( pszText, errMsg, cchText );
164 }
165 return TRUE;
166}
167
168/*****************************************************************************
169 * Converts an error to an error string
170 * Parameters: MCIERROR mcierr,
171 * LPSTR pszText,
172 * UINT cchText
173 * Variables :
174 * @return : API returncode (TRUE/FALSE)
175 * Remark :
176 * @status : Completely
177 *
178 * @author : Wine
179 *****************************************************************************/
180BOOL WINAPI mciGetErrorStringW(MCIERROR mcierr, LPWSTR pszText, UINT cchText)
181{
182 dprintf(("WINMM:mciGetErrorStringW(%d)\n", mcierr ));
183 char * theMsg = getWinmmMsg( mcierr );
184 if ( theMsg )
185 AsciiToUnicodeN( theMsg, pszText, cchText );
186 else
187 {
188 char errMsg[100];
189 sprintf( errMsg, "Unknown error number %d", mcierr );
190 AsciiToUnicodeN( errMsg, pszText, cchText );
191 }
192 return TRUE;
193}
194
195/*****************************************************************************
196 * Converts an error to an error string
197 * Parameters: MCIERROR mcierr,
198 * LPSTR pszText,
199 * UINT cchText
200 * Variables :
201 * @return : API returncode
202 * Remark :
203 * @status : Completely
204 *
205 * @author : Wine
206 *****************************************************************************/
207YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID mciId, LPDWORD pdwYieldData)
208{
209 LPWINE_MCIDRIVER wmd;
210
211 TRACE("Entering mciGetYieldProc (%u, %p) - untested\n", mciId, pdwYieldData);
212
213 if (!(wmd = MCI_GetDriver(mciId))) {
214 WARN("Bad uDeviceID\n");
215 return NULL;
216 }
217 if (!wmd->lpfnYieldProc) {
218 WARN("No proc set\n");
219 return NULL;
220 }
221 if (!wmd->bIs32) {
222 WARN("Proc is 32 bit\n");
223 return NULL;
224 }
225 return wmd->lpfnYieldProc;
226}
227
228UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance, LPCWSTR lpResName,
229 UINT uType)
230{
231 dprintf(("WINMM:mciLoadCOmmandResource - stub\n"));
232 return 0;
233}
234
235
236MCIERROR WINAPI mciSendCommandA(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1,
237 DWORD dwParam2)
238{
239 DWORD dwRet;
240 // dprintf(("WINMM:mciSendCommandA - entering %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
241 dwRet= MCI_SendCommand((UINT) mciId, uMsg, dwParam1, dwParam2) & 0xFFFF;
242 return(dwRet);
243}
244
245
246MCIERROR WINAPI mciSendCommandW(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1,
247 DWORD dwParam2)
248{
249 dprintf(("WINMM:mciSendCommandW - stub %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
250 return(MMSYSERR_NODRIVER);
251}
252
253MCIERROR WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString,
254 UINT uReturnLength, HWND hwndCallback)
255{
256 dprintf(("WINMM:mciSendStringA - stub\n"));
257 if(lpstrCommand)
258 dprintf(("WINMM:mciSendStringA command: %s\n",lpstrCommand));
259 return(MMSYSERR_NODRIVER);
260}
261
262MCIERROR WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrReturnString,
263 UINT uReturnLength, HWND hwndCallback)
264{
265 dprintf(("WINMM:mciSendStringW - stub\n"));
266 return(MMSYSERR_NODRIVER);
267}
268
269BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData)
270{
271 LPWINE_MCIDRIVER wmd;
272
273 wmd = MCI_GetDriver(uDeviceID);
274
275 if (!wmd) {
276 dprintf(("WARNING: Bad uDeviceID (mciSetDriverData line %d)\n",__LINE__));
277 return FALSE;
278 }
279
280 wmd->dwPrivate = dwData;
281 return TRUE;
282}
283
284
285BOOL WINAPI mciSetYieldProc(MCIDEVICEID mciId, YIELDPROC fpYieldProc, DWORD dwYieldData)
286{
287 LPWINE_MCIDRIVER wmd;
288
289 TRACE("WINMM:mciSetYieldProc (%u, %p, %08lx) - untested\n", mciId, fpYieldProc, dwYieldData);
290
291 if (!(wmd = MCI_GetDriver(mciId))) {
292 WARN("Bad uDeviceID\n");
293 return FALSE;
294 }
295
296 wmd->lpfnYieldProc = fpYieldProc;
297 wmd->dwYieldData = dwYieldData;
298 wmd->bIs32 = TRUE;
299
300 return TRUE;
301}
302
303
304/**************************************************************************/
305/* heap.c */
306/**************************************************************************/
307
308#ifdef __GNUC__
309#define GET_EIP() (__builtin_return_address(0))
310#define SET_EIP(ptr) ((ARENA_INUSE*)(ptr) - 1)->callerEIP = GET_EIP()
311#else
312#define GET_EIP() 0
313#define SET_EIP(ptr) /* nothing */
314#endif /* __GNUC__ */
315
316
317/**************************************************************************/
318/* mmmsystem.c */
319/**************************************************************************/
320
321static LPWINE_MM_IDATA lpFirstIData = NULL;
322
323static LPWINE_MM_IDATA MULTIMEDIA_GetIDataNoCheck(void)
324{
325 DWORD pid = GetCurrentProcessId();
326 LPWINE_MM_IDATA iData;
327
328 for (iData = lpFirstIData; iData; iData = iData->lpNextIData) {
329 if (iData->dwThisProcess == pid)
330 break;
331 }
332 return iData;
333}
334
335/**************************************************************************
336 * MULTIMEDIA_GetIData [internal]
337 */
338LPWINE_MM_IDATA MULTIMEDIA_GetIData(void)
339{
340 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIDataNoCheck();
341
342 if (!iData) {
343 dprintf(("MULTIMEDIA_GetIData: IData not found for pid=%08lx. Suicide !!!\n", GetCurrentProcessId()));
344 ExitProcess(0);
345 }
346 return iData;
347}
348
349
350/**************************************************************************
351 * MULTIMEDIA_CreateIData [internal]
352 */
353BOOL MULTIMEDIA_CreateIData(HINSTANCE hInstDLL)
354{
355 LPWINE_MM_IDATA iData;
356
357 iData = (LPWINE_MM_IDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MM_IDATA));
358
359 if (!iData)
360 return FALSE;
361 iData->hWinMM32Instance = hInstDLL;
362 iData->dwThisProcess = GetCurrentProcessId();
363 iData->lpNextIData = lpFirstIData;
364 lpFirstIData = iData;
365 InitializeCriticalSection(&iData->cs);
366 dprintf(("Created IData (%p) for pid %08lx\n", iData, iData->dwThisProcess));
367 return TRUE;
368}
369
370
371/**************************************************************************
372 * MULTIMEDIA_DeleteIData [internal]
373 */
374void MULTIMEDIA_DeleteIData(void)
375{
376 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIDataNoCheck();
377 LPWINE_MM_IDATA* ppid;
378
379 if (iData) {
380 for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) {
381 if (*ppid == iData) {
382 *ppid = iData->lpNextIData;
383 break;
384 }
385 }
386 /* FIXME: should also free content and resources allocated
387 * inside iData */
388 HeapFree(GetProcessHeap(), 0, iData);
389 }
390}
391
392
393/**************************************************************************/
394/* mmmsystem.c */
395/**************************************************************************/
396
397
398static int MCI_InstalledCount;
399static LPSTR MCI_lpInstallNames = NULL;
400
401
402/* First MCI valid device ID (0 means error) */
403#define MCI_MAGIC 0x0001
404
405
406/**************************************************************************
407 * MCI_GetDriver [internal]
408 */
409static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID)
410{
411 LPWINE_MCIDRIVER wmd = 0;
412 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
413
414 EnterCriticalSection(&iData->cs);
415 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
416 if (wmd->wDeviceID == wDevID)
417 break;
418 }
419 LeaveCriticalSection(&iData->cs);
420 return wmd;
421}
422
423/**************************************************************************
424 * MCI_GetDriverFromString [internal]
425 */
426static UINT MCI_GetDriverFromString(LPCSTR lpstrName)
427{
428 LPWINE_MCIDRIVER wmd;
429 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
430 UINT ret = 0;
431
432 if (!lpstrName)
433 return 0;
434
435 if (!lstrcmpiA(lpstrName, "ALL"))
436 return MCI_ALL_DEVICE_ID;
437
438 EnterCriticalSection(&iData->cs);
439 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
440 if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) {
441 ret = wmd->wDeviceID;
442 break;
443 }
444
445 if (wmd->lpstrDeviceType && strcmp(wmd->lpstrDeviceType, lpstrName) == 0) {
446 ret = wmd->wDeviceID;
447 break;
448 }
449
450 if (wmd->lpstrAlias && strcmp(wmd->lpstrAlias, lpstrName) == 0) {
451 ret = wmd->wDeviceID;
452 break;
453 }
454 }
455 LeaveCriticalSection(&iData->cs);
456
457 return ret;
458}
459
460
461/**************************************************************************
462 * MCI_GetDevTypeFromFileName [internal]
463 */
464static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
465{
466 LPSTR tmp;
467
468 if ((tmp = strrchr(fileName, '.'))) {
469 GetProfileStringA("mci extensions", tmp + 1, "*", buf, len);
470 if (strcmp(buf, "*") != 0) {
471 return 0;
472 }
473 dprintf(("No [mci extensions] entry for '%s' found. MCI_GetDevTypeFromFileName: line %d, file 'mci.cpp'\n", tmp, __LINE__));
474 }
475 return MCIERR_EXTENSION_NOT_FOUND;
476}
477
478
479#define MAX_MCICMDTABLE 20
480#define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE
481
482
483
484/**************************************************************************
485 * MCI_DefYieldProc [internal]
486 */
487//UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
488
489UINT16 WINAPI MCI_DefYieldProc(UINT16 wDevID, DWORD data)
490{
491 INT16 ret;
492
493#if 0
494 dprintf(("(0x%04x, 0x%08lx)\n", wDevID, data));
495#endif
496 if ((HIWORD(data) != 0 && GetActiveWindow() != HIWORD(data)) ||
497 (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
498 /* WINE stuff removed: UserYield16();*/
499 ret = 0;
500 } else {
501 MSG msg;
502
503 msg.hwnd = HIWORD(data);
504 while (!PeekMessageA(&msg, HIWORD(data), WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
505 ret = -1;
506 }
507 return ret;
508}
509
510
511/**************************************************************************
512 * MCI_UnLoadMciDriver [internal]
513 */
514static BOOL MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd)
515{
516 LPWINE_MCIDRIVER* tmp;
517
518#if 0
519 dprintf(("Entering MCI_UnLoadMciDriver...\n"));
520#endif
521 if (!wmd)
522 return TRUE;
523
524 if (wmd->hDrv)
525 CloseDriver(wmd->hDrv, 0, 0);
526
527 if (wmd->dwPrivate != 0)
528 dprintf(("Unloading mci driver with non nul dwPrivate field\n"));
529
530 EnterCriticalSection(&iData->cs);
531 for (tmp = &iData->lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) {
532 if (*tmp == wmd) {
533 *tmp = wmd->lpNext;
534 break;
535 }
536 }
537 LeaveCriticalSection(&iData->cs);
538
539 HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType);
540 HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias);
541 HeapFree(GetProcessHeap(), 0, wmd->lpstrElementName);
542
543 HeapFree(GetProcessHeap(), 0, wmd);
544 //dprintf(("Leaving MCI_UnLoadMciDriver...\n"));
545 return TRUE;
546}
547
548/**************************************************************************
549 * MCI_LoadMciDriver [internal]
550 */
551static DWORD MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp,
552 LPWINE_MCIDRIVER* lpwmd)
553{
554 LPSTR strDevTyp = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp));
555 LPWINE_MCIDRIVER wmd = (LPWINE_MCIDRIVER)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
556 MCI_OPEN_DRIVER_PARMSA modp;
557 DWORD dwRet = 0;
558 HDRVR hDrv = 0;
559
560
561 dprintf(("Entering MCI_LoadMciDriver...\n"));
562
563 if (!wmd || !strDevTyp) {
564 dwRet = MCIERR_OUT_OF_MEMORY;
565 goto errCleanUp;
566 }
567
568 wmd->lpstrDeviceType = strDevTyp;
569 wmd->lpfnYieldProc = MCI_DefYieldProc;
570 wmd->dwYieldData = VK_CANCEL;
571 wmd->hCreatorTask = NULL;
572
573
574 EnterCriticalSection(&iData->cs);
575 /* wmd must be inserted in list before sending opening the driver, coz' it
576 * may want to lookup at wDevID
577 */
578 wmd->lpNext = iData->lpMciDrvs;
579 iData->lpMciDrvs = wmd;
580
581 for (modp.wDeviceID = MCI_MAGIC;
582 MCI_GetDriver(modp.wDeviceID) != 0;
583 modp.wDeviceID++);
584
585 wmd->wDeviceID = modp.wDeviceID;
586
587 LeaveCriticalSection(&iData->cs);
588
589 dprintf(("wDevID=%04X strDevTyp: %s\n", modp.wDeviceID, strDevTyp));
590
591 modp.lpstrParams = NULL;
592
593 hDrv = OpenDriverA(strDevTyp, "mci", (LPARAM)&modp);
594
595 if (!hDrv) {
596 dprintf(("Couldn't load driver for type %s.\n"
597 "If you don't have a windows installation accessible from Wine,\n"
598 "you perhaps forgot to create a [mci] section in system.ini\n",
599 strDevTyp));
600 dwRet = MCIERR_DEVICE_NOT_INSTALLED;
601 goto errCleanUp;
602 }
603
604 /* FIXME: should also check that module's description is of the form
605 * MODULENAME:[MCI] comment
606 */
607
608 wmd->hDrv = hDrv;
609 /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
610 wmd->uSpecificCmdTable = LOWORD(modp.wCustomCommandTable);
611 wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;
612
613 dprintf(("Loaded driver %x (%s), type is %d, cmdTable=%08x\n",
614 hDrv, strDevTyp, modp.wType, modp.wCustomCommandTable));
615
616
617 wmd->wType = modp.wType;
618
619#if 0
620 dprintf(("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
621 modp.wDeviceID, modp.wType, modp.wDeviceID));
622#endif
623
624 *lpwmd = wmd;
625#if 0
626 dprintf(("Leaving MCI_LoadMciDriver succesful...\n"));
627#endif
628 return 0;
629errCleanUp:
630 MCI_UnLoadMciDriver(iData, wmd);
631 // HeapFree(GetProcessHeap(), 0, strDevTyp);<-- done in MCI_UnloadMciDriver
632 *lpwmd = 0;
633 dprintf(("Leaving MCI_LoadMciDriver on error...\n"));
634 return dwRet;
635}
636
637
638/**************************************************************************
639 * MCI_SendCommandFrom32 [internal]
640 */
641static DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
642{
643 DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
644 LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
645
646 if (!wmd) {
647 dwRet = MCIERR_INVALID_DEVICE_ID;
648 } else {
649 switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST)) {
650 case WINE_GDF_EXIST:
651 dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
652 break;
653 default:
654 dprintf(("Unknown driver %u\n", wmd->hDrv));
655 dwRet = MCIERR_DRIVER_INTERNAL;
656 }
657 }
658 return dwRet;
659}
660
661/**************************************************************************
662 * MCI_FinishOpen [internal]
663 */
664static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms,
665 DWORD dwParam)
666{
667 if (dwParam & MCI_OPEN_ELEMENT)
668 wmd->lpstrElementName = HEAP_strdupA(GetProcessHeap(), 0,
669 lpParms->lpstrElementName);
670
671 if (dwParam & MCI_OPEN_ALIAS)
672 wmd->lpstrAlias = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrAlias);
673
674 lpParms->wDeviceID = wmd->wDeviceID;
675
676 return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam,
677 (DWORD)lpParms);
678}
679
680/**************************************************************************
681 * MCI_Open [internal]
682 */
683static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
684{
685 char strDevTyp[128];
686 DWORD dwRet;
687 LPWINE_MCIDRIVER wmd = NULL;
688
689 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
690
691 dprintf(("Entering MCI_OPEN...\n"));
692
693 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
694
695 /* only two low bytes are generic, the other ones are dev type specific */
696#define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
697 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
698 MCI_NOTIFY|MCI_WAIT)
699 if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0) {
700 dprintf(("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP));
701 }
702#undef WINE_MCIDRIVER_SUPP
703
704 strDevTyp[0] = 0;
705
706 if (dwParam & MCI_OPEN_TYPE) {
707 if (dwParam & MCI_OPEN_TYPE_ID) {
708 WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
709 if (uDevType < MCI_DEVTYPE_FIRST ||
710 uDevType > MCI_DEVTYPE_LAST ||
711 !LoadStringA(iData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) /* This gets a name for the device e.g 'cdaudio' */
712 {
713 dwRet = MCIERR_BAD_INTEGER;
714 goto errCleanUp;
715 }
716 } else {
717 LPSTR ptr;
718 if (lpParms->lpstrDeviceType == NULL) {
719 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
720 goto errCleanUp;
721 }
722 strcpy(strDevTyp, lpParms->lpstrDeviceType);
723 ptr = strchr(strDevTyp, '!');
724 if (ptr) {
725 /* this behavior is not documented in windows. However, since, in
726 * some occasions, MCI_OPEN handling is translated by WinMM into
727 * a call to mciSendString("open <type>"); this code shall be correct
728 */
729 if (dwParam & MCI_OPEN_ELEMENT) {
730 dprintf(("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
731 lpParms->lpstrElementName, strDevTyp));
732 dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
733 goto errCleanUp;
734 }
735 dwParam |= MCI_OPEN_ELEMENT;
736 *ptr++ = 0;
737 /* FIXME: not a good idea to write in user supplied buffer */
738 lpParms->lpstrElementName = ptr;
739 }
740
741 }
742 dprintf(("MCI_OPEN (MCI_OPEN_TYPE): devType='%s' !\n", strDevTyp));
743 }
744
745 if (dwParam & MCI_OPEN_ELEMENT) {
746 dprintf(("lpstrElementName='%s'\n", lpParms->lpstrElementName));
747
748 if (dwParam & MCI_OPEN_ELEMENT_ID) {
749 dprintf(("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n"));
750 dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
751 goto errCleanUp;
752 }
753
754 if (!lpParms->lpstrElementName) {
755 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
756 goto errCleanUp;
757 }
758
759#if 0
760 /* Only working on my machine!! CW */
761 if(lpParms->lpstrElementName[0]=='N') {
762 dprintf(("Discarding drive N:\n"));
763 dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
764 goto errCleanUp;
765 }
766#endif
767
768 /* type, if given as a parameter, supersedes file extension */
769 if (!strDevTyp[0] &&
770 MCI_GetDevTypeFromFileName(lpParms->lpstrElementName,
771 strDevTyp, sizeof(strDevTyp))) {
772 if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) {
773 dwRet = MCIERR_EXTENSION_NOT_FOUND;
774 goto errCleanUp;
775 }
776 /* FIXME: this will not work if several CDROM drives are installed on the machine */
777 strcpy(strDevTyp, "CDAUDIO");
778 }
779 }
780
781 if (strDevTyp[0] == 0) {
782 dprintf(("Couldn't load driver (MCI_Open line %d)\n",__LINE__));
783 dwRet = MCIERR_INVALID_DEVICE_NAME;
784 goto errCleanUp;
785 }
786
787 if (dwParam & MCI_OPEN_ALIAS) {
788 dprintf(("MCI_OPEN_ALIAS requested\n"));
789 if (!lpParms->lpstrAlias) {
790 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
791 goto errCleanUp;
792 }
793 dprintf(("Alias='%s' !\n", lpParms->lpstrAlias));
794 }
795
796 if ((dwRet = MCI_LoadMciDriver(iData, strDevTyp, &wmd))) {
797 goto errCleanUp;
798 }
799
800
801 if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) {
802 dprintf(("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet));
803 /* FIXME: is dwRet the correct ret code ? */
804 goto errCleanUp;
805 }
806
807
808 /* only handled devices fall through */
809 dprintf(("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet));
810
811 if (dwParam & MCI_NOTIFY)
812 // mciDriverNotify16(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
813 dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Open (line %d)\n",__LINE__));
814
815 return 0;
816
817errCleanUp:
818
819 if (wmd) MCI_UnLoadMciDriver(iData, wmd);
820
821 if (dwParam & MCI_NOTIFY)
822 // mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
823 dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Open (line %d)\n",__LINE__));
824
825 dprintf(("Leaving MCI_Open on error...\n"));
826 return dwRet;
827}
828
829
830/**************************************************************************
831 * MCI_Close [internal]
832 */
833static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
834{
835 DWORD dwRet;
836 LPWINE_MCIDRIVER wmd;
837 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
838
839 //dprintf(("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms));
840
841 if (wDevID == MCI_ALL_DEVICE_ID) {
842 LPWINE_MCIDRIVER next;
843
844 EnterCriticalSection(&iData->cs);
845 /* FIXME: shall I notify once after all is done, or for
846 * each of the open drivers ? if the latest, which notif
847 * to return when only one fails ?
848 */
849 for (wmd = iData->lpMciDrvs; wmd; ) {
850 next = wmd->lpNext;
851 MCI_Close(wmd->wDeviceID, dwParam, lpParms);
852 wmd = next;
853 }
854 LeaveCriticalSection(&iData->cs);
855 return 0;
856 }
857
858 if (!(wmd = MCI_GetDriver(wDevID))) {
859 return MCIERR_INVALID_DEVICE_ID;
860 }
861
862 dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
863
864 MCI_UnLoadMciDriver(iData, wmd);
865
866 if (dwParam & MCI_NOTIFY)
867 dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Close (line %d)\n",__LINE__));
868 // mciDriverNotify16(lpParms->dwCallback, wDevID,
869 // (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
870
871 return dwRet;
872}
873
874
875/**************************************************************************
876 * MCI_WriteString [internal]
877 */
878DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
879{
880 DWORD ret = 0;
881
882 if (lpSrcStr) {
883 if (dstSize <= strlen(lpSrcStr)) {
884 lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
885 ret = MCIERR_PARAM_OVERFLOW;
886 } else {
887 strcpy(lpDstStr, lpSrcStr);
888 }
889 } else {
890 *lpDstStr = 0;
891 }
892 return ret;
893}
894
895
896/**************************************************************************
897 * MCI_Sysinfo [internal]
898 */
899static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
900{
901 DWORD ret = MCIERR_INVALID_DEVICE_ID;
902 LPWINE_MCIDRIVER wmd;
903 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
904
905 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
906
907 TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
908 uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
909
910 switch (dwFlags & ~MCI_SYSINFO_OPEN) {
911 case MCI_SYSINFO_QUANTITY:
912 {
913 DWORD cnt = 0;
914
915 if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST ||
916 lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
917 if (dwFlags & MCI_SYSINFO_OPEN) {
918 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
919 EnterCriticalSection(&iData->cs);
920 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
921 cnt++;
922 }
923 LeaveCriticalSection(&iData->cs);
924 } else {
925 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
926 cnt = MCI_InstalledCount;
927 }
928 } else {
929 if (dwFlags & MCI_SYSINFO_OPEN) {
930 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n",
931 lpParms->wDeviceType);
932 EnterCriticalSection(&iData->cs);
933 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
934 if (wmd->wType == lpParms->wDeviceType)
935 cnt++;
936 }
937 LeaveCriticalSection(&iData->cs);
938 } else {
939 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n",
940 lpParms->wDeviceType);
941 FIXME("Don't know how to get # of MCI devices of a given type\n");
942 cnt = 1;
943 }
944 }
945 *(DWORD*)lpParms->lpstrReturn = cnt;
946 }
947 TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
948 ret = MCI_INTEGER_RETURNED;
949 break;
950 case MCI_SYSINFO_INSTALLNAME:
951 TRACE("MCI_SYSINFO_INSTALLNAME \n");
952 if ((wmd = MCI_GetDriver(uDevID))) {
953 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize,
954 wmd->lpstrDeviceType);
955 } else {
956 *lpParms->lpstrReturn = 0;
957 ret = MCIERR_INVALID_DEVICE_ID;
958 }
959 TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
960 break;
961 case MCI_SYSINFO_NAME:
962 TRACE("MCI_SYSINFO_NAME\n");
963 if (dwFlags & MCI_SYSINFO_OPEN) {
964 FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
965 ret = MCIERR_UNRECOGNIZED_COMMAND;
966 } else if (lpParms->dwNumber > MCI_InstalledCount) {
967 ret = MCIERR_OUTOFRANGE;
968 } else {
969 DWORD count = lpParms->dwNumber;
970 LPSTR ptr = MCI_lpInstallNames;
971
972 while (--count > 0) ptr += strlen(ptr) + 1;
973 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
974 }
975 TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
976 break;
977 default:
978 TRACE("Unsupported flag value=%08lx\n", dwFlags);
979 ret = MCIERR_UNRECOGNIZED_COMMAND;
980 }
981 return ret;
982}
983
984
985/**************************************************************************
986 * MCI_Break [internal]
987 */
988static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
989{
990 DWORD dwRet = 0;
991
992 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
993
994 if (dwFlags & MCI_NOTIFY)
995 dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Break (line %d)\n",__LINE__));
996 // mciDriverNotify16(lpParms->dwCallback, wDevID,
997 // (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
998
999 return dwRet;
1000}
1001
1002
1003/**************************************************************************
1004 * MCI_SendCommand [internal]
1005 */
1006static DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1,
1007 DWORD dwParam2)
1008{
1009 DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND;
1010
1011 switch (wMsg) {
1012 case MCI_OPEN:
1013 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
1014 break;
1015 case MCI_CLOSE:
1016 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
1017 break;
1018 case MCI_SYSINFO:
1019 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
1020 break;
1021 case MCI_BREAK:
1022 dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
1023 break;
1024 // case MCI_SOUND:
1025 /* FIXME: it seems that MCI_SOUND needs the same handling as MCI_BREAK
1026 * but I couldn't get any doc on this MCI message
1027 */
1028 // break;
1029 default:
1030 if (wDevID == MCI_ALL_DEVICE_ID) {
1031 dprintf(("MCI_SendCommand: unhandled MCI_ALL_DEVICE_ID\n"));
1032 dwRet = MCIERR_CANNOT_USE_ALL;
1033 } else {
1034 dwRet=MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2);
1035 }
1036 break;
1037 }
1038 return dwRet;
1039}
1040
1041
1042
1043
1044/**************************************************************************
1045 * MULTIMEDIA_MciInit [internal]
1046 *
1047 * Initializes the MCI internal variables.
1048 *
1049 */
1050BOOL MULTIMEDIA_MciInit(void)
1051{
1052 LPSTR ptr1, ptr2;
1053 HKEY hWineConf;
1054 HKEY hkey;
1055 DWORD err;
1056 DWORD type;
1057 DWORD count = 2048;
1058
1059 MCI_InstalledCount = 0;
1060 ptr1 = MCI_lpInstallNames = (char*) HeapAlloc(GetProcessHeap(), 0, count);
1061
1062 if (!MCI_lpInstallNames)
1063 return FALSE;
1064
1065#if 0
1066 /* FIXME: should do also some registry diving here ? */
1067 if (!(err = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) &&
1068 !(err = RegOpenKeyA(hWineConf, "options", &hkey))) {
1069 err = RegQueryValueExA(hkey, "mci", 0, &type, MCI_lpInstallNames, &count);
1070 RegCloseKey(hkey);
1071 FIXME("Registry handling for mci drivers not changed for odin yet. Verbatim copy from WINE (line %d)",__LINE__);
1072 }
1073#endif
1074 FIXME("No Registry querying for mci drivers yet! (line %d)",__LINE__);
1075 err=1;
1076 if (!err) {
1077 TRACE("Wine => '%s' \n", ptr1);
1078 while ((ptr2 = strchr(ptr1, ':')) != 0) {
1079 *ptr2++ = 0;
1080 TRACE("---> '%s' \n", ptr1);
1081 MCI_InstalledCount++;
1082 ptr1 = ptr2;
1083 }
1084 MCI_InstalledCount++;
1085 TRACE("---> '%s' \n", ptr1);
1086 ptr1 += strlen(ptr1) + 1;
1087 } else {
1088 GetPrivateProfileStringA("mci", NULL, "", MCI_lpInstallNames, count, "SYSTEM.INI");
1089 while (strlen(ptr1) > 0) {
1090 TRACE("---> '%s' \n", ptr1);
1091 ptr1 += strlen(ptr1) + 1;
1092 MCI_InstalledCount++;
1093 }
1094 }
1095 //RegCloseKey(hWineConf);
1096 return TRUE;
1097}
Note: See TracBrowser for help on using the repository browser.