/**************************************************************************
* OpenDriver [WINMM.@]
* DrvOpen [WINMM.@]
*/
HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
{
LPWINE_DRIVER lpDrv = NULL;
WCHAR libName[128];
LPCWSTR lsn = lpSectionName;
TRACE("(%s, %s, 0x%08lx);\n",
debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam);
/* If no section name is specified, either the caller is intending on
opening a driver by filename, or wants to open a user-installable
driver that has an entry in the Drivers32 key in the registry */
if (lsn == NULL)
{
/* Default registry key */
static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0};
lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR));
/* Try and open the driver by filename */
if ( (lpDrv = DRIVER_TryOpenDriver32(libName, lParam)) )
goto the_end;
/* If we got here, the file wasn't found. So we assume the caller
wanted a driver specified under the Drivers32 registry key */
lsn = wszDrivers32;
}
/* Attempt to locate the driver filename in the registry */
if ( DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) )
{
/* Now we have the filename, we can try and load it */
if ( (lpDrv = DRIVER_TryOpenDriver32(libName, lParam)) )
goto the_end;
}
/* now we will try a 16 bit driver (and add all the glue to make it work... which
* is located in our mmsystem implementation)
* so ensure, we can load our mmsystem, otherwise just fail
*/
WINMM_CheckForMMSystem();
#if 0
if (pFnOpenDriver16 &&
(lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam)))
{
if (DRIVER_AddToList(lpDrv, 0, lParam)) goto the_end;
HeapFree(GetProcessHeap(), 0, lpDrv);
}
TRACE("Failed to open driver %s from system.ini file, section %s\n",
debugstr_w(lpDriverName), debugstr_w(lpSectionName));
#endif
return 0;
the_end:
if (lpDrv) TRACE("=> %p\n", lpDrv);
return (HDRVR)lpDrv;
}
/**************************************************************************
* DRIVER_TryOpenDriver16 [internal]
*
* Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
*/
static LPWINE_DRIVER DRIVER_TryOpenDriver16(LPCSTR lpFileName, LPARAM lParam2)
{
static WORD DRIVER_hDrvr16Counter /* = 0 */;
LPWINE_DRIVER lpDrv = NULL;
HMODULE16 hModule;
DRIVERPROC16 lpProc;
LPCSTR lpSFN;
LPSTR ptr;
TRACE("('%s', %08lX);\n", lpFileName, lParam2);
if (strlen(lpFileName) < 1) return lpDrv;
if ((lpSFN = strrchr(lpFileName, '\\')) == NULL)
lpSFN = lpFileName;
else
lpSFN++;
if ((ptr = strchr(lpFileName, ' ')) != NULL) {
*ptr++ = '\0';
while (*ptr == ' ') ptr++;
if (*ptr == '\0') ptr = NULL;
}
if ((hModule = LoadLibrary16(lpFileName)) < 32) goto exit;
if ((lpProc = (DRIVERPROC16)GetProcAddress16(hModule, "DRIVERPROC")) == NULL)
goto exit;
if ((lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER))) == NULL)
goto exit;
lpDrv->dwDriverID = 0;
while (DRIVER_FindFromHDrvr16(++DRIVER_hDrvr16Counter));
lpDrv->hDriver16 = DRIVER_hDrvr16Counter;
lstrcpynA(lpDrv->szAliasName, lpSFN, sizeof(lpDrv->szAliasName));
lpDrv->hModule16 = hModule;
lpDrv->lpDrvProc = lpProc;
if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2)) goto exit;
return lpDrv;
exit:
TRACE("Unable to load 16 bit module (%s): %04x\n", lpFileName, hModule);
if (hModule >= 32) FreeLibrary16(hModule);
HeapFree(GetProcessHeap(), 0, lpDrv);
return NULL;
}
/**************************************************************************
* DRIVER_TryOpenDriver32 [internal]
*
* Tries to load a 32 bit driver whose DLL's (module) name is fn
*/
LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
{
LPWINE_DRIVER lpDrv = NULL;
HMODULE hModule = 0;
LPWSTR ptr;
LPCSTR cause = 0;
TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2);
if ((ptr = strchrW(fn, ' ')) != NULL) {
*ptr++ = '\0';
while (*ptr == ' ') ptr++;
if (*ptr == '\0') ptr = NULL;
}
lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
if (lpDrv == NULL) {cause = "OOM"; goto exit;}
if ((hModule = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
lpDrv->lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
if (lpDrv->lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
lpDrv->dwFlags = 0;
lpDrv->hModule = hModule;
lpDrv->dwDriverID = 0;
/* Win32 installable drivers must support a two phase opening scheme:
* + first open with NULL as lParam2 (session instance),
* + then do a second open with the real non null lParam2)
*/
if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, NULL) == 0 && lParam2)
{
LPWINE_DRIVER ret;
if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
{
cause = "load0 failed";
goto exit;
}
ret = DRIVER_TryOpenDriver32(fn, lParam2);
if (!ret)
{
CloseDriver((HDRVR)lpDrv, 0L, 0L);
cause = "load1 failed";
goto exit;
}
lpDrv->dwFlags |= WINE_GDF_SESSION;
return ret;
}
if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
{cause = "load failed"; goto exit;}
TRACE("=> %p\n", lpDrv);
return lpDrv;
exit:
FreeLibrary(hModule);
HeapFree(GetProcessHeap(), 0, lpDrv);
TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn), cause);
return NULL;
}
