Example #1
0
BOOL WINAPI
DllMain(HINSTANCE hinstDll,
    DWORD dwReason,
    LPVOID reserved)
{
    switch (dwReason)
    {
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(hinstDll);
            RegInitialize();
            break;
        case DLL_PROCESS_DETACH:
            RegCleanup();
            UnloadNtMarta();
            break;
    }

   return TRUE;
}
Example #2
0
BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);

    switch (fdwReason) {
        case DLL_PROCESS_ATTACH:
        {
            DisableThreadLibraryCalls(hinstDLL);
            WTSAPI32_hModule = hinstDLL;
            break;
        }
        case DLL_PROCESS_DETACH:
        {
            break;
        }
    }

    return TRUE;
}
Example #3
0
BOOL WINAPI     DllMain(HANDLE hInstance, DWORD dwReason, LPVOID pvReserved)
{
    if (dwReason == DLL_PROCESS_ATTACH)
    {
        g_hInst = (HINSTANCE)hInstance;
        DisableThreadLibraryCalls((HINSTANCE)hInstance);
#ifdef SELF_NO_HOST
        jitOnDllProcessAttach();
        g_fClrCallbacksInit = TRUE;
#endif
    }
    else if (dwReason == DLL_PROCESS_DETACH)
    {
        if (g_fClrCallbacksInit)
            jitOnDllProcessDetach();
    }

    return TRUE;
}
Example #4
0
extern "C" bool __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch(fdwReason)
    {
    case DLL_PROCESS_ATTACH:
    {
        DisableThreadLibraryCalls(hinstDLL);
        return Initialize();
    }
    break;

    case DLL_PROCESS_DETACH:
    {
        DeInitialize();
    }
    break;
    }
    return true;
}
Example #5
0
/***********************************************************************
 *              DllMain (MAPI32.init)
 */
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
{
    TRACE("(%p,%d,%p)\n", hinstDLL, fdwReason, fImpLoad);

    switch (fdwReason)
    {
    case DLL_PROCESS_ATTACH:
        hInstMAPI32 = hinstDLL;
        DisableThreadLibraryCalls(hinstDLL);
        load_mapi_providers();
        break;
    case DLL_PROCESS_DETACH:
        if (fImpLoad) break;
	TRACE("DLL_PROCESS_DETACH: %d objects remaining\n", MAPI_ObjectCount);
        unload_mapi_providers();
	break;
    }
    return TRUE;
}
Example #6
0
// Dll loaded entry point
BOOL WINAPI DllMain(__in HINSTANCE hDll, __in DWORD dwReason, __in void * reserved)
{
    switch (dwReason)
    {
    case DLL_PROCESS_ATTACH:
        DisableThreadLibraryCalls(hDll);
        break;
    case DLL_PROCESS_DETACH:
        break;
	// No thread attach/detach will be signaled, as we called DisableThreadLibraryCalls,
	// cases included here for completeness in enum values only!
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
		break;
    }

    g_dllHandle = hDll;
    return TRUE;
}
Example #7
0
/******************************************************************
 *      DllMain
 */
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
    case DLL_PROCESS_ATTACH:
        msi_hInstance = hinstDLL;
        DisableThreadLibraryCalls(hinstDLL);
        IsWow64Process( GetCurrentProcess(), &is_wow64 );
        break;
    case DLL_PROCESS_DETACH:
        if (lpvReserved) break;
        msi_dialog_unregister_class();
        msi_free_handle_table();
        msi_free( gszLogFile );
        release_typelib();
        break;
    }
    return TRUE;
}
Example #8
0
File: main.c Project: bilboed/wine
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);

    switch (fdwReason)
    {
        case DLL_WINE_PREATTACH:
            return FALSE;    /* prefer native version */
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(hinstDLL);
            break;
        case DLL_PROCESS_DETACH:
            break;
        default:
            break;
    }

    return TRUE;
}
BOOL WINAPI DllMain(	HINSTANCE	hInstance,
                        DWORD		reason,
                        LPVOID		pReserved )
{
	IFXRESULT	result	= IFX_OK;

    if ( reason == DLL_PROCESS_ATTACH )
    {
		DisableThreadLibraryCalls( hInstance );

		result = IFXRenderingStartup();
    }
    else if ( reason == DLL_PROCESS_DETACH )
    {
		result = IFXRenderingShutdown();
    }

	return ( IFXSUCCESS( result ) ? TRUE : FALSE );
}
Example #10
0
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
	BOOL bRet = FALSE;

	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		DisableThreadLibraryCalls(hModule);

		bRet = (CStackStorage::GetInstance()->InitSharedFileMapping(0) 
			&& CStackStorage::GetInstance()->Open());

		if (TRUE == bRet)
		{
			bRet = DetoursorHelper::AddAllFunctionsToDetoursor(CDetoursor::GetInstance());		
			if (TRUE == bRet)
			{
				bRet = CDetoursor::GetInstance()->DoHook();
			}
		}
		break;
	case DLL_PROCESS_DETACH:
		bRet = CDetoursor::GetInstance()->UndoHook();
		if (TRUE == bRet)
		{			
			WCHAR wcsExeFilePathName[_MAX_PATH];
			ZeroMemory(wcsExeFilePathName, sizeof(_MAX_PATH));
			GetModuleFileNameW(NULL, wcsExeFilePathName, _countof(wcsExeFilePathName));
			
			CDetoursor::GetInstance()->ClearFunctionTable();
			
			CStackStorage::GetInstance()->SetModInfoData(CCallStack::GetModInfoVector());
			CStackStorage::GetInstance()->SetHeaderData(wcsExeFilePathName);
			CStackStorage::GetInstance()->Close();
		}
		break;
	}

    return bRet;
}
Example #11
0
/******************************************************************
 *              DllMain (vbscript.@)
 */
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
{
    TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpv);

    switch(fdwReason)
    {
    case DLL_WINE_PREATTACH:
        return FALSE;  /* prefer native version */
    case DLL_PROCESS_ATTACH:
        DisableThreadLibraryCalls(hInstDLL);
        vbscript_hinstance = hInstDLL;
        break;
    case DLL_PROCESS_DETACH:
        release_typelib();
        release_regexp_typelib();
    }

    return TRUE;
}
Example #12
0
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);

    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(hinstDLL);
