📄 usbmicard.cpp
字号:
// wsprintf(szBuf,"INVALID MODE");
nErr=1;
}
if(CurrentCardType==0x04){
// Mifare 1K
if(nBlock < 0 || nBlock > 63) {
// wsprintf(szBuf,"INVALID BLOCK");
nErr=1;
}
}
else if(CurrentCardType==0x02){
// Mifare 4K
if(nBlock < 0 || nBlock > 255) {
// wsprintf(szBuf,"INVALID BLOCK");
nErr=1;
}
}
else nErr=1;
if(nErr==0){
SendBuf[0]=0xAD;
SendBuf[1]=0x16;
SendBuf[2]=nBlock;
Card_Sn=sSN;
SendBuf[2]=(BYTE)nBlock;
SendBuf[3]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[4]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[5]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[6]=(BYTE)Card_Sn;
for(i=7;i<23;i++)
SendBuf[i]=SendDat[i-7];
SendBuf[23]=(BYTE)nMode;
for(i=0;i<24;i++)
check=check^SendBuf[i];
SendBuf[24]=check;
status=Communicate(RevBuf,19,SendBuf,25);
if(status)
{
check=0;
for(i=0;i<18;i++)
check^=RevBuf[i];
for(i=2;i<18;i++)
{
RevDat[i-2]=RevBuf[i];
if(RevBuf[i]!=SendBuf[i+5])
{
status=0;
break;
}
status=1;
}
if(check==RevBuf[18] && RevBuf[0]==0x00 && RevBuf[1]==0x10 && RevBuf[18]==check && status)
{
nErr=0;
}
else
nErr=1;
}
else
nErr=1;
}
return(nErr);
}
MI_CARD_API long FAR PASCAL MifUSB_WriteBlockEx(BYTE nSector, BYTE nBlock, unsigned long sSN, BYTE nMode, BYTE *sKey, BYTE *SendDat)
{
// AFX_MANAGE_STATE(AfxGetStaticModuleState());
BYTE bBlock;
BYTE SendBuf[25],RevBuf[19],RevDat[16],i,check=0;
BOOL status;
unsigned long Card_Sn;
int nErr=0;
if(CurrentCardType==0x04){
if((nSector < 0) || (nSector > 15)){
// wsprintf(szBuf,"INVALID SECTOR");
nErr=1;
}
}
else if(CurrentCardType==0x02){
if((nSector < 0) || (nSector > 39)){
// wsprintf(szBuf,"INVALID SECTOR");
nErr=1;
}
}
if(nErr==0){
if(MifareTransKey(nSector, sKey)){
return(3);
}
else{
if(nMode < 0 || nMode > 1) {
return(1);
}
if(CurrentCardType==0x04){
// Mifare 1K
if(nBlock < 0 || nBlock > 3) {
// wsprintf(szBuf,"INVALID BLOCK");
nErr=1;
}
}
else if(CurrentCardType==0x02){
// Mifare 4K
if(nSector < 32){
if(nBlock < 0 || nBlock > 3) {
// wsprintf(szBuf,"INVALID BLOCK");
nErr=1;
}
}
else{
if(nBlock < 0 || nBlock > 15) {
// wsprintf(szBuf,"INVALID BLOCK");
nErr=1;
}
}
}
if(nErr==0){
if(nSector > 31){
bBlock = (32 * 4) + (((nSector - 32) * 16) + nBlock);
}
else{
bBlock = nSector * 4 + nBlock;
}
SendBuf[0]=0xAD;
SendBuf[1]=0x16;
SendBuf[2]=bBlock;
Card_Sn=sSN;
SendBuf[3]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[4]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[5]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[6]=(BYTE)Card_Sn;
for(i=7;i<23;i++)
SendBuf[i]=SendDat[i-7];
SendBuf[23]=nMode;
for(i=0;i<24;i++)
check=check^SendBuf[i];
SendBuf[24]=check;
status=Communicate(RevBuf,19,SendBuf,25);
if(status)
{
check=0;
for(i=0;i<18;i++)
check^=RevBuf[i];
for(i=2;i<18;i++)
{
RevDat[i-2]=RevBuf[i];
if(RevBuf[i]!=SendBuf[i+5])
{
status=0;
break;
}
status=1;
}
if(check==RevBuf[18] && RevBuf[0]==0x00 && RevBuf[1]==0x10 && RevBuf[18]==check && status)
{
nErr=0;
}
else
nErr=1;
}
else
nErr=1;
}
}
}
return(nErr);
}
// -------------------------------------------------------- //
MI_CARD_API long FAR PASCAL MifUSB_OpenDevice()
{
Z_STATUS status = Z_Open(0, &m_hUSBDevice);
// Open selected file.
if (status == Z_SUCCESS)
{
// Write file to device in MAX_PACKET_SIZE-byte chunks.
// Get the write handle
m_hUSBWrite = sgCUsbIF.OpenUSBfile(SILABS_BULK_WRITEPIPE);
if (m_hUSBWrite == INVALID_HANDLE_VALUE)
{
return 1;
}
// Get the read handle
m_hUSBRead = sgCUsbIF.OpenUSBfile(SILABS_BULK_READPIPE);
if (m_hUSBRead == INVALID_HANDLE_VALUE)
{
return 1;
}
cBitStatus=0;
return 0;
}
else
{
return 1;
}
}
MI_CARD_API long FAR PASCAL MifUSB_CloseDevice()
{
if (m_hUSBDevice != INVALID_HANDLE_VALUE)
{
Z_STATUS status =Z_Close(m_hUSBDevice);
m_hUSBDevice = INVALID_HANDLE_VALUE;
if (status == Z_SUCCESS)
return 0;
else
return 1;
}
return 1;
}
// -------------------------------------------------------- //
int MF_ReadBlock(int BlockSN,unsigned long CardSN,int mode, BYTE *RevDat)
{
BYTE SendBuf[9],RevBuf[19],i,check=0;
BOOL status;
unsigned long Card_Sn;
Card_Sn=CardSN;
SendBuf[0]=0xAC;
SendBuf[1]=0x06;
SendBuf[2]=(BYTE)BlockSN;
SendBuf[3]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[4]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[5]=(BYTE)Card_Sn%256;
Card_Sn=Card_Sn/256;
SendBuf[6]=(BYTE)Card_Sn;
SendBuf[7]=(BYTE)mode;
for(i=0;i<8;i++)
check^=SendBuf[i];
SendBuf[8]=check;
status=Communicate(RevBuf,19,SendBuf,9);
if(status)
{
check=0;
for(i=0;i<18;i++)
check^=RevBuf[i];
if(check==RevBuf[18] && RevBuf[0]==0x00 && RevBuf[1]==0x10)
{
for(i=2;i<18;i++)
RevDat[i-2]= RevBuf[i];
return 0;
}
else
return 1;
}
else
return 1;
}
int MF_GetSN(unsigned long *CardSN)
{
BYTE SendBuf[3],RevBuf[7],i,check=0;
BOOL status;
SendBuf[0]=0xAB;
SendBuf[1]=0x00;
SendBuf[2]=0xAB;
status=Communicate(RevBuf,7,SendBuf,3);
if(status)
{
for(i=0;i<6;i++)
check^=RevBuf[i];
if(check==RevBuf[6] && RevBuf[0]==0x00 && RevBuf[1]==0x04)
{
*CardSN=RevBuf[2]+RevBuf[3]*256+RevBuf[4]*256*256+RevBuf[5]*256*256*256;
return 0;
}
else
return 1;
}
else
return 1;
}
int MF_TransKey(int nSector , LPSTR sKey)
{
BYTE SendBuf[10],RevBuf[3],i,check=0;
BOOL status;
SendBuf[0]=0xA4;
SendBuf[1]=0x07;
SendBuf[2]=(BYTE)nSector;
for(i=3;i<9;i++)
SendBuf[i]=sKey[i-3];
for(i=0;i<9;i++)
check^=SendBuf[i];
SendBuf[9]=check;
status=Communicate(RevBuf,3,SendBuf,10);
if(status)
{
if(RevBuf[0]==0x00 && RevBuf[1]==0x00 && RevBuf[2]==0x00)
return 0;
else
return 1;
}
else
return 1;
}
// -------------------------------------------------------- //
Z_STATUS
Z_GetNumDevices(LPDWORD lpdwNumDevices)
{
Z_STATUS status = Z_DEVICE_NOT_FOUND;
// Validate parameter
if (!ValidParam(lpdwNumDevices))
{
return Z_INVALID_PARAMETER;
}
// Must set the GUID for functions that access the registry.
sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);
*lpdwNumDevices = sgCUsbIF.GetNumDevices();
if (*lpdwNumDevices > 0)
{
status = Z_SUCCESS;
}
return status;
}
//------------------------------------------------------------------------
// Z_GetProductString()
//
// Find the product string of a device by index in the registry.
//------------------------------------------------------------------------
Z_STATUS
Z_GetProductString(DWORD dwDeviceNum, LPVOID lpvDeviceString, DWORD dwFlags)
{
Z_STATUS status = Z_DEVICE_NOT_FOUND;
CDeviceListEntry dev;
// Validate parameter
if (!ValidParam(lpvDeviceString))
{
return Z_INVALID_PARAMETER;
}
// Must set the GUID for functions that access the registry.
sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);
sgCUsbIF.GetDeviceStrings(dwDeviceNum, dev);
switch (dwFlags)
{
case Z_RETURN_SERIAL_NUMBER:
if (dev.m_serialnumber.length() > 0)
{
strcpy((char*)lpvDeviceString, dev.m_serialnumber.c_str());
status = Z_SUCCESS;
}
break;
case Z_RETURN_DESCRIPTION:
if (dev.m_friendlyname.length() > 0)
{
strcpy((char*)lpvDeviceString, dev.m_friendlyname.c_str());
status = Z_SUCCESS;
}
break;
default:
break;
}
return status;
}
//------------------------------------------------------------------------
// Z_Open()
//
// Open a file handle to access a Silabs device by index number. The open
// routine determines the device's full name and uses it to open the handle.
//------------------------------------------------------------------------
Z_STATUS
Z_Open(DWORD dwDevice, HANDLE* cyHandle)
{
Z_STATUS status = Z_DEVICE_NOT_FOUND;
// Validate parameter
if (!ValidParam(cyHandle))
{
return Z_INVALID_PARAMETER;
}
// Must set the GUID for functions that access the registry.
sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);
if (cyHandle)
{
*cyHandle = sgCUsbIF.Open(dwDevice);
if (*cyHandle != INVALID_HANDLE_VALUE)
{
status = Z_SUCCESS;
}
}
else
{
status = Z_INVALID_HANDLE;
}
return status;
}
//------------------------------------------------------------------------
// Z_Close()
//
// Close file handle used to access a Silabs device.
//------------------------------------------------------------------------
Z_STATUS
Z_Close(HANDLE cyHandle)
{
Z_STATUS status = Z_INVALID_HANDLE;
if ((cyHandle != NULL) && (cyHandle != INVALID_HANDLE_VALUE))
{
::CloseHandle(cyHandle);
status = Z_SUCCESS;
}
return status;
}
//------------------------------------------------------------------------
// Z_Read()
//
// Read data from USB device.
// If read timeout value has been set, check RX queue until Z_RX_COMPLETE
// flag bit is set. If timeout the occurs before Z_RX_COMPLETE, return
// error. If no timeout has been set attempt read immediately.
//------------------------------------------------------------------------
Z_STATUS
Z_Read(HANDLE cyHandle, LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpdwBytesReturned)
{
Z_STATUS status = Z_SUCCESS;
// Validate parameters
if (!ValidParam(lpBuffer, lpdwBytesReturned))
{
return Z_INVALID_PARAMETER;
}
// Check for a valid Handle value
if (cyHandle != INVALID_HANDLE_VALUE)
{
// Check that the read length is within range
if ((dwBytesToRead > 0) && (dwBytesToRead <= Z_MAX_READ_SIZE))
{
// Read transfer packet
while(!ReadFile(cyHandle, lpBuffer, dwBytesToRead, lpdwBytesReturned, NULL))
{ // Device IO failed.
status = Z_READ_ERROR;
}
}
else
status = Z_INVALID_REQUEST_LENGTH;
}
else
status = Z_INVALID_HANDLE;
return status;
}
//------------------------------------------------------------------------
// Z_Write()
//
// Write data to USB device.
// If write timeout value has been set, continue write attempts until
// successful or timeout occurs.
//------------------------------------------------------------------------
Z_STATUS
Z_Write(HANDLE cyHandle, LPVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpdwBytesWritten)
{
Z_STATUS status = Z_INVALID_HANDLE;
// Validate parameters
if (!ValidParam(lpBuffer, lpdwBytesWritten))
{
return Z_INVALID_PARAMETER;
}
if (cyHandle != INVALID_HANDLE_VALUE)
{
if ((dwBytesToWrite > 0) && (dwBytesToWrite <= Z_MAX_WRITE_SIZE))
{
if (!WriteFile(cyHandle, lpBuffer, dwBytesToWrite, lpdwBytesWritten, NULL))
{
status = Z_WRITE_ERROR;
if (sgdwWriteTimeout > 0)
{
DWORD dwStart = GetTickCount();
DWORD dwEnd = GetTickCount();
// Keep trying to write until success or timeout
while((dwEnd - dwStart) < sgdwWriteTimeout && status != Z_SUCCESS)
{
if (WriteFile(cyHandle, lpBuffer, dwBytesToWrite, lpdwBytesWritten, NULL))
{
status = Z_SUCCESS; // Write succeeded after > 1 attempts.
}
dwEnd = GetTickCount();
}
}
}
else
status = Z_SUCCESS; // Write succeeded on first attempt.
}
else
status = Z_INVALID_REQUEST_LENGTH;
}
return status;
}
//------------------------------------------------------------------------
// ValidParam(LPDWORD)
//
// Checks validity of an LPDWORD pointer value.
//------------------------------------------------------------------------
static BOOL ValidParam(LPDWORD lpdwPointer)
{
DWORD temp = 0;
try
{
temp = *lpdwPointer;
}
catch(...)
{
return FALSE;
}
return TRUE;
}
//------------------------------------------------------------------------
// ValidParam(LPVOID)
//
// Checks validity of an LPVOID pointer value.
//------------------------------------------------------------------------
static BOOL ValidParam(LPVOID lpVoidPointer)
{
BYTE temp = 0;
try
{
temp = *((BYTE*)lpVoidPointer);
}
catch(...)
{
return FALSE;
}
return TRUE;
}
//------------------------------------------------------------------------
// ValidParam(HANDLE*)
//
// Checks validity of an HANDLE* pointer value.
//------------------------------------------------------------------------
static BOOL ValidParam(HANDLE* lpHandle)
{
HANDLE temp = 0;
try
{
temp = *lpHandle;
}
catch(...)
{
return FALSE;
}
return TRUE;
}
//------------------------------------------------------------------------
// ValidParam(LPVOID, LPDWORD)
//
// Checks validity of LPVOID, LPDWORD pair of pointer values.
//------------------------------------------------------------------------
static BOOL ValidParam(LPVOID lpVoidPointer, LPDWORD lpdwPointer)
{
if (ValidParam(lpVoidPointer))
if (ValidParam(lpdwPointer))
return TRUE;
return FALSE;
}
//------------------------------------------------------------------------
// ValidParam(LPDWORD, LPDWORD)
//
// Checks validity of LPDWORD, LPDWORD pair of pointer values.
//------------------------------------------------------------------------
static BOOL ValidParam(LPDWORD lpdwPointer1, LPDWORD lpdwPointer2)
{
if (ValidParam(lpdwPointer1))
if (ValidParam(lpdwPointer2))
return TRUE;
return FALSE;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -