GASPilotDLL.cpp

Go to the documentation of this file.

/// \file GASPilotDLL.cpp
/// \brief Entry Point file for GASPilotDLL
/// \ingroup GASPilotDLL
///
/// Injected library for adjusting the speed within DirectX/DirectSound games.
///
/// Copyright (c) 2007-2008 by Michael Ellison.
/// See COPYING.txt for the \ref gaslicense License (MIT License).
/// \sa gaslicense
///
// $Author: mikeellison $
// $Date: 2008-01-31 09:36:59 -0600 (Thu, 31 Jan 2008) $
// $Revision:   $
// $NoKeywords: $

#include "GASPilotDLL.h"

#define CAT_WM_FASTER WM_USER + 555
#define CAT_WM_SLOWER WM_USER + 556

unsigned int _stdcall InjectedThreadFunc(void *param);

HANDLE  gThreadHandle = 0;
HANDLE  gExitEvent    = 0;
HMODULE gInstance     = 0;
int     gPID          = 0;
wchar_t gEventName[64];

BOOL WINAPI DllMain(  HINSTANCE hinstDLL,
                      DWORD fdwReason,
                      LPVOID lpvReserved)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            {   
                gPID           = _getpid();
                gInstance      = hinstDLL;
                swprintf(gEventName,64,L"GASPilotDLL_%d",gPID);
                gExitEvent     = ::CreateEvent(0,TRUE,0,gEventName);                
                
                // Start up our injected thread.
                unsigned int threadId = 0;
                gThreadHandle  = (HANDLE)_beginthreadex(0,0,InjectedThreadFunc,0,0,&threadId);
                ::OutputDebugString(L"GASPilotDLL injected.\n");
            }
            break;

        case DLL_PROCESS_DETACH:                  
            // If the thread hasn't been exited already from other methods, it's getting
            // nuked as we speak and won't receive an event even if we fire it.
            if (gExitEvent)
            {
                ::CloseHandle(gExitEvent);            
                gExitEvent = 0;
            }
            if (gThreadHandle)
            {
                ::CloseHandle(gThreadHandle);
            }
            ::OutputDebugString(L"GASPilotDLL exiting.\n");            
            break;
    }

    return TRUE;
}

unsigned int _stdcall InjectedThreadFunc(void *param)
{   
    ::OutputDebugString(L"Starting InjectedThread.\n");
    GASPilotDLL* gp = new GASPilotDLL();
    gp->Run();
    delete gp;
    ::OutputDebugString(L"Exiting InjectedThread.\n");
    ::FreeLibraryAndExitThread(gInstance,-1);
    return 0;
}


extern "C"
{
    void*        gPassedData    = 0;
    unsigned int gPassedDataLen = 0;
    void _declspec(dllexport) UnpatchProcess(void*        passData,
                                             unsigned int passDataLen,
                                             void*        startLoc,
                                             unsigned int patchSize,
                                             void*        hostBuffer,
                                             unsigned int hostProcId)
    {
        // Open host process and read the stored bytes into our 
        // hooked process over the start location, restoring the
        // original executable code.        
        HANDLE hostProcess = ::OpenProcess(PROCESS_ALL_ACCESS,
                                           FALSE,
                                           hostProcId);
        if (hostProcess != 0)
        {
            DWORD amountRead = 0;
            ::ReadProcessMemory(hostProcess,hostBuffer,startLoc,patchSize,&amountRead);
            if (passDataLen && passData)
            {
                gPassedDataLen = passDataLen;
                gPassedData = new BYTE[passDataLen];
                ::ReadProcessMemory(hostProcess,passData,gPassedData,passDataLen,&amountRead);
            }
            CloseHandle(hostProcess);
        }

        // Got the data from the parent. Open the wait event and set it.
        wchar_t eventName[64];
        wsprintf(eventName,L"UnpatchProcess_%d",hostProcId);
        HANDLE waitEvent = ::OpenEvent(GENERIC_READ|GENERIC_WRITE,FALSE,eventName);
        if (waitEvent != 0)
        {
            ::SetEvent(waitEvent);
            CloseHandle(waitEvent);
        }

        // Now, restore the stack and go back to the starting location                
        __asm
        {         
            mov esp,ebp  // Get original base pointer
            pop ebp      
            add esp,0x1c // Restore stack point to start of our code
            popfd
            popad
            ret
        }
    }
}

