raswap.cpp

11N RUOTER Source Code

// RaSwap.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "RaSwap.h"
#include <atlbase.h>

#define   ULONG_PTR	DWORD
#define   DWORD_PTR	DWORD

#include <Setupapi.h>
#include <tlhelp32.h>


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// The one and only application object

#define WIN32_PATH_CLASS_PATH_NETCARDS			_TEXT("System\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002bE10318}")
#define REGSTR_KEY_DEFAULT						_T("Default")
#define REGSTR_KEY_AP_DEFAULT					_T("ApDefault")
#define REGSTR_KEY_STA_BACKUP					_T("StaBackup")
#define REGSTR_KEY_AP_BACKUP					_T("ApBackup")
//#define REGSTR_DEVCLASS_PCI_COMPONENTID			_T("PCI\\VEN_1814&DEV_0201")
#define REGSTR_PATH_CLASS_2K					_T("System\\CurrentControlSet\\Control\\Class")
#define REGSTR_PATH_CLASS_9X					_T("System\\CurrentControlSet\\Services\\Class")
typedef	BOOL   (WINAPI *ENUMPROCESSES)(DWORD*,DWORD,DWORD*);
typedef	BOOL   (WINAPI *ENUMPROCESSMODULES)(HANDLE,HMODULE*,DWORD,LPDWORD);
typedef	DWORD  (WINAPI *GETMODULEBASENAME)(HANDLE,HMODULE,LPSTR,DWORD);
typedef BOOL   (WINAPI *PROCESSWALK)(HANDLE, LPPROCESSENTRY32);
typedef BOOL   (WINAPI *MODULEWALK)(HANDLE, LPMODULEENTRY32);
typedef HANDLE (WINAPI *CREATESNAPSHOT)(DWORD, DWORD);
BOOL OpenAllAccess(HKEY hKey, const char *lpszSubKey, PHKEY phkResult, BOOL bCreate = FALSE);

TCHAR PciDeviceIdTable[][22] = 
{
//	_T("PCI\\VEN_1814&DEV_0201"),   //not for RT2500
	_T("PCI\\VEN_1814&DEV_0301"),
	_T("PCI\\VEN_1814&DEV_0401"),
};

int G_nPciDeviceIdCount = sizeof(PciDeviceIdTable) / 22;


TCHAR UsbDeviceIdTable[][22] = 
{
	_T("USB\\VID_148F&PID_2561"),
	_T("USB\\VID_148F&PID_2661"),
/*
	_T("USB\\VID_148F&PID_2570"),  //not for RT2500USB
	_T("USB\\VID_148F&PID_2573"),
	_T("USB\\VID_148F&PID_5225"),
	_T("USB\\VID_148F&PID_5226"),
	_T("USB\\VID_148F&PID_9020"),
	_T("USB\\VID_0DB0&PID_6861"),
	_T("USB\\VID_0DB0&PID_6865"),
	_T("USB\\VID_0DB0&PID_6869"),
	_T("USB\\VID_0707&PID_EE13"),
	_T("USB\\VID_0B05&PID_1706"),
	_T("USB\\VID_0B05&PID_1707"),
	_T("USB\\VID_5A57&PID_0260"),
	_T("USB\\VID_5A57&PID_0261"),
	_T("USB\\VID_0F88&PID_3012"),
	_T("USB\\VID_13B1&PID_000D"),
	_T("USB\\VID_0769&PID_11F3"),
	_T("USB\\VID_14B2&PID_3C02"),
	_T("USB\\VID_14B2&PID_3C03"),
	_T("USB\\VID_1044&PID_8007"),
	_T("USB\\VID_0411&PID_0066"),
	_T("USB\\VID_0411&PID_0067"),
*/
};

int G_nUsbDeviceIdCount = sizeof(UsbDeviceIdTable) / 22;

char BridgeNetCfgInstanceId[512];
BOOL G_bAp = TRUE;
BOOL G_bUsb = FALSE;
OS_VERSION	G_osVersion = Undefine;
CUIntArray G_arrayDeviceEnum;

HANDLE m_hDrv;
OVERLAPPED m_ovlp;
bool	m_IsLoadSuccessfully;

// Rseb
#define NDISHK_ETHERNET_BRIDGE     0x00000002
#define FILE_DEVICE_PROTOCOL        0x8000
#define IOCTL_PIM_BASE				FILE_DEVICE_PROTOCOL
#define IOCTL_PIM_GET_VERSION\
   CTL_CODE(IOCTL_PIM_BASE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)

#define IOCTL_PIM_SET_BRIDGING\
   CTL_CODE(IOCTL_PIM_BASE, 1, METHOD_BUFFERED, FILE_ANY_ACCESS)

void Trace(const char *format, ...)
{
   va_list pArg;
   va_start(pArg, format);
   CHAR buf[512];
   wvsprintf(buf, format, pArg);
   OutputDebugString(buf);
   va_end(pArg);
}

void CPIMApi(const char * pszFileName)
{ 
	char FullName [ 300 ];
	strcpy ( FullName, "\\\\.\\" );
	strcat ( FullName, pszFileName );
	m_IsLoadSuccessfully = FALSE;
	m_hDrv = CreateFile ( FullName, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED | FILE_FLAG_DELETE_ON_CLOSE, 0 );
	if( m_hDrv == INVALID_HANDLE_VALUE )
		m_hDrv   = CreateFile ( FullName, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0 );

	if( m_hDrv == INVALID_HANDLE_VALUE )
		m_ovlp.hEvent = 0;
	else
	{
		m_ovlp.hEvent = 0;
		m_ovlp.hEvent = CreateEvent ( 0, TRUE, FALSE, NULL );

		if   ( m_ovlp.hEvent )
		{
		   m_IsLoadSuccessfully = TRUE;
		}
	}
}

void RemoveCPIMApi()
{
	if( m_hDrv != INVALID_HANDLE_VALUE )
		CloseHandle ( m_hDrv );

    if( m_ovlp.hEvent )   
		CloseHandle ( m_ovlp.hEvent );
}

// Wrapper around DeviceIoControl API
bool DrvIoControl(DWORD dwService, void *BuffIn, int SizeIn, void *BuffOut, int SizeOut, int *SizeRet, LPOVERLAPPED povlp)
{
     ULONG Ret = 0;
     if   ( m_hDrv != INVALID_HANDLE_VALUE )
     {
		 if(povlp == NULL)
			 Ret = DeviceIoControl ( m_hDrv, dwService, BuffIn, SizeIn, BuffOut, SizeOut, (unsigned long*)SizeRet, &m_ovlp);
		 else 
			 Ret = DeviceIoControl ( m_hDrv, dwService, BuffIn, SizeIn, BuffOut, SizeOut, (unsigned long*)SizeRet, povlp);
     }

     return Ret?true:false;
}

// Getting version info function
int GetRSEBVersion()
{
	 ULONG nDriverAPIVersion = 0xFFFFFFFF;
	 int cbBytesRet =0;
	 bool bIOResult = DrvIoControl(
					  IOCTL_PIM_GET_VERSION,
					  &nDriverAPIVersion,
					  sizeof(ULONG),
					  &nDriverAPIVersion,
					  sizeof(ULONG),
                      &cbBytesRet,   // Bytes Returned
                      NULL
					  );
	 return nDriverAPIVersion;
}

// Starts bridging interfaces
// 1: Bridge On
// 0: Bridge Off
// We will try for 3 times to set the bridge.
BOOL SetBridgingState (ULONG state)
{
	int cbBytesRet =0;
	BOOL bIOResult = FALSE;
	int count = 0; 

#if 0
	if(G_osVersion >= WinXP)
	{
		TRACE("RaSwap::SetBridgingState() -> If XP, do nothing\n");

		// If XP, do nothing.
		return TRUE;
	}
	else
	{
		TRACE("RaSwap::SetBridgingState() -> Do the follows\n");
		; // Do the follows.
	}
#endif

	if (GetRSEBVersion() == NDISHK_ETHERNET_BRIDGE)
	{
//		 printf ("\nThis version support bridging.\n");

		for (count = 0; count < 3; count++)
		{
			bIOResult = DrvIoControl(
								IOCTL_PIM_SET_BRIDGING,
								&state,
								sizeof(ULONG),
								NULL,
								0,
								&cbBytesRet,   // Bytes Returned
								NULL
								);
			if (bIOResult)
			{
				if (state)
					TRACE("Bridging succesfully started.\n");
				else
					TRACE("Bridging successfuly stoped.\n");
				break;
			}
			else
				TRACE ("Failed to change bridging state.\n");

			Sleep(1000);
		}
	}
	else
		TRACE ("\nThis version of driver does not support ethernet bridging.\n");

	return bIOResult;
}

void KillProcess(long PID)
{
	HANDLE  process;

	process = OpenProcess(PROCESS_TERMINATE, 0, PID);
	TerminateProcess(process, (unsigned)-1);
}

long GetProcessID(LPTSTR ModuleName)
{
	DWORD dwVersion, PID;
	HMODULE hLib;
	ENUMPROCESSES         lpEnumProcesses;          
	ENUMPROCESSMODULES    lpEnumProcessModules;
	GETMODULEBASENAME     lpGetModuleBaseName;
	DWORD tbProcesses[1024];
	DWORD cbNeeded;
	DWORD cbProcesses;
	unsigned i;
	HANDLE hProcess;
	HMODULE tbMod[1024];
	CHAR szProcessName[MAX_PATH];
	CREATESNAPSHOT   lpCreateToolhelp32Snapshot;
	PROCESSWALK      lpProcess32First;
	PROCESSWALK      lpProcess32Next;
	MODULEWALK       lpModule32First;
	MODULEWALK       lpModule32Next;
	HANDLE hSnapShot;
	PROCESSENTRY32 procentry;
	HANDLE hSnapShot2;
	MODULEENTRY32 modentry;
	BOOL bFlag;
	
	dwVersion=GetVersion();
	if((dwVersion & 0x80000000))  
	{
		hLib=LoadLibrary("kernel32.dll");
		if (hLib!=NULL)
		{
			lpCreateToolhelp32Snapshot= (CREATESNAPSHOT)GetProcAddress(hLib,"CreateToolhelp32Snapshot");
			lpProcess32First= (PROCESSWALK)GetProcAddress(hLib,"Process32First");
			lpProcess32Next= (PROCESSWALK)GetProcAddress(hLib,"Process32Next") ;
			lpModule32First= (MODULEWALK)GetProcAddress(hLib,"Module32First");
			lpModule32Next= (MODULEWALK)GetProcAddress(hLib,"Module32Next") ;
			if(lpCreateToolhelp32Snapshot!=NULL && lpProcess32First!=NULL && lpProcess32Next!=NULL)
			{
				hSnapShot=lpCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
				if(hSnapShot!=INVALID_HANDLE_VALUE)
				{
					procentry.dwSize=sizeof(PROCESSENTRY32) ;
					bFlag=lpProcess32First(hSnapShot,&procentry);
					while(bFlag)
					{
						hSnapShot2=lpCreateToolhelp32Snapshot(TH32CS_SNAPMODULE,procentry.th32ProcessID);
						if(hSnapShot2!=INVALID_HANDLE_VALUE)
						{
							modentry.dwSize=sizeof(MODULEENTRY32) ;
							bFlag=lpModule32First(hSnapShot2,&modentry);
							while(bFlag)
							{
								if(strnicmp(modentry.szModule,ModuleName,strlen(ModuleName))==0)
								{
									PID = procentry.th32ProcessID;
									FreeLibrary(hLib);
									return PID;
								}
								modentry.dwSize=sizeof(MODULEENTRY32);
								bFlag=lpModule32Next(hSnapShot2,&modentry);
							}
						}
						procentry.dwSize=sizeof(PROCESSENTRY32);
						bFlag=lpProcess32Next(hSnapShot,&procentry);
					} 
				}
			}
			FreeLibrary(hLib);
		}
	}
	else
	{
		hLib = LoadLibrary("psapi.dll");
		if (hLib != NULL)
	    {
			lpEnumProcesses=(ENUMPROCESSES)GetProcAddress(hLib,"EnumProcesses");
			lpEnumProcessModules=(ENUMPROCESSMODULES)GetProcAddress(hLib,"EnumProcessModules");
			lpGetModuleBaseName=(GETMODULEBASENAME)GetProcAddress(hLib,"GetModuleBaseNameA");
	
			if(lpEnumProcesses!=NULL && lpEnumProcessModules!=NULL && lpGetModuleBaseName!=NULL)
			{
				if(lpEnumProcesses(tbProcesses,sizeof(tbProcesses),&cbNeeded))
				{
					cbProcesses=cbNeeded/sizeof(tbProcesses[0]);
					for (i=0;i<cbProcesses;i++)
					{
						hProcess=OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,false,tbProcesses[i]);
						if(hProcess!=NULL)
						{
							if(lpEnumProcessModules(hProcess,tbMod,sizeof(tbMod),&cbNeeded))
							{
								lpGetModuleBaseName(hProcess,tbMod[0],szProcessName,sizeof(szProcessName));
								if(strcmpi(szProcessName,ModuleName)==0)
								{
									PID = tbProcesses[i];
									CloseHandle(hProcess);
									FreeLibrary(hLib);
									return PID;
								}
							}
							CloseHandle(hProcess);
						}
					} 
				}
			}
			FreeLibrary(hLib);
		}
	}
	return FALSE;
}

bool IsX64Platform()
{
	bool bIsX64 = false;
	HKEY hkOpenedKey;

	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
					"System\\CurrentControlSet\\Control\\Session Manager\\Environment",						
					0,
					KEY_READ,