sp2fix.cpp

Last change: 2008-02-03 This is the source code of KCeasy。

/*
This file is part of KCeasy (http://www.kceasy.com)
Copyright (C) 2002-2005 Markus Kern <[e-mail]>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
*/
//---------------------------------------------------------------------------
#pragma hdrstop
#include "SP2Fix.h"
#include "..\tcpip_patcher\tcpip_patcher.h"
//---------------------------------------------------------------------------
#define DRIVER_IMAGE_PATH "\\tcpip_patcher.sys" // relative to KCeasy.exe
#define DRIVER_NAME "tcpip_patcher"
#define DEVICE_PATH "\\\\.\\" PATCHER_DEVICE_NAME_A
#define LOG_BUFFER_SIZE (3*1024)
//---------------------------------------------------------------------------
#pragma package(smart_init)

TTcpIpPatcher::TTcpIpPatcher()
{
}

TTcpIpPatcher::~TTcpIpPatcher()
{
}

bool TTcpIpPatcher::NeedsPatching()
{
    OSVERSIONINFOEX OSVerEx;
    OSVerEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

    // if this fails we are certainly below XP SP2
    if(!GetVersionEx((OSVERSIONINFO *)&OSVerEx))
        return false;

    // needs to be 2k+ system
    if(OSVerEx.dwPlatformId != VER_PLATFORM_WIN32_NT || OSVerEx.dwMajorVersion != 5)
        return false;

    // XP with SP2+
    if(OSVerEx.dwMinorVersion == 1 && OSVerEx.wServicePackMajor >= 2)
        return true;

    // Windows Server 2003 with SP1+
    if(OSVerEx.dwMinorVersion == 2 && OSVerEx.wServicePackMajor >= 1)
        return true;

    return false;
}

bool TTcpIpPatcher::RunningInWow64()
{
    typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS)(HANDLE,PBOOL);
    LPFN_ISWOW64PROCESS pIsWow64Process;
    BOOL IsWow64;

    pIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"),
                                                          "IsWow64Process");

    if(pIsWow64Process && pIsWow64Process(GetCurrentProcess(),&IsWow64))
        return IsWow64;

    return false;
}

bool TTcpIpPatcher::IsDriverLoaded()
{
    HANDLE hDevice;

	if((hDevice = OpenDeviceHandle()) == INVALID_HANDLE_VALUE)
        return false;

    CloseHandle(hDevice);
    return true;
}

bool TTcpIpPatcher::LoadDriver()
{
    if(IsDriverLoaded())
        return true;

    // our driver is for 32 bit only
    if(RunningInWow64())
        return false;

    char ModulePath[MAX_PATH];
    if(GetModuleFileName(NULL,ModulePath,MAX_PATH) == 0)
        return false;
    string ImagePath = ModulePath;
    ImagePath.erase(ImagePath.rfind('\\'));
    ImagePath += DRIVER_IMAGE_PATH; 

	SC_HANDLE hSCManager;
	if(!(hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS)))
        return false;

	SC_HANDLE hService = CreateService(hSCManager,
	                                   DRIVER_NAME,
	                                   DRIVER_NAME,
	                                   SERVICE_ALL_ACCESS,
	                                   SERVICE_KERNEL_DRIVER,
	                                   SERVICE_DEMAND_START,
	                                   SERVICE_ERROR_NORMAL,
	                                   ImagePath.c_str(),
	                                   NULL,
	                                   NULL,
	                                   NULL,
	                                   NULL,
	                                   NULL);

	if(!hService) {
		if(GetLastError() != ERROR_SERVICE_EXISTS) {
			CloseServiceHandle(hSCManager);
			return false;
		}

        // service is already installed, try to open it
		if(!(hService = OpenService(hSCManager,DRIVER_NAME,SERVICE_ALL_ACCESS))) {
			CloseServiceHandle(hSCManager);
			return false;
		}
	}

    // start service
    bool ServiceRunning = true;
	if(!StartService(hService,0,NULL)) {
        if(GetLastError() != ERROR_SERVICE_ALREADY_RUNNING) {
            ServiceRunning = false;
            DeleteService(hService);
        }
    }

	CloseServiceHandle(hService);
	CloseServiceHandle(hSCManager);
	return ServiceRunning;
}

bool TTcpIpPatcher::UnloadDriver()
{
	SC_HANDLE hSCManager, hService;
	SERVICE_STATUS ServiceStatus;

	if(!(hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS)))
        return false;

	if(!(hService = OpenService(hSCManager,DRIVER_NAME,SERVICE_ALL_ACCESS))) {
		CloseServiceHandle(hSCManager);
        return false;
    }

    // stop the service, if this fails we still try to remove it though
	ControlService(hService,SERVICE_CONTROL_STOP,&ServiceStatus);

    bool ServiceDeleted = true;
	if(!DeleteService(hService))
        ServiceDeleted = (GetLastError() == ERROR_SERVICE_MARKED_FOR_DELETE);

	CloseServiceHandle(hService);
	CloseServiceHandle(hSCManager);
	return ServiceDeleted;
}

unsigned int TTcpIpPatcher::GetLimit()
{
    HANDLE hDevice;
	PATCHER_LIMIT_DATA* LimitData;
	DWORD BytesReturned;
    unsigned int Limit = 0;

	if((hDevice = OpenDeviceHandle()) == INVALID_HANDLE_VALUE)
        return 0;

	LimitData = (PATCHER_LIMIT_DATA*) malloc(sizeof(PATCHER_LIMIT_DATA) + LOG_BUFFER_SIZE);
    if(!LimitData) {
        CloseHandle(hDevice);
        return 0;
    }

    if(DeviceIoControl (hDevice, IOCTL_PATCHER_GET_LIMIT,
	                    NULL, 0,
	                    (LPVOID)LimitData,sizeof(PATCHER_LIMIT_DATA) + LOG_BUFFER_SIZE,
	                    &BytesReturned,NULL))
    {
        if(LimitData->ErrorCode == PATCHER_ERROR_SUCCESS)
            Limit = LimitData->HalfOpenLimit;
        DriverLog += LimitData->LogString;
    }

    free(LimitData);
    CloseHandle(hDevice);
    return Limit;
}

bool TTcpIpPatcher::SetLimit(unsigned int NewLimit)
{
    HANDLE hDevice;
	PATCHER_LIMIT_DATA* LimitData;
	DWORD BytesReturned;
    unsigned int Limit = 0;

	if((hDevice = OpenDeviceHandle()) == INVALID_HANDLE_VALUE)
        return 0;

	LimitData = (PATCHER_LIMIT_DATA*) malloc(sizeof(PATCHER_LIMIT_DATA) + LOG_BUFFER_SIZE);
    if(!LimitData) {
        CloseHandle(hDevice);
        return 0;
    }

    LimitData->HalfOpenLimit = NewLimit;

    if(DeviceIoControl (hDevice, IOCTL_PATCHER_SET_LIMIT,
	                    (LPVOID)LimitData,sizeof(PATCHER_LIMIT_DATA),
	                    (LPVOID)LimitData,sizeof(PATCHER_LIMIT_DATA) + LOG_BUFFER_SIZE,
	                    &BytesReturned,NULL))
    {
        if(LimitData->ErrorCode == PATCHER_ERROR_SUCCESS)
            Limit = LimitData->HalfOpenLimit;
        DriverLog += LimitData->LogString;
    }

    free(LimitData);
    CloseHandle(hDevice);
    return Limit;
}

// private
HANDLE TTcpIpPatcher::OpenDeviceHandle()
{
    HANDLE hDevice = CreateFile (DEVICE_PATH,
	                             GENERIC_READ | GENERIC_WRITE,
	                             0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
                                 NULL);

	return hDevice;
}