GASPilotDLL::GASPilotDLL()
{
    fSpeed        = 1.00;
    fExecCap      = 0;
    fTimeWarp     = 0;
    fOverlayDX9   = 0;
    fOverlayGL    = 0;
    fSpeedImg     = 0;
    fSlowImg      = 0;
    fFastImg      = 0;
    fSpeedImg     = 0;

    ::GetModuleFileName(0,fHostApp.GetUnicodeBuffer(1024),1023);
    fHostApp.ReleaseBuffer();

    ::GetModuleFileName(gInstance,fDLLPath.GetUnicodeBuffer(1024),1023);
    fDLLPath.ReleaseBuffer();
    fBasePath = fDLLPath.GetDriveDirectory();
    fSlowImgPath = fBasePath;
    fSlowImgPath << L"Overlays\\GameSpeed_e.png";    
    fFastImgPath = fBasePath;
    fFastImgPath << L"Overlays\\GameSpeed_f.png";

    fFastImg = 0;
    fSlowImg = 0;

    CATStreamFile *imgStream = new CATStreamFile();
    CATResult result = imgStream->Open(fSlowImgPath,CATStream::READ_ONLY);
    if (CATSUCCEEDED(result))
    {
        result = CATImage::Load(imgStream,fSlowImg);
        imgStream->Close();
    }
    if (CATFAILED(result))
    {
        ::OutputDebugString(L"Failed to load speed image");
        ::OutputDebugString(fSlowImgPath);        
    }
    
    result = imgStream->Open(fFastImgPath,CATStream::READ_ONLY);
    if (CATSUCCEEDED(result))
    {
        result = CATImage::Load(imgStream,fFastImg);
        imgStream->Close();
    }

    if (CATFAILED(result))
    {
        ::OutputDebugString(L"Failed to load speed image");
        ::OutputDebugString(fFastImgPath);
    }

    delete imgStream;
}

GASPilotDLL::~GASPilotDLL()
{
    if (fOverlayDX9)
        fOverlayDX9->RestoreAll();
    
    if (fTimeWarp)
        fTimeWarp->RestoreAll();

    if (fExecCap)
        fExecCap->RestoreAll();

    if (fOverlayGL)
        fOverlayGL->RestoreAll();

    delete fOverlayDX9;
    fOverlayDX9 = 0;

    delete fTimeWarp;
    fTimeWarp = 0;

    delete fExecCap;
    fExecCap = 0;
    
    delete fOverlayGL;
    fOverlayGL = 0;

    if (fSpeedImg)
        CATImage::ReleaseImage(fSpeedImg);
    if (fFastImg)
        CATImage::ReleaseImage(fFastImg);
    if (fSlowImg)
        CATImage::ReleaseImage(fSlowImg); 
}