#ifdef HAVE_OPENAL
            load_libopenal();
#endif /*HAVE_OPENAL*/
            break;
        case DLL_PROCESS_DETACH:
            MMDevEnum_Free();
            break;
    }

    return TRUE;
}
Example #13
0
BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
{
    TRACE("%p, %u, %p\n", hinst, reason, reserved);

    switch (reason)
    {
        case DLL_WINE_PREATTACH:
            return FALSE;    /* prefer native version */
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls( hinst );
            scrrun_instance = hinst;
            break;
        case DLL_PROCESS_DETACH:
            if (reserved) break;
            release_typelib();
            break;
    }
    return TRUE;
}
Example #14
0
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    TRACE("(%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);

    MSCOREE_hInstance = hinstDLL;

    switch (fdwReason)
    {
    case DLL_WINE_PREATTACH:
        return FALSE;  /* prefer native version */
    case DLL_PROCESS_ATTACH:
        DisableThreadLibraryCalls(hinstDLL);
        break;
    case DLL_PROCESS_DETACH:
        expect_no_runtimes();
        break;
    }
    return TRUE;
}
BOOL APIENTRY DllMain( HANDLE hInst, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
			DisableThreadLibraryCalls((HINSTANCE)hInst);
			break;
		case DLL_THREAD_ATTACH:
			break;
		case DLL_THREAD_DETACH:
			break;
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}
Example #16
0
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
	DisableThreadLibraryCalls((HMODULE)hModule);
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		DLL.Start();
		break;
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		DLL.Stop();
		break;
	}
	return TRUE;
}
Example #17
0
extern "C" BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
	switch (fdwReason)
	{
		case DLL_PROCESS_ATTACH:
			g_hModule = hinstDLL;
			DisableThreadLibraryCalls(hinstDLL);
			Com_Printf("\n[CoD XTREME] Injected successfully. Visit www.modszombies.com\n");
			crackFunctions();
			crackGSCFunctions();
			//connectMySql();			
			break;

		case DLL_PROCESS_DETACH:
		case DLL_THREAD_DETACH:
			FreeLibraryAndExitThread(g_hModule, 0);
			break;
		}
	return TRUE;
}
Example #18
0
//===========================================================================
extern "C" BOOL WINAPI DllMain (HINSTANCE hDLLInst, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
    case DLL_PROCESS_ATTACH:
        // The DLL is being loaded for the first time by a given process.
        // Perform per-process initialization here.  If the initialization
        // is successful, return TRUE; if unsuccessful, return FALSE.

        // TODO: DisableThreadLibraryCalls screws with msvcrt
        // TODO: RegisterWindowMessage is not safe to called from the dllmain, it can lead to deadlocks.
        //       we should put it into some initializer instead.

        hInstance = hDLLInst;
        DisableThreadLibraryCalls(hDLLInst);
        bbSkinMsg = RegisterWindowMessage(BBLEANSKIN_MSG);
        //dbg_printf("Attached to %x HHOOKs: CW %x GM %x", hDLLInst, hCallWndHook, hGetMsgHook);
        break;

    case DLL_PROCESS_DETACH:
        // The DLL is being unloaded by a given process.  Do any
        // per-process clean up here, such as undoing what was done in
        // DLL_PROCESS_ATTACH.  The return value is ignored.
        //dbg_printf("unloaded.");
        break;

    case DLL_THREAD_ATTACH:
        // A thread is being created in a process that has already loaded
        // this DLL.  Perform any per-thread initialization here.  The
        // return value is ignored.
        //dbg_printf("new thread");
        break;

    case DLL_THREAD_DETACH:
        // A thread is exiting cleanly in a process that has already
        // loaded this DLL.  Perform any per-thread clean up here.  The
        // return value is ignored.
        //dbg_printf("end thread");
        break;
    }
    return TRUE;
}
Example #19
0
/*
 *  Dll Main function
 */
BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);

    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(hinstDLL);
            /* Try to load low-level library */
            if (load_functions() != 0)
		return FALSE;  /* error */
            break;
        case DLL_PROCESS_DETACH:
            if (lpvReserved) break;
            if (ctapi_handle) wine_dlclose(ctapi_handle, NULL, 0);
            break;
    }

    return TRUE;
}
Example #20
0
// DllMain is needed to get the module handle for registration.
EXTERN_C BOOL WINAPI DllMain(_In_ HINSTANCE hInstance,
                             _In_ ULONG ulReason,
                             _In_opt_ LPVOID pvReserved)
{
    MI_UNREFERENCED_PARAMETER(pvReserved);

    if (DLL_PROCESS_ATTACH == ulReason)
    {
        DisableThreadLibraryCalls(hInstance);
        g_hModule = hInstance;
    }
    else if (DLL_PROCESS_DETACH == ulReason)
    {
        if(g_hHelper)
        {
            FreeLibrary(g_hHelper);
        }
    }
    return TRUE;
}
Example #21
0
/***********************************************************************
 * DllMain.
 */
BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
{
    static const WCHAR riched20W[] = {'r','i','c','h','e','d','2','0','.','d','l','l',0};
    static HMODULE richedit;

    switch(reason)
    {
    case DLL_WINE_PREATTACH:
        return FALSE; /* prefer native version */
    case DLL_PROCESS_ATTACH:
        /* explicitly load riched20 since it creates the window classes at dll attach time */
        richedit = LoadLibraryW( riched20W );
        DisableThreadLibraryCalls(inst);
        break;
    case DLL_PROCESS_DETACH:
        FreeLibrary( richedit );
        break;
    }
    return TRUE;
}
Example #22
0
BOOL WINAPI DllMain(HINSTANCE hinstDLL,ULONG fdwReason,LPVOID lpvReserved) 
{
	switch(fdwReason) {
	case DLL_PROCESS_ATTACH:
		MaxSDK::Util::UseLanguagePackLocale();
		hInstance = hinstDLL;				// Hang on to this DLL's instance handle.
		DisableThreadLibraryCalls(hInstance);
		break;
	case DLL_PROCESS_DETACH:
#ifndef NDEBUG 
		if( hResource )
		{
			// Leak resource DLL: shouldn't call FreeLibrary() from here.
			OutputDebugString(_T("eps/eps.cpp: DllMain(DLL_PROCESS_DETACH) called before LibShutdown()\n"));
		}
#endif
		break;
	}
	return(TRUE);
}
Example #23
0
BOOL APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
	switch(dwReason)
	{
		case DLL_PROCESS_ATTACH:
			// Pass around hinstance references...
			Logger::GetInstance()->SetHInstance(hInstance);
			GlobalHook::GetInstance()->SetHInstance(hInstance);
			DisableThreadLibraryCalls(hInstance);

			CreateThread(NULL, NULL,(LPTHREAD_START_ROUTINE)OnProcessAttach, hInstance, NULL, NULL);
			break;

		case DLL_PROCESS_DETACH:
			OnProcessDetach();
			break;
	}	

	return TRUE;
}
Example #24
0
BOOL WINAPI
DllMain(
    IN HINSTANCE hInstance,
    IN DWORD dwReason,
    IN LPVOID lpReserved)
{
    if (dwReason == DLL_PROCESS_ATTACH)
    {
        INITCOMMONCONTROLSEX InitControls;

        DisableThreadLibraryCalls(hInstance);

        InitControls.dwSize = sizeof(INITCOMMONCONTROLSEX);
        InitControls.dwICC = ICC_PROGRESS_CLASS;
        InitCommonControlsEx(&InitControls);
        hDllInstance = hInstance;
    }

    return TRUE;
}
Example #25
0
BOOL WINAPI DllMain(HINSTANCE hinstDLL,ULONG fdwReason,LPVOID lpvReserved)
{
	hInstance = hinstDLL;				// Hang on to this DLL's instance handle.

	if (!controlsInit) {
		controlsInit = TRUE;
		InitCustomControls(hInstance);	// Initialize MAX's custom controls
		InitCommonControls();			// Initialize Win95 controls
	}

    if(fdwReason == DLL_PROCESS_ATTACH)
    {
        DisableThreadLibraryCalls(hinstDLL);
        InitXT();
    }
    else if(fdwReason == DLL_PROCESS_DETACH)
        TerminateXT();
			
	return (TRUE);
}
Example #26
0
/******************************************************************
 *              DllMain (ieframe.@)
 */
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
{
    TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpv);

    switch(fdwReason)
    {
    case DLL_WINE_PREATTACH:
        return FALSE;  /* prefer native version */
    case DLL_PROCESS_ATTACH:
        ieframe_instance = hInstDLL;
        register_iewindow_class();
        DisableThreadLibraryCalls(ieframe_instance);
        break;
    case DLL_PROCESS_DETACH:
        unregister_iewindow_class();
        release_typelib();
    }

    return TRUE;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);

    switch (fdwReason)
    {
        case DLL_WINE_PREATTACH:
            return TRUE;
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(hinstDLL);
            dbg_flag = get_dbg_flag('w');
            dbg_report("Attach request\n");
            break;
        case DLL_PROCESS_DETACH:
            linuxtrack_shutdown();
            break;
    }

    return TRUE;
}
Example #28
0
BOOL APIENTRY DllMain(HMODULE module, DWORD reason, LPVOID reserved)
{
    module_global = module;

    switch (reason)
    {
        case DLL_PROCESS_ATTACH:
            everquest_chat_helper_detour_function();

            DisableThreadLibraryCalls(module);
            CreateThread(NULL, 0, &thread_load, NULL, 0, NULL);
            break;

        case DLL_PROCESS_DETACH:
            everquest_chat_helper_remove_detour();
            break;
    }

    return TRUE;
}
Example #29
0
    DLLEXPORT // For Win32 PAL LoadLibrary emulation
