📄 zdwlanadapter.cpp
字号:
// ZDWlanAdapter.cpp: implementation of the ZDWlanAdapter class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "..\ZDUSBMP_DUT.h"
#include "ZDWlanAdapter.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#include "ZD12Para.H"
#include <Winsvc.h>
#include <math.h>
// Default Extended EEPROM Data.
EXT_EEPROM_BUFFER g_DefaultExtEE[EXT_EE_MAX_ID+1] = {
{0x03, {0x00, 0x00}}, // 0x00 EXTEE_ID_END_SETTING
{0x07, {0x00, 0xA0, 0xC5, 0xFE, 0xDC, 0xBA}}, // 0x01 EXTEE_ID_MAC_ADDRESS
{0x0F, {0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, // 0x02 EXTEE_ID_TX_SET_POINT
0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B}},
{0x0F, {0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, // 0x03 EXTEE_ID_TX_INTEG_VAL
0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5}},
{0x00, {0x00}}, // 0x04 Reserved.
{0x02, {0x10}}, // 0x05 EXTEE_LEN_HW_VER
{0x03, {0xFF, 0x3F}}, // 0x06 EXTEE_LEN_ALLOW_CH
{0x03, {0x00, 0x04}}, // 0x07 EXTEE_LEN_DEFAULT_CH
{0x02, {0x10}}, // 0x08 EXTEE_ID_REGION_CODE
{0x0D, {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, // 0x09 EXTEE_ID_SN
0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B}},
{0x02, {0x03}}, // 0x0A EXTEE_ID_RF_MODULE
{0x03, {0xCE, 0x0A}}, // 0x0B EXTEE_ID_USB_VENDOR_ID
{0x03, {0x01, 0x12}}, // 0x0C EXTEE_ID_USB_DEVICE_ID
{0x0B, {0x04, 0x03, 0x09, 0x04, 0x00, 0x00, 0x00, // 0x0D EXTEE_ID_USB_STR0
0x00, 0x00, 0x00}},
{0x15, {0x0E, 0x03, 0x5A, 0x00, 0x79, 0x00, 0x44, // 0x0E EXTEE_ID_USB_STR1
0x00, 0x41, 0x00, 0x53, 0x00, 0x20, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{0x15, {0x12, 0x03, 0x55, 0x00, 0x53, 0x00, 0x42, // 0x0F EXTEE_ID_USB_STR2
0x00, 0x20, 0x00, 0x57, 0x00, 0x4C, 0x00,
0x41, 0x00, 0x4E, 0x00, 0x00, 0x00}},
{0x02, {0x01}} // 0x10 EXTEE_ID_PA_TYPE
};
char g_HexAsc[] = {'0','1','2','3','4','5','6','7',
'8','9','A','B','C','D','E','F'};
INT QueryHLMReg(LPCTSTR pszKeyPath, LPCTSTR pszName, LPCTSTR pszNew, LPDWORD pDwLen)
{
HKEY hKeyObj;
DWORD dwWORD;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszKeyPath, 0, KEY_ALL_ACCESS, &hKeyObj)
== ERROR_SUCCESS)
{
if(RegQueryValueEx(hKeyObj, pszName, NULL, &dwWORD, (LPBYTE)pszNew, pDwLen) == ERROR_SUCCESS) {
RegCloseKey(hKeyObj);
return ZDNDIS_SUCCESS;
} else {
RegCloseKey(hKeyObj);
return ZDNDIS_FAIL;
}
} else {
return ZDNDIS_FAIL;
}
}
INT SetHLMReg(LPCTSTR pszKeyPath, LPCTSTR pszName, LPCTSTR pszNew)
{
HKEY hKeyObj;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszKeyPath, 0, KEY_ALL_ACCESS, &hKeyObj)
== ERROR_SUCCESS)
{
RegSetValueEx(hKeyObj, pszName, NULL, REG_SZ, (LPBYTE)pszNew, strlen(pszNew)+1);
RegCloseKey(hKeyObj);
return ZDNDIS_SUCCESS;
} else {
RegCloseKey(hKeyObj);
return ZDNDIS_FAIL;
}
}
//---------------------------------------------------------------------------
//
// S T R I N G P R O C E S S F U N C T I O N
//
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Input : char inum
// Output string: ostr
//
void CharToHex(char inum, char* ostr)
{
int iinum = ((int)inum) & 0xff;
*ostr++ = g_HexAsc[(iinum >> 4 )];
*ostr++ = g_HexAsc[(iinum & 0x0F)];
*ostr = NULL;
}
//---------------------------------------------------------------------------
BOOL IsHexDigit(char cChar)
{
if( (cChar >= '0' && cChar <= '9') ||
(cChar >= 'A' && cChar <= 'F') ||
(cChar >= 'a' && cChar <= 'f') ) {
return 1;
} else {
return 0;
}
}
//---------------------------------------------------------------------------
int BinToHexSpace(char* pInBinData,
char* pOutHexSpace,
int ConvLen)
{
BinToHexStr(pInBinData, pOutHexSpace, ConvLen, 1);
return 1;
}
//---------------------------------------------------------------------------
// Warring!! This convert function can convert 2 bytes Hexdecimal
// The range is from 0 ~ FFFFFFFE, The prefix '0x' or '0X' is not needed.
// If input character not 0 ~ F or not NULL, return 0xFFFFFFFF
UINT HexToUINT(char* pstr)
{
UINT uResult = 0;
while(*pstr)
{
if(!IsHexDigit(*pstr)) {
return 0xFFFFFFFF;
}
uResult = uResult * 16;
if(*pstr > '9')
uResult = uResult + (char)(*pstr & 0xF) + 9;
else
uResult = uResult + (char)(*pstr & 0xF);
pstr++;
}
return uResult;
}
//---------------------------------------------------------------------------
DWORD HexToDWORD(char* pstr)
{
DWORD uResult = 0;
while(*pstr)
{
if(!IsHexDigit(*pstr)) {
return 0xFFFFFFFF;
}
uResult = uResult * 16;
if(*pstr > '9')
uResult = uResult + (char)(*pstr & 0xF) + 9;
else
uResult = uResult + (char)(*pstr & 0xF);
pstr++;
}
return uResult;
}
//---------------------------------------------------------------------------
// Input:
// pInStr : Point to the Input string to convert
// pBinData : Point to the Output string (binary data)
// ConvLen : How many Hex need to convert to binary.
//
// Output:
// 0: Failed
// 1: Success
//---------------------------------------------------------------------------
int HexStrToBin(char* pInStr,
char* pOutBinData, // Need (1 * ConvLen) bytes space to use(NULL Terminate is not needed).
int ConvLen) // How many couple of hexdecimal string to be convert
{
bool exitFlag = 0; // Exit parsing
bool stateTrigger = 0; // Find data to convert
bool lastHex = 0; // Last input character is Hex?
int bytesCount = 0; // How many Hex character have been find
int HexCoupleCount = 0; // How many hex already convert
char TempStr[3]; // TempStr for convert Hex to byte
char *pch1; // pointer
char *pch2; // pointer
int i;
// Set all output buffer to 0.
pch1 = pOutBinData;
for(i=0; i<ConvLen; i++) {
*pch1++ = 0; // Clear pOutBinData
}
pch1 = pInStr;
pch2 = pOutBinData;
// Generate the output binary string.
while(1) // Parsing input string
{
switch(*pch1) {
case NULL: // Termainal string
exitFlag = 1;
if(bytesCount > 0)
stateTrigger = 1; // *** Need parsing the number.
break;
case 0x20: // SPACE
case 0x09: // TAB
if(lastHex)
stateTrigger = 1; // *** Need parsing the number.
break;
default:
if(!IsHexDigit(*pch1)) { // Not hexdecimal character
exitFlag = 1;
break;
}
if(HexCoupleCount >= ConvLen){ // Too much input.
exitFlag = 1;
break;
}
lastHex = 1;
bytesCount++;
if(bytesCount == 2)
stateTrigger = 1; // *** Need parsing the number.
break;
} // End of switch(*pch1)
pch1++;
// Generate binary output
if(stateTrigger) {
pch1 = pch1 - 2;
strncpy(TempStr,pch1,bytesCount);
TempStr[bytesCount] = NULL; // Set the NULL Terminated.
*pch2++ = (char)HexToUINT(TempStr);
HexCoupleCount++;
pch1 = pch1 + 2;
stateTrigger = 0;
bytesCount = 0;
lastHex = 0;
} // End of if(stateTrigger)
if(exitFlag)
break;
} // End of while(*pch != NULL)
return 1; // Convert OK!!
}
//---------------------------------------------------------------------------
// pInBinData : The binary string to be convert
// pOutHexString: The output hexdecimal string
// ConvLen : Convert binary string length
// bSpace : Insert space between each hexdecimal 1: Insert space
// 0: Not insert space
int BinToHexStr( char* pInBinData,
char* pOutHexString,
int ConvLen,
BOOL bSpace)
{
int i;
for( i=0; i<ConvLen; i++) {
CharToHex(*pInBinData, pOutHexString);
pOutHexString += 2;
if(bSpace)
*pOutHexString++ = 0x20;
pInBinData++;
}
if(bSpace)
pOutHexString--;
*pOutHexString = 0; // Null-terminated
return 1;
}
BOOL CheckHEXValues(CString str, int length)
{
for (int j=0; j<length; j++){
if( (str.GetAt(j) > 'F') || (str.GetAt(j) < 'A') && (str.GetAt(j) > '9') || (str.GetAt(j) < '0') ){
return FALSE;
}
}
return TRUE;
}
//---------------------------------------------------------------------------
void IntegerToBinaryStr(int nValue, int bitNum, char* szBuffer)
{
int i;
int MaskValue;
char* pCh;
pCh = szBuffer;
*pCh = 0;
MaskValue = 0x0001 << (bitNum-1);
if(bitNum < 1 || bitNum > 16)
return;
for(i=0; i<bitNum; i++) {
if(nValue & MaskValue)
*pCh = '1';
else
*pCh = '0';
pCh++;
MaskValue = MaskValue >> 1;
}
*pCh = 0;
}
//---------------------------------------------------------------------------
void ParsingExtEEPROM(UCHAR* pcEEBuffer, PEXT_EEPROM_BUFFER pExtStructBuf, int nMaxStructNum)
{
UCHAR nID, nLength;
int nExtIDCharCount;
int i;
// Empty the Extended EEPROM buffer.
for(i=0; i<nMaxStructNum; i++) {
pExtStructBuf[i].nLength = (UCHAR)0x00;
}
nID = 0;
nLength = 0;
nExtIDCharCount = 0;
while(1) {
if(nExtIDCharCount > 253)
break;
nLength = pcEEBuffer[nExtIDCharCount++];
nID = pcEEBuffer[nExtIDCharCount++];
if( (nExtIDCharCount + nLength) > 255) { // Exceed the Extended EEPROM buffer size.
break;
}
if( nID >= nMaxStructNum ) {
break;
}
if( (nID < EXT_EE_MIN_ID) || (nID > EXT_EE_MAX_ID) ) {
break;
}
if( (nLength < EXT_EE_MIN_LENGTH) || (nLength > EXT_EE_MAX_LENGTH) ) {
break;
}
pExtStructBuf[nID].nLength = nLength;
memcpy(pExtStructBuf[nID].cIDData, &pcEEBuffer[nExtIDCharCount], (nLength-1));
nExtIDCharCount = nExtIDCharCount + nLength - 1;
if(nID == EXT_EE_END_ID) {
break;
}
} // End of while(1)
} // End of Function: void ParsingExtEEPROM(UCHAR* pcEEBuffer, PEXT_EEPROM_BUFFER pExtStructBuf)
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CZDWlanAdapter::CZDWlanAdapter()
{
pAdapterInfo = new WLADAPTERINFO[MAX_ADAPTER];
CurrentOpenAdapterAmount = 0;
tempAdapterAmount = 0;
g_nZDChipVersion= 0x1201; //depend on ZDConfig.INI
//------------------------------------------------------------------
// Get Matching Device ID
char fileName[256];
char szBuffer[256];
char szBuffer1[256];
CString strModulePath;
CString strINIFullPath;
CString strTempStr;
int nLastOffset;
int i;
//------------------------------------------------------------------
// Get current path.
GetModuleFileName(AfxGetInstanceHandle(), fileName, 256);
strModulePath = fileName;
nLastOffset = strModulePath.ReverseFind('\\');
strINIFullPath = strModulePath.Left( nLastOffset+1);
strINIFullPath += "ZDDevice.INI";
i=0;
while(1) {
sprintf(szBuffer1, "%s%d", "MatchingDeviceId", i);
strTempStr = "";
::GetPrivateProfileString(
"ADAPTER_INFORMATION",
szBuffer1,
(const char *) strTempStr,
szBuffer,
256,
(LPCTSTR)strINIFullPath
);
strTempStr.Format(szBuffer);
g_sMatchingDeviceId[i] = strTempStr;
i++;
if( (i >= 10) || (strTempStr == "") )
break;
}
}
CZDWlanAdapter::~CZDWlanAdapter()
{
int i;
for (i=0; i<CurrentOpenAdapterAmount; i++){
CloseAdapter(&pAdapterInfo[i]);
}
delete []pAdapterInfo;
}
INT CZDWlanAdapter::QueryWin32NDISOid(PWLADAPTERINFO pWLAdapterInfoIn, DWORD oid, PVOID pInfoBuf, DWORD nInfoBufLen)
{
W32N_REQUEST W32N_Request;
NDIS_STATUS nNdisStatus;
OVERLAPPED ovRidOverlap;
DWORD dBytes;
ovRidOverlap.hEvent = CreateEvent(
NULL, // Security Attributes
FALSE, // Auto-Reset
FALSE, // Initial State Signaled
NULL // Event-object Name
);
if( !ovRidOverlap.hEvent ) {
return ZDNDIS_FAIL;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -