#include "stdafx.h"
#include "MbnEventInternal.h"

// Windows version store.
ULONG wv;
int gArch;

void InitAccessKeyInfo(ptAccessKeyInfo info)
{
	info->strProfileDesc = "";
	info->strAccessString = "";
	info->strUserName = "";
	info->strPassword = "";
	info->strIPType = "";
	info->strAuthProtocol = "";
	info->strPhoneNum = "";
	info->IsDefault = FALSE;
	info->usCntType = 0;
	info->usAPType = 0;
}

void InitMbnDongleSubInfo(pMbnDongleSubInfo info)
{
	info->strDeviceID = "";
	info->strManufacturer = "";
	info->strMode = "";
	info->strFirmware = "";
	info->strCellularClass = "";


	info->mbnReadyState = MBN_READY_STATE_OFF;
	info->mbnRegState = MBN_REGISTER_STATE_NONE;
	info->mbnCntState = MBN_ACTIVATION_STATE_NONE;

	info->strDataClass = "";
	info->strProfileName = "";
	info->strProviderName = "";
	info->strIMSI = ""; 
	info->strSimIccID = "";

	info->ulSingnal = 0UL;
}

DongleList g_DongleInfos;

void ResetDongleInfos(void)
{
	if(g_DongleInfos.GetCount() > 0) {
		for (int i=0; i<g_DongleInfos.GetCount(); ++i) {
			g_DongleInfos[i].priority = 0;
			if(g_DongleInfos[i].profileList.GetCount() > 0) {
				g_DongleInfos[i].profileList.Clear();
			}
		}
		g_DongleInfos.Clear();
	}
}

const char* ActivationStateToString(MBN_ACTIVATION_STATE activationState)
{
	switch(activationState)
	{
	case MBN_ACTIVATION_STATE_NONE: 
		return "NONE"; 
	case MBN_ACTIVATION_STATE_ACTIVATED: 
		return "CONNECTED"; 
	case MBN_ACTIVATION_STATE_ACTIVATING: 
		return "CONNECTING";
	case MBN_ACTIVATION_STATE_DEACTIVATED: 
		return "DISCONNECTED";
	case MBN_ACTIVATION_STATE_DEACTIVATING: 
		return "DISCONNECTING";
	default: 
		return "UNKNOWN"; 
	}
}

const char* CellularToString(MBN_CELLULAR_CLASS cellularClass)
{
	switch(cellularClass)
	{
	case MBN_CELLULAR_CLASS_NONE:
		return "NONE";
	case MBN_CELLULAR_CLASS_GSM:
		return "GSM";
	case MBN_CELLULAR_CLASS_CDMA:
		return "CDMA";
	default: 
		return "UNKNOWN";
	}
	return "ERRORTYPE";
}

const char* DataClassToString(MBN_DATA_CLASS dts)
{
	static char data[256] = {0};
	memset(data, 0, sizeof(data));
	bool bEmpty = true;

#define DEFINE_DATACLASS_MARCO(DataClass) \
	do { \
	if((dts & MBN_DATA_CLASS_##DataClass) == MBN_DATA_CLASS_##DataClass) { \
	if(!bEmpty) { \
		strcat_s(data, ", "); \
	} else { \
		bEmpty = false; \
	} \
	strcat_s(data, #DataClass); \
	} \
	}while(false)

	DEFINE_DATACLASS_MARCO(GPRS);
	DEFINE_DATACLASS_MARCO(EDGE);
	DEFINE_DATACLASS_MARCO(UMTS);
	DEFINE_DATACLASS_MARCO(HSDPA);
	DEFINE_DATACLASS_MARCO(HSUPA);
	DEFINE_DATACLASS_MARCO(LTE);
	DEFINE_DATACLASS_MARCO(1XRTT);
	DEFINE_DATACLASS_MARCO(1XEVDO);
	DEFINE_DATACLASS_MARCO(1XEVDO_REVA);
	DEFINE_DATACLASS_MARCO(1XEVDV);
	DEFINE_DATACLASS_MARCO(3XRTT);
	DEFINE_DATACLASS_MARCO(1XEVDO_REVB);
	DEFINE_DATACLASS_MARCO(UMB);
	DEFINE_DATACLASS_MARCO(CUSTOM);

	if(dts == 0) {
		return "UNKNOWN";
	}


	//if((dts & MBN_DATA_CLASS_GPRS) == MBN_DATA_CLASS_GPRS) {
	//	if(!bEmpty) {
	//		strcat_s(data, ", ");
	//	} else {
	//		bEmpty = false;
	//	}
	//	strcat_s(data, "GRPS");
	//}

	return data;

	/*
	switch(dts)
	{
	case MBN_DATA_CLASS_NONE :
		return "NONE";
		break;
	case MBN_DATA_CLASS_GPRS:
		return "GPRS-2G";
		break;
	case MBN_DATA_CLASS_EDGE:
		return "EDGE-3G";
		break;
	case MBN_DATA_CLASS_UMTS:
		//https://en.wikipedia.org/wiki/UMTS_(telecommunication)
		return "UMTS-3G";
		break;
	case MBN_DATA_CLASS_HSDPA:
		return "HSDPA-3G";
		break;
	case MBN_DATA_CLASS_HSUPA:
		return "HSUPA-3G";
		break;
	case MBN_DATA_CLASS_LTE:
		return "LTE-4G";
		break;
	case MBN_DATA_CLASS_1XRTT:
		return "1XRTT-3G";
		break;
	case MBN_DATA_CLASS_1XEVDO:
		return "1XEVDO-3G";
		break;
	case MBN_DATA_CLASS_1XEVDO_REVA:
		return "1XEVDO_REVA-3G";
		break;
	case MBN_DATA_CLASS_1XEVDV:
		return "1XEVDV-3G";
		break;
	case MBN_DATA_CLASS_3XRTT:
		return "3XRTT_CDMA2000-3G";
		break;
	case MBN_DATA_CLASS_1XEVDO_REVB:
		return "1XEVDO_REVB-3G";
		break;
	case MBN_DATA_CLASS_UMB:
		return "UMB-3/4G";
		break;
	case MBN_DATA_CLASS_CUSTOM:
		return "CUSTOM";
		break;
	default:
		return "UNKNOWN";
		break;
	}
	*/
}

const char* StateToString(MBN_READY_STATE readyState, MOBILEDIAL_CONNECTION_STATE& rdState)
{
	switch(readyState)  
	{ 
	case MBN_READY_STATE_OFF : 
		rdState = MBD_READY_BAD_SIM;
		return "OFF"; 
	case MBN_READY_STATE_INITIALIZED: 
		rdState = MBD_HOLD_MOBILEDONGLE;
		return "INITIALIZED";
	case MBN_READY_STATE_SIM_NOT_INSERTED:
		rdState = MBD_READY_SIM_NO_INSERT;
		return "SIM_NOT_INSERTED";
	case MBN_READY_STATE_BAD_SIM : 
		rdState = MBD_READY_BAD_SIM;
		return "BAD_SIM";
	case MBN_READY_STATE_FAILURE: 
		rdState = MBD_READY_FAILURE;
		return "FAILURE";
	case MBN_READY_STATE_NOT_ACTIVATED: 
		rdState = MBD_READY_NOT_ACTIVATED;
		return "NOT_ACTIVATED";
	case MBN_READY_STATE_DEVICE_LOCKED: 
		rdState = MBD_READY_DEVICE_LOCKED;
		return "DEVICE_LOCKED";
	case MBN_READY_STATE_DEVICE_BLOCKED: 
		rdState = MBD_READY_DEVICE_BLOCKED;
		return "DEVICE_BLOCKED";
	default : 
		rdState = MBD_UNKNOWN;
		return "UNKNOWN";
	}
}

const char* RegisterStateToString(MBN_REGISTER_STATE registerState, MOBILEDIAL_CONNECTION_STATE& rdState)
{
	switch(registerState)
	{
	case MBN_REGISTER_STATE_NONE:
		rdState = MBD_UNKNOWN;
		return "NONE"; 
	case MBN_REGISTER_STATE_DEREGISTERED: 
		rdState = MBD_REGISTERED_DEREG;
		return "DEREGISTERED"; 
	case MBN_REGISTER_STATE_SEARCHING:
		rdState = MBD_UNKNOWN;
		return "SEARCHING";
	case MBN_REGISTER_STATE_HOME:
		rdState = MBD_HOLD_MOBILEDONGLE;
		return "HOME";
	case MBN_REGISTER_STATE_ROAMING:
		rdState = MBD_HOLD_MOBILEDONGLE;
		return "ROAMING";
	case MBN_REGISTER_STATE_PARTNER:
		rdState = MBD_HOLD_MOBILEDONGLE;
		return "PARTNER";
	case MBN_REGISTER_STATE_DENIED:
		rdState = MBD_READY_BAD_SIM;
		return "DENIED";
	default: 
		rdState = MBD_UNKNOWN;
		return "UNKNOWN"; 
	}
}

const char* ConnectStateToString(MBN_ACTIVATION_STATE& cntState)
{
	switch(cntState)
	{
	case MBN_ACTIVATION_STATE_NONE:
		return "The connection state is unknown.";
		break;
	case MBN_ACTIVATION_STATE_ACTIVATED:
		return "The connection has been established.";
		break;
	case MBN_ACTIVATION_STATE_ACTIVATING:
		return "The device is establishing the connection.";
		break;
	case MBN_ACTIVATION_STATE_DEACTIVATED:
		return "There is no connection.";
		break;
	case MBN_ACTIVATION_STATE_DEACTIVATING:
		return "The device is in the process of disconnection.";
		break;
	default:
		return "returnValue cannot specified.";
		break;
	}
}

#define MBD_TO_STRING(mbnstate) \
	case mbnstate : return #mbnstate

LPCTSTR ConvertStatusToString(MOBILEDIAL_CONNECTION_STATE state)
{
	static char text[128] = {0};
	switch(state)
	{
	MBD_TO_STRING(MBD_VALID_CONNECTED);
	MBD_TO_STRING(MBD_INVALID_CONNECTED);
	MBD_TO_STRING(MBD_NOT_INITIALIZED);
	MBD_TO_STRING(MBD_NO_FOUND_CABLE);
	MBD_TO_STRING(MBD_RUN_CONFIG_INCOMPLEMENT);
	MBD_TO_STRING(MBD_CENTERSETTING_LACK);

	MBD_TO_STRING(MBD_NETWORK_TIMEOUT);
	MBD_TO_STRING(MBD_NETWORK_ERROR_SOCKET);
	MBD_TO_STRING(MBD_NETWORK_NOTFOUND_SOCKET);
	MBD_TO_STRING(MBD_NETWORK_INVALID_SOCKET);

	MBD_TO_STRING(MBD_CABLE_TYPE_MBB);
	MBD_TO_STRING(MBD_CABLE_TYPE_LTE);
	MBD_TO_STRING(MBD_CABLE_TYPE_WIRE);
	MBD_TO_STRING(MBD_CABLE_TYPE_DONGLE);
	MBD_TO_STRING(MBD_CABLE_TYPE_UNKNOWN);
	MBD_TO_STRING(MBD_CABLE_TYPE_WIFI);
	MBD_TO_STRING(MBD_CABLE_NOT_SUPPORT_TYPE);
	MBD_TO_STRING(MBD_CABLE_TYPE_LTE_ENHANCE);

	MBD_TO_STRING(MBD_RASDIAL_FAILED);
	MBD_TO_STRING(MBD_NO_MOBILEDONGLE);
	MBD_TO_STRING(MBD_NO_PROFILE);
	MBD_TO_STRING(MBD_NO_ENTRY);
	MBD_TO_STRING(MBD_CREATE_ENTRY_FAILED);
	MBD_TO_STRING(MBD_RUN_ENTRY_NOTFOUND);
	MBD_TO_STRING(MBD_INVALID_BOTH_DONGLE);

	MBD_TO_STRING(MBD_ACTIVATION_NONE);
	MBD_TO_STRING(MBD_ACTIVATION_CONNECTED);
	MBD_TO_STRING(MBD_ACTIVATION_CONNECTING);
	MBD_TO_STRING(MBD_ACTIVATION_DISCONNECTED);
	MBD_TO_STRING(MBD_ACTIVATION_DISCONNECTING);
	MBD_TO_STRING(MBD_CONNECTION_INVALID_ACCESS);
	MBD_TO_STRING(MBD_CONNECTION_INVALID_NAMEORPASSWORD);
	MBD_TO_STRING(MBD_CONNECTION_FAILURE);
	MBD_TO_STRING(MBD_READY_OFF);
	MBD_TO_STRING(MBD_READY_SIM_NO_INSERT);
	MBD_TO_STRING(MBD_READY_BAD_SIM);
	MBD_TO_STRING(MBD_READY_FAILURE);
	MBD_TO_STRING(MBD_READY_NOT_ACTIVATED);
	MBD_TO_STRING(MBD_READY_DEVICE_LOCKED);
	MBD_TO_STRING(MBD_READY_DEVICE_BLOCKED);
	MBD_TO_STRING(MBD_CONNECTION_PIN_REQUIRED);
	MBD_TO_STRING(MBD_CONNECTION_MAX_CONTEXTS);
	MBD_TO_STRING(MBD_POWER_OFF);
	MBD_TO_STRING(MBD_REGISTERED_DEREG);
	MBD_TO_STRING(MBD_REGISTERED_DENIED);
	MBD_TO_STRING(MBD_READY_INITIALIZED);
	MBD_TO_STRING(MBD_READY_NO_SERVICE);
	
	MBD_TO_STRING(MBD_WLAN_OFF);
	MBD_TO_STRING(MBD_WLAN_DISCONNECTED);
	MBD_TO_STRING(MBD_WLAN_CONNECTING);
	MBD_TO_STRING(MBD_WLAN_ENTRY_NO_FOUND);
	MBD_TO_STRING(MBD_WLAN_INVALID_NAMEORPASSWORD);
	MBD_TO_STRING(MBD_WLAN_CONNECTED);
	MBD_TO_STRING(MBD_WLAN_CONNECT_FAILED);
	MBD_TO_STRING(MBD_WLAN_CONFIG_CHANGED);
	MBD_TO_STRING(MBD_WLAN_CONFIG_REBOOT);
	MBD_TO_STRING(MBD_WLAN_DEVICE_PLUG_OFF);
	MBD_TO_STRING(MBD_WLAN_CONFIG_WAIT_REBOOT);
	MBD_TO_STRING(MBD_WLAN_DISCONNECT_UNEXPECT);
	MBD_TO_STRING(MBD_WLAN_CONNECTED_WITH_ILLEGAL_SSID);
	MBD_TO_STRING(MBD_WLAN_SSID_VISIBLE);
	
	MBD_TO_STRING(MBD_MIFI_START);
	MBD_TO_STRING(MBD_MIFI_LOGIN_INVALID_NAMEORPASSWORD);
	MBD_TO_STRING(MBD_MIFI_MACFILTER_UPDATE_FAILED);
	MBD_TO_STRING(MBD_MIFI_NEED_LOGIN);
	MBD_TO_STRING(MBD_MIFI_INVALID_PARAM);
	MBD_TO_STRING(MBD_MIFI_NOT_EXISTED);
	MBD_TO_STRING(MBD_MIFI_NOT_IMPLEMENTED);
	MBD_TO_STRING(MBD_MIFI_NO_DATA);
	MBD_TO_STRING(MBD_MIFI_NO_CHANGED);
	MBD_TO_STRING(MBD_MIFI_NOT_SUPPORTED);
	MBD_TO_STRING(MBD_MIFI_INVALID_CERT);
	MBD_TO_STRING(MBD_MIFI_NO_RIGHTS);
	MBD_TO_STRING(MBD_MIFI_NO_DEVICE);
	MBD_TO_STRING(MBD_MIFI_EXCEPTION);
	MBD_TO_STRING(MBD_MIFI_INVALID_SITUATION);
	MBD_TO_STRING(MBD_MIFI_OPT_FAILED);
	MBD_TO_STRING(MBD_MIFI_DEVICE_LOCKED);
	MBD_TO_STRING(MBD_MIFI_URL);
	MBD_TO_STRING(MBD_MIFI_LOW_BATTERY);
	MBD_TO_STRING(MBD_MIFI_BUSY);
	MBD_TO_STRING(MBD_MIFI_END);

	MBD_TO_STRING(MBD_CABLE_DEVICE_REMOVE);
	MBD_TO_STRING(MBD_MBN_DEVICE_REMOVE);
	MBD_TO_STRING(MBD_RAS_DEVICE_REMOVE);
	MBD_TO_STRING(MBD_MBN_DEVICE_REMOVE_IN_BUSINESS);
	MBD_TO_STRING(MBD_RAS_DEVICE_REMOVE_IN_BUSINESS);

	MBD_TO_STRING(MBD_CABLE_DEVICE_ARRIVAL);
	MBD_TO_STRING(MBD_MBN_DEVICE_ARRIVAL);
	MBD_TO_STRING(MBD_RAS_DEVICE_ARRIVAL);

	MBD_TO_STRING(MBD_CABLE_DIALUP_CONNETED);
	MBD_TO_STRING(MBD_MBN_DIALUP_CONNETED);
	MBD_TO_STRING(MBD_RAS_DIALUP_CONNETED);
	MBD_TO_STRING(MBD_MBB_DIALUP_CONNECTED);

	MBD_TO_STRING(MBD_CABLE_DIALUP_DISCONNETED);
	MBD_TO_STRING(MBD_MBN_DIALUP_DISCONNETED);
	MBD_TO_STRING(MBD_RAS_DIALUP_DISCONNETED);
	MBD_TO_STRING(MBD_MBN_DIALUP_DISCONNETED_IN_BUSINESS);
	MBD_TO_STRING(MBD_RAS_DIALUP_DISCONNETED_IN_BUSINESS);

	MBD_TO_STRING(MBD_DNS_SET_FAILED);
	MBD_TO_STRING(MBD_DNS_MULTI_CABLE_CONNECT);

	MBD_TO_STRING(MBD_INTERNET_START);
	MBD_TO_STRING(MBD_CABLE_TYPE_INTERNET_WIFI);
	MBD_TO_STRING(MBD_CABLE_TYPE_INTERNET_LTE);
	MBD_TO_STRING(MBD_CABLE_TYPE_INTERNET_DONGLE);
	MBD_TO_STRING(MBD_CABLE_TYPE_INERNET_UNKNOWN);

	MBD_TO_STRING(MBD_HOLD_MOBILEDONGLE);
	MBD_TO_STRING(MBD_UNKNOWN);
	MBD_TO_STRING(MBD_INTERNAL_ERROR);
	}
	sprintf_s(text, "MOBILEDIAL_UNEXPECT_STATE(0x%08X)", state);
	return text;
}

LPCTSTR ConvertStatusToSimpleName(MOBILEDIAL_CONNECTION_STATE state) {

	if(state == MBD_READY_SIM_NO_INSERT) {
		return "[无SIM卡]";
	} else {
		return MBN_ERROR_INVALID_STRING;
	}
}

namespace MBN {

	LPCTSTR ConvertOperatorToString(int value)
	{
		switch(value) {
		case 0:
			return "未知";
			break;
		case 1:
			return "中国联通";
			break;
		case 2:
			return "中国移动";
			break;
		case 3:
			return "中国电信";
			break;
		default:
			return "其他";
		}
	}

	MBN_READY_STATE ConvertToMBNState(int value)
{
/*
		sim_sub_state_unknown =       0,
		sim_sub_state_absent,         1
		sim_sub_state_pin_required,   2
		sim_sub_state_puk_required,   3
		sim_sub_state_network_locked, 4
		sim_sub_state_ready,          5
		sim_sub_state_not_ready,      6
		sim_sub_state_perm_disabled,  7
		sim_sub_state_card_io_error,  8
		sim_sub_state_card_restricted,9
		sim_sub_state_loaded,         10
		sim_sub_state_present         11
*/
	switch(value) {
	case 0:
		return MBN_READY_STATE_OFF;
	case 5:
	case 10:
	case 11:
		return MBN_READY_STATE_INITIALIZED;
	case 1:
		return MBN_READY_STATE_SIM_NOT_INSERTED;
	case 7:
		return MBN_READY_STATE_BAD_SIM;
	case 8:
		return MBN_READY_STATE_FAILURE;
	case 9:
		return MBN_READY_STATE_NOT_ACTIVATED;
	case 2:
	case 3:
	case 4:
		return MBN_READY_STATE_DEVICE_LOCKED;
	case 6:
		return MBN_READY_STATE_DEVICE_BLOCKED;
	default:
		return MBN_READY_STATE_OFF;
	}
}

MOBILEDIAL_CONNECTION_STATE ConvertToMCS(MBN_READY_STATE state)
{
	switch(state) {

		case MBN_READY_STATE_OFF:
			return MBD_READY_BAD_SIM;
		break;
		case MBN_READY_STATE_INITIALIZED:
			return MBD_READY_INITIALIZED;
			break;
		case MBN_READY_STATE_SIM_NOT_INSERTED:
			return MBD_READY_SIM_NO_INSERT;
			break;
		case MBN_READY_STATE_BAD_SIM:
			return MBD_READY_BAD_SIM;
			break;
		case MBN_READY_STATE_FAILURE:
			return MBD_READY_FAILURE;
			break;
		case MBN_READY_STATE_NOT_ACTIVATED:
			return MBD_READY_NOT_ACTIVATED;
			break;
		case MBN_READY_STATE_DEVICE_LOCKED:
			return MBD_READY_DEVICE_LOCKED;
			break;
		case MBN_READY_STATE_DEVICE_BLOCKED:
			return MBD_READY_DEVICE_BLOCKED;
		default:
			return MBD_READY_BAD_SIM;
			break;

	}
}


}



int GetSignalRank(ULONG ulSignalStrength)
{
	if(ulSignalStrength == MBN_RSSI_UNKNOWN) return 0;
	else if(ulSignalStrength >= 24) return(4);
	else if(ulSignalStrength >= 16) return(3);
	else if(ulSignalStrength >= 8) return(2);
	return (1);
}

CSimpleStringA EncryptString(LPCTSTR lpszText)
{
	int	iEncrypt=0;
	int len = strlen(lpszText);
	CSimpleStringA csEncrypted('\0', len*2+1);
	for(int i=0; i<len; ++i) {
		sprintf(&csEncrypted[i*2],"%02X", (int)((lpszText[i]) ^ (128 | (iEncrypt++ & 127))));
	}
	return CSimpleStringA((LPCTSTR)csEncrypted);
}

CSimpleStringA DecryptString(LPCTSTR lpszEncrpyted)
{
	int	iEncrypt=0;
	int len = strlen(lpszEncrpyted);
	CSimpleStringA csPlainTxt('\0', (len)/2+1);
	int iCh = 0;
	for(int i=0; i<len; i+=2) {
		sscanf(lpszEncrpyted+i, "%02X", &iCh);
		csPlainTxt[i/2] = (char)(((char)iCh) ^ (128 | (iEncrypt++ & 127)));
	}
	return CSimpleStringA((LPCTSTR)csPlainTxt);
}

MOBILEDIAL_CONNECTION_STATE MBBResult2Status(int value)
{
	switch(value)
	{
		case 0:  return MBD_NOT_INITIALIZED;
		case -2: return MBD_MIFI_NEED_LOGIN;
		case -3: return	MBD_MIFI_LOGIN_INVALID_NAMEORPASSWORD;
		case -4: return MBD_MIFI_INVALID_PARAM;
		case -5: return MBD_MIFI_NOT_EXISTED;
		case -6: return MBD_MIFI_NOT_IMPLEMENTED;
		case -7: return MBD_MIFI_NO_DATA;
		case -8: return MBD_MIFI_NO_CHANGED;
		case -9: return MBD_MIFI_NOT_SUPPORTED;
		case -10: return MBD_MIFI_INVALID_CERT;
		case -11: return MBD_MIFI_NO_RIGHTS;
		case -12: return MBD_MIFI_NO_DEVICE;
		case -13: return MBD_MIFI_EXCEPTION;
		case -14: return MBD_MIFI_INVALID_SITUATION;
		case -15: return MBD_MIFI_TIMEOUT;
		case -16: return MBD_MIFI_OPT_FAILED;
		case -17: return MBD_MIFI_DEVICE_LOCKED;
		case -18: return MBD_MIFI_URL;
		case -19: return MBD_MIFI_BUSY;
		default:
			break;
	}
	return MBD_UNKNOWN;

}

void GetCurWindowsVersion(void)
{
	DWORD dwMajorVer;
	DWORD dwMinVer;
	DWORD dwBuildNumber;
	BOOL bValid = FALSE;
	HMODULE hModuleDll = NULL;
	if(hModuleDll = ::LoadLibraryA("ntdll.dll")) {
		typedef void (WINAPI * pfRTLGETNTVERSIONNUMBERS)(DWORD*, DWORD*, DWORD*);
		pfRTLGETNTVERSIONNUMBERS pfRtlGetNtVersionNumbers = NULL;
		pfRtlGetNtVersionNumbers = (pfRTLGETNTVERSIONNUMBERS)::GetProcAddress(hModuleDll, "RtlGetNtVersionNumbers");
		if(pfRtlGetNtVersionNumbers) {
			pfRtlGetNtVersionNumbers(&dwMajorVer, &dwMinVer, &dwBuildNumber);
			dwBuildNumber &= 0x0FFFF;
			bValid = TRUE;
		}
	}

	::FreeLibrary(hModuleDll);
	hModuleDll = NULL;
	wv = 0;

	{
		SYSTEM_INFO si = { 0 };
		GetNativeSystemInfo(&si);

		switch (si.wProcessorArchitecture){
		case 0:
			gArch = 32; //  Intel x86
			break;
		case 9:
			gArch = 64; // Intel/AMD x64
			break;
		case 6: // Itanium-based x64
		default:
			gArch = 0;
			break;
		}
	}

	if(!bValid) {
		return;
	}

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("dwMajorVer: %d, dwMinVer: %d, dwBuildNumber: %d", dwMajorVer, dwMinVer, dwBuildNumber);

	if (dwMajorVer == 5 && dwMinVer < 1 || dwMajorVer < 5)
	{
		wv = 1;
	}
	/* Windows XP */
	else if (dwMajorVer == 5 && dwMinVer == 1)
	{
		wv = 2;
	}
	/* Windows Server 2003 */
	else if (dwMajorVer == 5 && dwMinVer == 2)
	{
		wv = 3;
	}
	/* Windows Vista, Windows Server 2008 */
	else if (dwMajorVer == 6 && dwMinVer == 0)
	{
		wv = 4;
	}
	/* Windows 7, Windows Server 2008 R2 */
	else if (dwMajorVer == 6 && dwMinVer == 1)
	{
		wv = 7;
	}
	/* Windows 8 */
	else if (dwMajorVer == 6 && dwMinVer == 2)
	{
		wv = 8;
	}
	/* Windows 8.1 */
	else if (dwMajorVer == 6 && dwMinVer == 3)
	{
		wv = 8;
	}
	/* Windows 10 */
	else if (dwMajorVer == 10 && dwMinVer == 0)
	{
		wv = 10;
	}
	else if (dwMajorVer == 10 && dwMinVer > 0 || dwMajorVer > 10)
	{
		wv = 99;
	}
}