#endif
    BOOL WINAPI
    DllMain(HANDLE hInstance, DWORD dwReason, LPVOID pvReserved)
{
    if (dwReason == DLL_PROCESS_ATTACH)
    {
        g_hInst = (HINSTANCE)hInstance;
        DisableThreadLibraryCalls((HINSTANCE)hInstance);
    }
    else if (dwReason == DLL_PROCESS_DETACH)
    {
        // From MSDN: If fdwReason is DLL_PROCESS_DETACH, lpvReserved is NULL if FreeLibrary has
        // been called or the DLL load failed and non-NULL if the process is terminating.
        bool processIsTerminating = (pvReserved != nullptr);
        jitShutdown(processIsTerminating);
    }

    return TRUE;
}
Example #30
0
BOOL
WINAPI
DllMain(
    HINSTANCE hInstance,
    DWORD dwReason,
    LPVOID lpReserved
    )
{
    if (dwReason == DLL_PROCESS_ATTACH) {
        WPP_INIT_TRACING(MYDRIVER_TRACING_ID);
        
        g_hInstance = hInstance;
        DisableThreadLibraryCalls(hInstance);

    } else if (dwReason == DLL_PROCESS_DETACH) {
        WPP_CLEANUP();
    }

    return _AtlModule.DllMain(dwReason, lpReserved);
}