void GASPilotDLL::Run()
{   
    CATUInt32 hookFlags = this->CheckHooks();


    if (hookFlags & CATHook_Exec)
    {
        fExecCap = new CATInjectionPropagate(fDLLPath);
        fExecCap->HookFunctions();
    }
    
    if (hookFlags & CATHook_OGL)
    {
        fOverlayGL    = new CATOverlayOpenGL();
        fOverlayGL->HookFunctions();
    }

    if (hookFlags & CATHook_DX9)
    {
        fOverlayDX9   = new CATOverlayDirect3D9();
        fOverlayDX9->HookFunctions();
    }

    if (hookFlags & CATHook_Time)
    {
        fTimeWarp     = new CATTimeWarp();
        fTimeWarp->HookFunctions();
    }
    

    CATFloat32 speed         = 1.0f;
    CATInt32   logoWidth     = 60;

    if (fTimeWarp)
        fTimeWarp->GetSpeed();

    CATRect rect(0,0,360,50);
    if (fFastImg)
    {
        fOverlayDX9->SetOverlayImage(fFastImg,rect,1024,768);
        fOverlayGL->SetOverlayImage(fFastImg,rect,1024,768);            
    }


    // Create a message window for others to post to
    WNDCLASS msgWndClass;
    memset(&msgWndClass,0,sizeof(msgWndClass));
    HINSTANCE instance = gInstance;
    msgWndClass.style           = 0;
    msgWndClass.lpfnWndProc     = (WNDPROC)EventMsgProc;
    msgWndClass.cbClsExtra      = 0;
    msgWndClass.cbWndExtra      = 0;
    msgWndClass.hInstance       = instance;
    msgWndClass.hIcon           = 0;
    msgWndClass.hbrBackground   = 0;
    msgWndClass.lpszMenuName    = 0;    
    msgWndClass.lpszClassName   = L"GASPilotDLLWnd";    
    ATOM classAtom = RegisterClass(&msgWndClass);
    ::RegisterClass(&msgWndClass);

    fMsgWnd = ::CreateWindowEx(0,L"GASPilotDLLWnd",L"GASPilotMsgs",0,0,0,0,0,0,0,gInstance,this);


    
    for (; ;)
    {
        // This needs to be put in a hook instead.... asynckeystate not reliable.
        DWORD waitResult = MsgWaitForMultipleObjects(1, 
                                                     &gExitEvent,
                                                     FALSE,
                                                     150,
                                                     QS_ALLINPUT);

        if (waitResult == WAIT_OBJECT_0)
        {
            break;
        } 
        else if (WAIT_TIMEOUT == waitResult)
        {
            CheckKeys();
        }
        else
        {
            MSG msg;
            while (PeekMessage(&msg, fMsgWnd, 0, 0, PM_REMOVE)) 
            { 
                CheckKeys();
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
    }

    DestroyWindow(fMsgWnd);
    UnregisterClass(L"GASPilotDLLWnd",gInstance);

}

LRESULT CALLBACK GASPilotDLL::EventMsgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    GASPilotDLL* pilot = 0;

    if (message == WM_CREATE)
    {
        LPCREATESTRUCT lpc = (LPCREATESTRUCT)lParam;
        SetWindowLong(hWnd,GWL_USERDATA,PtrToUlong(lpc->lpCreateParams));
        SetWindowPos(hWnd,0,0,0,0,0,SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOZORDER|SWP_NOSIZE);
        pilot = (GASPilotDLL*)lpc->lpCreateParams;        
    }
    else
    {
        pilot = (GASPilotDLL*)(ULONG_PTR)GetWindowLong(hWnd,GWL_USERDATA);
    }

    switch (message)
    {
        case CAT_WM_SLOWER:
            pilot->OnSlower();
            break;
        case CAT_WM_FASTER:
            pilot->OnFaster();
        default:
            break;
    }
    
    return DefWindowProc(hWnd,message,wParam,lParam);
}

void GASPilotDLL::OnFaster()
{
    fSpeed += 0.05f;
    UpdateSpeed();
}
void GASPilotDLL::OnSlower()
{
    fSpeed -= 0.05f;
    UpdateSpeed();
}

void GASPilotDLL::OnFast()
{
    fSpeed = 1.0f;
    UpdateSpeed();
}
void GASPilotDLL::OnSlow()
{
    fSpeed = 0.4f;
    UpdateSpeed();
}

void GASPilotDLL::UpdateSpeed()
{
     if (fSpeed > 1.0f)
        fSpeed = 1.0f;   
    if (fSpeed < 0.2f)
        fSpeed = 0.2f;

   if (fFastImg && fSlowImg)
    {
        CATImage* newSpeedImage = 0;
        CATImage::CopyImage(fSlowImg,newSpeedImage);
        
        CATRect rect(0,0,360,50);
        
        if (newSpeedImage)
        {
            newSpeedImage->Overlay(fFastImg,0,0,0,0,60 + (fFastImg->Width()-60)*fSpeed,fFastImg->Height());
            if (fOverlayDX9)
                fOverlayDX9->SetOverlayImage(newSpeedImage,rect,1024,768);
            if (fOverlayGL)
                fOverlayGL->SetOverlayImage(newSpeedImage,rect,1024,768);
        }

        if (fSpeedImg != 0)
            CATImage::ReleaseImage(fSpeedImg );
        fSpeedImg = newSpeedImage;
    }

   CATString speedStr;
   speedStr.Format(L"Setting speed to %f\n",fSpeed);
   ::OutputDebugString(speedStr);

   if (fTimeWarp)
        fTimeWarp->SetSpeed(fSpeed);

    ::InvalidateRect(::GetForegroundWindow(),0,FALSE);
}

CATUInt32 GASPilotDLL::CheckHooks()
{
    if (fHostApp.IsEmpty())
        return CATHook_All;
    
    /// \todo
    /// Add XML exception list to exclude hooking of launch apps
    CATString appName = fHostApp.GetFilenameNoExt();
    if (0 == appName.CompareNoCase(L"steam"))
    {
        return CATHook_None;   
    }

    return CATHook_All;
}

void GASPilotDLL::CheckKeys()
{
    bool nextDown = (0x8000 & GetAsyncKeyState(VK_NEXT));
    bool prevDown = (0x8000 & GetAsyncKeyState(VK_PRIOR));
    bool f13      = (0x8000 & GetAsyncKeyState(VK_F13));
    bool f14      = (0x8000 & GetAsyncKeyState(VK_F14));

    if (nextDown)
    {
        this->OnSlower();
    }
    
    if (prevDown)
    {
        this->OnFaster();
    }

    if (f13)    
        this->OnSlow();
    
    if (f14)
        this->OnFast();
}

---