public void DisableQCEmvMode()
{
try
{
// Disable QC Mode
string command = USDK_CONFIGURATION_COMMANDS.DISABLE_QUICK_CHIP_MODE;
DeviceCommand(command, true);
// Disable ICC
RETURN_CODE rt = IDT_Augusta.SharedController.icc_disable();
// Remove EMV settings
rt = IDT_Augusta.SharedController.emv_removeTerminalData();
// Remove All AID
rt = IDT_Augusta.SharedController.emv_removeAllApplicationData();
// Remove All CAPK
rt = IDT_Augusta.SharedController.emv_removeAllCAPK();
// Set Device to HID MODE
rt = IDT_Augusta.SharedController.msr_switchUSBInterfaceMode(true);
Debug.WriteLine("DeviceCfg::DisableQCEmvMode() - status={0}", rt);
//string [] message = { "Enable" };
//NotificationRaise(new DeviceNotificationEventArgs { NotificationType = NOTIFICATION_TYPE.NT_SET_EMV_MODE_BUTTON, Message = message });
// Restart device discovery
DeviceRemovedHandler();
}
catch (Exception exp)
{
Logger.error("DeviceCfg::DisableQCEmvMode(): - exception={0}", (object)exp.Message);
}
}
private void channel_open()//打开dma通道
{
DmaDesc.EnableReadyInput = 1;
DmaDesc.EnableBTERMInput = 0;
DmaDesc.EnableIopBurst = 1;
DmaDesc.EnableWriteInvalidMode = 0;
DmaDesc.EnableDmaEOTPin = 0;
DmaDesc.DmaStopTransferMode = 0;
DmaDesc.HoldIopAddrConst = 1;
DmaDesc.DemandMode = 0;
DmaDesc.EnableTransferCountClear = 0;
DmaDesc.WaitStates = 0;
DmaDesc.IopBusWidth = 2; // 32-bit
DmaDesc.DmaChannelPriority = DMA_CHANNEL_PRIORITY.Rotational;
rc = PlxDmaSglChannelOpen(hDevice, DMA_CHANNEL.PrimaryPciChannel0, ref DmaDesc);
rc = PlxIntrStatusGet(hDevice, ref PlxInterrupt);
PlxInterrupt.PciDmaChannel0 = 1;
PlxInterrupt.PciMainInt = 1;
PlxInterrupt.IopToPciInt = 1;
rc = PlxIntrAttach(hDevice, PlxInterrupt, ref hInterruptEvent);
rc = PlxIntrEnable(hDevice, ref PlxInterrupt);
ReceiveFlag = 0xf0;
PlxBusIopWrite(hDevice, IOP_SPACE.IopSpace1, 0x00001000, true, ref ReceiveFlag, 1, ACCESS_TYPE.BitSize8);
DmaData.UserVa = getaddress(buffer);
DmaData.LocalAddr = 0x00008000;
DmaData.TransferCount = 500000;
DmaData.LocalToPciDma = 1;// Local to PCI
DmaData.TerminalCountIntr = 0;
}
/********************************************************************************************************/
// DEVICE CONFIGURATION
/********************************************************************************************************/
#region -- device configuration --
public void GetTerminalInfo(ConfigSerializer serializer)
{
try
{
string response = null;
RETURN_CODE rt = IDT_Augusta.SharedController.device_getFirmwareVersion(ref response);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS && !string.IsNullOrWhiteSpace(response))
{
//serializer.terminalCfg.general_configuration.Terminal_info.firmware_ver = response;
}
response = "";
rt = IDT_Augusta.SharedController.emv_getEMVKernelVersion(ref response);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS && !string.IsNullOrWhiteSpace(response))
{
//serializer.terminalCfg.general_configuration.Terminal_info.contact_emv_kernel_ver = response;
}
response = "";
rt = IDT_Augusta.SharedController.emv_getEMVKernelCheckValue(ref response);
if (RETURN_CODE.RETURN_CODE_DO_SUCCESS == rt && !string.IsNullOrWhiteSpace(response))
{
//serializer.terminalCfg.general_configuration.Terminal_info.contact_emv_kernel_checksum = response;
}
response = "";
rt = IDT_Augusta.SharedController.emv_getEMVConfigurationCheckValue(ref response);
if (RETURN_CODE.RETURN_CODE_DO_SUCCESS == rt && !string.IsNullOrWhiteSpace(response))
{
//serializer.terminalCfg.general_configuration.Terminal_info.contact_emv_kernel_configuration_checksum = response;
}
}
catch (Exception exp)
{
Debug.WriteLine("device: GetTerminalInfo() - exception={0}", (object)exp.Message);
}
}
public override string [] GetCapKList()
{
string [] data = null;
try
{
byte [] keys = null;
RETURN_CODE rt = IDT_Augusta.SharedController.emv_retrieveCAPKList(ref keys);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
List <string> collection = new List <string>();
Debug.WriteLine("DEVICE CAPK LIST ----------------------------------------------------------------------");
List <byte[]> capkNames = new List <byte[]>();
// Convert array to array of arrays
for (int i = 0; i < keys.Length; i += 6)
{
byte[] result = new byte[6];
Array.Copy(keys, i, result, 0, 6);
capkNames.Add(result);
}
foreach (byte[] capkName in capkNames)
{
string devCapKName = BitConverter.ToString(capkName).Replace("-", string.Empty);
Debug.WriteLine("CAPK: {0} ===============================================", (object)devCapKName);
byte[] key = null;
rt = IDT_Augusta.SharedController.emv_retrieveCAPK(capkName, ref key);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Capk capk = new Capk(key);
string RID = devCapKName.Substring(0, 10);
string Idx = devCapKName.Substring(10, 2);
string payload = string.Format("{0}:{1} ", "RID", RID).ToUpper();
payload += string.Format("{0}:{1} ", "INDEX", Idx).ToUpper();
payload += string.Format("{0}:{1} ", "MODULUS", capk.GetModulus()).ToUpper();
collection.Add(string.Format("{0}#{1}", (RID + "-" + Idx), payload).ToUpper());
Debug.WriteLine("MODULUS: {0}", (object)capk.GetModulus().ToUpper());
}
}
data = collection.ToArray();
}
else
{
Debug.WriteLine("device: emv_retrieveCAPKList() - ERROR={0}", rt);
}
}
catch (Exception exp)
{
Debug.WriteLine("device: GetTerminalData() - exception={0}", (object)exp.Message);
}
return(data);
}
public override string [] GetAidList()
{
string [] data = null;
try
{
byte [][] keys = null;
RETURN_CODE rt = IDT_Augusta.SharedController.emv_retrieveAIDList(ref keys);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
List <string> collection = new List <string>();
Debug.WriteLine("DEVICE AID LIST ----------------------------------------------------------------------");
foreach (byte[] aidName in keys)
{
byte[] value = null;
rt = IDT_Augusta.SharedController.emv_retrieveApplicationData(aidName, ref value);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
string devAidName = BitConverter.ToString(aidName).Replace("-", string.Empty).ToUpper();
Debug.WriteLine("AID: {0} ===============================================", (object)devAidName);
Dictionary <string, Dictionary <string, string> > dict = Common.processTLV(value);
List <string> valCollection = new List <string>();
// Compare values and replace if not the same
foreach (Dictionary <string, string> devCollection in dict.Where(x => x.Key.Equals("unencrypted")).Select(x => x.Value))
{
foreach (var devTag in devCollection)
{
valCollection.Add(string.Format("{0}:{1}", devTag.Key, devTag.Value).ToUpper());
}
}
collection.Add(string.Format("{0}#{1}", devAidName, String.Join(" ", valCollection.ToArray())));
}
}
data = collection.ToArray();
}
else
{
Debug.WriteLine("TERMINAL DATA: emv_retrieveAIDList() - ERROR={0}", rt);
}
}
catch (Exception exp)
{
Debug.WriteLine("device: GetTerminalData() - exception={0}", (object)exp.Message);
}
return(data);
}
/// <summary>
/// Executes a given command.
/// And returns a response.
/// </summary>
/// <returns>Response from server.</returns>
private APIResponse Execute(string cmd)
{
#if !DEBUG
string e_cmd = cmd;
string e_response = String.Empty;
if (isLoggedIn)
{
e_cmd += (e_cmd.Contains("=") ? "&" : " ") + "s=" + sessionKey;
}
data = Encoding.UTF8.GetBytes(e_cmd);
conn.Send(data, data.Length);
data = conn.Receive(ref apiserver);
m_lastCommand = DateTime.Now;
queryLog.Add(m_lastCommand);
e_response = Encoding.UTF8.GetString(data, 0, data.Length);
RETURN_CODE e_code = (RETURN_CODE)int.Parse(e_response.Substring(0, 3));
switch (e_code)
{
case RETURN_CODE.LOGIN_FIRST:
case RETURN_CODE.ACCESS_DENIED:
case RETURN_CODE.INVALID_SESSION:
isLoggedIn = false;
if (Login(user, pass))
{
return(Execute(cmd));
}
else
{
var login = new LoginWindow();
login.Show();
mainWindow.Close();
return(new APIResponse());
}
default:
return(new APIResponse {
Message = e_response, Code = e_code
});
}
#else
return(new APIResponse {
Message = "\n411|7562|7488|1928235|0|0|0|0|0|0|3|6|54|4117|0|0|94407", Code = (RETURN_CODE)200
});
#endif
}
private void pci_open()
{
byte a = 0, b = 0, c = 0;
device_location.SerialNumber = new byte[12];
device_location.BusNumber = 0xff;
device_location.SlotNumber = 0xff;
device_location.VendorId = 0xffff;
device_location.DeviceId = 0xffff;
rc = PlxSdkVersion(ref a, ref b, ref c);
rc = PlxPciDeviceOpen(ref device_location, ref hDevice);
}
public override string GetFirmwareVersion()
{
string firmwareVersion = "";
RETURN_CODE rt = IDT_Augusta.SharedController.device_getFirmwareVersion(ref firmwareVersion);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
deviceInfo.FirmwareVersion = ParseFirmwareVersion(firmwareVersion);
firmwareVersion = deviceInfo.FirmwareVersion;
Debug.WriteLine("device INFO[Firmware Version] : {0}", (object)deviceInfo.FirmwareVersion);
}
else
{
Debug.WriteLine("device: GetDeviceFirmwareVersion() - failed to get Firmware version reason={0}", rt);
}
return(firmwareVersion);
}
public override string GetSerialNumber()
{
string serialNumber = "";
RETURN_CODE rt = IDT_Augusta.SharedController.config_getSerialNumber(ref serialNumber);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
deviceInfo.SerialNumber = serialNumber;
Debug.WriteLine("device::GetSerialNumber(): {0}", (object)deviceInfo.SerialNumber);
}
else
{
Debug.WriteLine("device::GetSerialNumber(): failed to get serialNumber e={0}", rt);
}
return(serialNumber);
}
public override int SetTerminalConfiguration(int majorcfg)
{
RETURN_CODE rt = RETURN_CODE.RETURN_CODE_DO_SUCCESS;
//20190508-NOTE: emv_setTerminalMajorConfiguration() not suppported
/*try
* {
* rt = IDT_VP3300.SharedController.emv_setTerminalMajorConfiguration(majorcfg);
* if(rt != RETURN_CODE.RETURN_CODE_DO_SUCCESS)
* {
* Logger.error("DeviceCfg::SetTerminalMajorConfiguration(): failed Error Code=0x{0:X}", (ushort)rt);
* }
* }
* catch(Exception ex)
* {
* Debug.WriteLine("device: SetTerminalConfiguration() - exception={0}", (object)ex.Message);
* }*/
return((int)rt);
}
public string DeviceCommand(string command, bool notify)
{
string [] message = { "" };
if (useUniversalSDK)
{
byte[] response = null;
RETURN_CODE rt = IDT_Augusta.SharedController.device_sendDataCommand(command, true, ref response);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
message[0] = BitConverter.ToString(response).Replace("-", string.Empty);
}
else
{
if (response != null)
{
message[0] = "COMMAND EXECUTE FAILED - CODE=" + BitConverter.ToString(response).Replace("-", string.Empty);
}
else
{
message[0] = "COMMAND EXECUTE FAILED - CODE=0x" + string.Format("{0:X}", rt);
}
}
if (notify)
{
NotificationRaise(new DeviceNotificationEventArgs {
NotificationType = NOTIFICATION_TYPE.NT_SET_EXECUTE_RESULT, Message = message
});
}
}
else
{
//TODO:
}
return(message[0]);
}
public override string [] GetTerminalData()
{
string [] data = null;
try
{
byte [] tlv = null;
RETURN_CODE rt = IDT_Augusta.SharedController.emv_retrieveTerminalData(ref tlv);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
List <string> collection = new List <string>();
Debug.WriteLine("DEVICE TERMINAL DATA ----------------------------------------------------------------------");
Dictionary <string, Dictionary <string, string> > dict = Common.processTLV(tlv);
foreach (Dictionary <string, string> devCollection in dict.Where(x => x.Key.Equals("unencrypted")).Select(x => x.Value))
{
foreach (var devTag in devCollection)
{
collection.Add(string.Format("{0}:{1}", devTag.Key, devTag.Value).ToUpper());
}
}
data = collection.ToArray();
}
else
{
Debug.WriteLine("TERMINAL DATA: emv_retrieveTerminalData() - ERROR={0}", rt);
}
}
catch (Exception exp)
{
Debug.WriteLine("device: GetTerminalData() - exception={0}", (object)exp.Message);
}
return(data);
}
public override void FactoryReset()
{
try
{
// TERMINAL DATA
TerminalDataFactory tf = new TerminalDataFactory();
byte[] term = tf.GetFactoryTerminalData5C();
RETURN_CODE rt = IDT_Augusta.SharedController.emv_setTerminalData(term);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("TERMINAL DATA [DEFAULT] ----------------------------------------------------------------------");
}
else
{
Debug.WriteLine("TERMINAL DATA [DEFAULT] failed with error code: 0x{0:X}", (ushort)rt);
}
// AID
AidFactory factoryAids = new AidFactory();
Dictionary <byte [], byte []> aid = factoryAids.GetFactoryAids();
Debug.WriteLine("AID LIST [DEFAULT] ----------------------------------------------------------------------");
foreach (var item in aid)
{
byte [] name = item.Key;
byte [] value = item.Value;
rt = IDT_Augusta.SharedController.emv_setApplicationData(name, value);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("AID: {0}", (object)BitConverter.ToString(name).Replace("-", string.Empty));
}
else
{
Debug.WriteLine("CAPK: {0} failed Error Code: 0x{1:X}", (ushort)rt);
}
}
// CAPK
CapKFactory factoryCapk = new CapKFactory();
Dictionary <byte [], byte []> capk = factoryCapk.GetFactoryCapK();
Debug.WriteLine("CAPK LIST [DEFAULT] ----------------------------------------------------------------------");
foreach (var item in capk)
{
byte [] name = item.Key;
byte [] value = item.Value;
rt = IDT_Augusta.SharedController.emv_setCAPK(value);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("CAPK: {0}", (object)BitConverter.ToString(name).Replace("-", string.Empty).ToUpper());
}
else
{
Debug.WriteLine("CAPK: {0} failed Error Code: 0x{1:X}", (ushort)rt);
}
}
}
catch (Exception exp)
{
Debug.WriteLine("device: FactoryReset() - exception={0}", (object)exp.Message);
}
}
private void MessageCallBackIP(IDTechSDK.IDT_DEVICE_Types type, DeviceState state, byte[] data, IDTTransactionData cardData, EMV_Callback emvCallback, RETURN_CODE transactionResultCode, string IP2)
{
MessageCallBack(type, state, data, cardData, emvCallback, transactionResultCode);
}
public void SetDeviceMode(string mode)
{
try
{
Debug.WriteLine("device: SET MODE={0} ++++++++++++++++++++++++++++++++++++++++", (object)mode);
if (mode.Equals(USK_DEVICE_MODE.USB_HID))
{
if (DeviceInformation.deviceMode == IDTECH_DEVICE_PID.AUGUSTA_KYB ||
DeviceInformation.deviceMode == IDTECH_DEVICE_PID.AUGUSTAS_KYB)
{
// Set Device to HID MODE
if (!Device.SetUSBHIDMode())
{
DeviceRemovedHandler();
}
//if(status == EntryModeStatus.Success)
//{
//status = DeviceSoftReset();
//Debug.WriteLine("DeviceCfg::SetDeviceMode(): - RESET status={0}", status);
//}
}
else if (DeviceInformation.deviceMode == IDTECH_DEVICE_PID.VP3000_KYB)
{
Device.SetVP3000DeviceHidMode();
}
}
else if (mode.Equals(USK_DEVICE_MODE.USB_KYB))
{
if (DeviceInformation.deviceMode == IDTECH_DEVICE_PID.AUGUSTA_HID ||
DeviceInformation.deviceMode == IDTECH_DEVICE_PID.AUGUSTAS_HID)
{
// TURN ON QUICK CHIP MODE
string command = USDK_CONFIGURATION_COMMANDS.ENABLE_QUICK_CHIP_MODE;
DeviceCommand(command, true);
// Set Device to HID MODE
RETURN_CODE rt = IDT_Augusta.SharedController.msr_switchUSBInterfaceMode(true);
Debug.WriteLine("DeviceCfg::SetDeviceMode(): - status={0}", rt);
// Restart device discovery
DeviceRemovedHandler();
}
else if (DeviceInformation.deviceMode == IDTECH_DEVICE_PID.VP3000_HID)
{
RETURN_CODE rt = IDT_VP3300.SharedController.device_setPollMode(3);
if (rt != RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("DeviceCfg::SetDeviceMode(): VP3000 - error={0}", rt);
}
}
else if (DeviceInformation.deviceMode == IDTECH_DEVICE_PID.VP5300_HID)
{
RETURN_CODE rt = IDT_NEO2.SharedController.device_setPollMode(3);
if (rt != RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("DeviceCfg::SetDeviceMode(): VP5300 - error={0}", rt);
}
}
}
}
catch (Exception exp)
{
Logger.error("DeviceCfg::SetDeviceMode(): - exception={0}", (object)exp.Message);
}
}
public void FirmwareUpdate(string fullPathfilename, byte[] bytes)
{
try
{
if (bytes.Length > 0)
{
/*TODO: GUI UNIT TEST
* new Thread(() =>
* {
* Thread.CurrentThread.IsBackground = false;
*
* for(int i = 1; i <= bytes.Length / 1024; i++)
* {
* Debug.WriteLine("device: sent block {0} of {1}", i.ToString(), (bytes.Length / 1024).ToString());
* string [] message = { i.ToString() };
* NotificationRaise(new DeviceNotificationEventArgs { NotificationType = NOTIFICATION_TYPE.NT_FIRMWARE_UPDATE_STEP, Message = message });
* Thread.Sleep(10);
* }
* Thread.Sleep(1000);
* SetDeviceFirmwareVersion();
* }).Start();
*
* return;*/
// Validate FW Signature
byte[] FirmwareSignature = new byte[64];
Array.Copy(bytes, 64, FirmwareSignature, 0, 32);
DeviceFirmwareSignature Signature = new DeviceFirmwareSignature();
Dictionary <string, string> Values = Common.processTLVUnencrypted(FirmwareSignature);
foreach (var Item in Values)
{
switch (Int32.Parse(Item.Key))
{
case (int)DeviceFirmwareSignature.SignatureIndex.SIG_VERSION:
{
Signature.Version = Common.hexStringToString(Item.Value);
break;
}
case (int)DeviceFirmwareSignature.SignatureIndex.SIG_MODELNAME:
{
Signature.ModelName = Common.hexStringToString(Item.Value);
break;
}
case (int)DeviceFirmwareSignature.SignatureIndex.SIG_TYPE:
{
Signature.Type = Item.Value;
break;
}
}
}
foreach (var ModelName in Signature.Devices.Where(x => x.Key.Equals(DeviceInformation.ModelName, StringComparison.CurrentCultureIgnoreCase)).Select(y => y.Value))
{
if (ModelName.Equals(Signature.ModelName, StringComparison.CurrentCultureIgnoreCase))
{
RETURN_CODE rt = IDT_Device.SharedController.device_updateDeviceFirmware(bytes);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
string filename = System.IO.Path.GetFileName(fullPathfilename);
Logger.debug("device: firmware update started for: {0}", filename);
firmwareUpdate = true;
}
else
{
Logger.error("device: firmware Update Failed Error Code: 0x{0:X}", (ushort)rt);
}
}
else
{
string [] message = { string.Format("UPDATE FAILED: [{0}] FIRMWARE DOESN'T MATCH DEVICE MODEL {1}", Signature.ModelName, DeviceInformation.ModelName) };
Logger.error("device: {0}", message[0]);
NotificationRaise(new DeviceNotificationEventArgs {
NotificationType = NOTIFICATION_TYPE.NT_FIRMWARE_UPDATE_FAILED, Message = message
});
break;
}
}
}
}
catch (Exception exp)
{
Logger.error("device: FirmwareUpdate() - exception={0}", (object)exp.Message);
}
}
private void MessageCallBack(IDTechSDK.IDT_DEVICE_Types type, DeviceState state, byte[] data, IDTTransactionData cardData, EMV_Callback emvCallback, RETURN_CODE transactionResultCode)
{
// Setup Connection
IDTechComm comm = Profile.getComm(type, DEVICE_INTERFACE_Types.DEVICE_INTERFACE_USB);
if (comm == null)
{
comm = Profile.getComm(type, DEVICE_INTERFACE_Types.DEVICE_INTERFACE_SERIAL);
}
if (comm == null)
{
comm = Profile.getComm(type, DEVICE_INTERFACE_Types.DEVICE_INTERFACE_BT);
}
if (comm == null)
{
comm = Profile.getComm(type, DEVICE_INTERFACE_Types.DEVICE_INTERFACE_AUDIO_JACK);
}
deviceConnect = DEVICE_INTERFACE_Types.DEVICE_INTERFACE_UNKNOWN;
deviceProtocol = DEVICE_PROTOCOL_Types.DEVICE_PROTOCOL_UNKNOWN;
if (comm != null)
{
deviceConnect = comm.getDeviceConnection();
deviceProtocol = comm.getDeviceProtocol();
}
//Debug.WriteLine("DeviceCfg::MessageCallBack: device discovery: state={0}", state);
switch (state)
{
case DeviceState.ToConnect:
{
deviceType = type;
Debug.WriteLine("device connecting: {0}", (object)deviceType.ToString());
break;
}
case DeviceState.Connected:
{
deviceType = type;
Debug.WriteLine("device connected: {0}", (object)IDTechSDK.Profile.IDT_DEVICE_String(type, deviceConnect));
// Populate Device Configuration
if (!connected && !firmwareUpdate)
{
new Thread(() =>
{
Thread.CurrentThread.IsBackground = false;
connected = true;
// Get Device Configuration
SetDeviceConfig();
Thread.Sleep(100);
// Get Device Information
GetDeviceInformation();
}).Start();
}
break;
}
case DeviceState.Disconnected:
{
if (!firmwareUpdate)
{
connected = false;
DeviceRemovedHandler();
}
break;
}
case DeviceState.DefaultDeviceTypeChange:
{
break;
}
case DeviceState.Notification:
{
if (cardData.Notification == EVENT_NOTIFICATION_Types.EVENT_NOTIFICATION_Card_Not_Seated)
{
Debug.WriteLine("Notification: ICC Card not Seated\n");
}
if (cardData.Notification == EVENT_NOTIFICATION_Types.EVENT_NOTIFICATION_Card_Seated)
{
Debug.WriteLine("Notification: ICC Card Seated\n");
}
if (cardData.Notification == EVENT_NOTIFICATION_Types.EVENT_NOTIFICATION_Swipe_Card)
{
Debug.WriteLine("Notification: MSR Swipe Card\n");
}
break;
}
case DeviceState.TransactionData:
{
if (cardData == null)
{
break;
}
//lastCardData = cardData;
if (type == IDT_DEVICE_Types.IDT_DEVICE_AUGUSTA && deviceProtocol == DEVICE_PROTOCOL_Types.DEVICE_PROTOCOL_KB)
{
if (cardData.msr_rawData != null)
{
if (cardData.msr_rawData.Length == 1 && cardData.msr_rawData[0] == 0x18)
{
Debug.WriteLine("Get MSR Complete! \n");
Debug.WriteLine("Get MSR Complete! \n");
}
}
//clearCallbackData(ref data, ref cardData);
return;
}
if (cardData.Event != EVENT_TRANSACTION_DATA_Types.EVENT_TRANSACTION_PIN_DATA &&
cardData.Event != EVENT_TRANSACTION_DATA_Types.EVENT_TRANSACTION_DATA_CARD_DATA &&
cardData.Event != EVENT_TRANSACTION_DATA_Types.EVENT_TRANSACTION_DATA_EMV_DATA)
{
//SoftwareController.MSR_LED_RED_SOLID();
Debug.WriteLine("MSR Error " + cardData.msr_errorCode.ToString() + "\n");
Debug.WriteLine("MSR Error " + cardData.msr_errorCode.ToString());
}
else
{
if (cardData.Event != EVENT_TRANSACTION_DATA_Types.EVENT_TRANSACTION_DATA_EMV_DATA)
{
//SoftwareController.MSR_LED_GREEN_SOLID();
}
//output parsed card data
Debug.WriteLine("Return Code: " + transactionResultCode.ToString() + "\r\n");
// Data Received Processing
///ProcessCardData(cardData);
}
break;
}
case DeviceState.DataReceived:
{
//SetOutputTextLog(GetTimestamp() + " IN: " + Common.getHexStringFromBytes(data));
break;
}
case DeviceState.DataSent:
{
//SetOutputTextLog(GetTimestamp() + " OUT: " + Common.getHexStringFromBytes(data));
break;
}
case DeviceState.CommandTimeout:
{
Debug.WriteLine("Command Timeout\n");
break;
}
case DeviceState.CardAction:
{
if (data != null & data.Length > 0)
{
CARD_ACTION action = (CARD_ACTION)data[0];
StringBuilder sb = new StringBuilder("Card Action Request: ");
if ((action & CARD_ACTION.CARD_ACTION_INSERT) == CARD_ACTION.CARD_ACTION_INSERT)
{
sb.Append("INSERT ");
}
if ((action & CARD_ACTION.CARD_ACTION_REINSERT) == CARD_ACTION.CARD_ACTION_REINSERT)
{
sb.Append("REINSERT ");
}
if ((action & CARD_ACTION.CARD_ACTION_REMOVE) == CARD_ACTION.CARD_ACTION_REMOVE)
{
sb.Append("REMOVE ");
}
if ((action & CARD_ACTION.CARD_ACTION_SWIPE) == CARD_ACTION.CARD_ACTION_SWIPE)
{
sb.Append("SWIPE ");
}
if ((action & CARD_ACTION.CARD_ACTION_SWIPE_AGAIN) == CARD_ACTION.CARD_ACTION_SWIPE_AGAIN)
{
sb.Append("SWIPE_AGAIN ");
}
if ((action & CARD_ACTION.CARD_ACTION_TAP) == CARD_ACTION.CARD_ACTION_TAP)
{
sb.Append("TAP ");
}
if ((action & CARD_ACTION.CARD_ACTION_TAP_AGAIN) == CARD_ACTION.CARD_ACTION_TAP_AGAIN)
{
sb.Append("TAP_AGAIN ");
}
Debug.WriteLine(sb.ToString() + "\n");
}
break;
}
case DeviceState.MSRDecodeError:
{
//SoftwareController.MSR_LED_RED_SOLID();
Debug.WriteLine("MSR Decode Error\n");
break;
}
case DeviceState.SwipeTimeout:
{
Debug.WriteLine("Swipe Timeout\n");
break;
}
case DeviceState.TransactionCancelled:
{
Debug.WriteLine("TransactionCancelled.");
//Debug.WriteLine("");
//Debug.WriteLine(DeviceTerminalInfo.getDisplayMessage(DeviceTerminalInfo.MSC_ID_WELCOME));
break;
}
case DeviceState.DeviceTimeout:
{
Debug.WriteLine("Device Timeout\n");
break;
}
case DeviceState.TransactionFailed:
{
if ((int)transactionResultCode == 0x8300)
{
//SoftwareController.MSR_LED_RED_SOLID();
}
string text = IDTechSDK.errorCode.getErrorString(transactionResultCode);
Debug.WriteLine("Transaction Failed: {0}\r\n", (object)text);
// Allow for GUI Recovery
string [] message = { "" };
message[0] = "***** TRANSACTION FAILED: " + text + " *****";
NotificationRaise(new DeviceNotificationEventArgs {
NotificationType = NOTIFICATION_TYPE.NT_PROCESS_CARDDATA_ERROR, Message = message
});
break;
}
case DeviceState.FirmwareUpdate:
{
switch (transactionResultCode)
{
case RETURN_CODE.RETURN_CODE_FW_STARTING_UPDATE:
{
string [] message = { "STARTING FIRMWARE UPDATE...." };
Logger.debug("device: {0}", (object)message[0]);
NotificationRaise(new DeviceNotificationEventArgs {
NotificationType = NOTIFICATION_TYPE.NT_FIRMWARE_UPDATE_STATUS, Message = message
});
break;
}
case RETURN_CODE.RETURN_CODE_DO_SUCCESS:
{
string [] message = { "FIRMWARE UPDATE SUCCESSFUL" };
Logger.debug("device: {0}", (object)message[0]);
NotificationRaise(new DeviceNotificationEventArgs {
NotificationType = NOTIFICATION_TYPE.NT_FIRMWARE_UPDATE_STATUS, Message = message
});
new Thread(() =>
{
Thread.CurrentThread.IsBackground = false;
firmwareUpdate = false;
// Get Device Configuration
SetDeviceFirmwareVersion();
}).Start();
break;
}
case RETURN_CODE.RETURN_CODE_APPLYING_FIRMWARE_UPDATE:
{
string [] message = { "APPLYING FIRMWARE UPDATE...." };
Logger.debug("device: {0}", (object)message[0]);
NotificationRaise(new DeviceNotificationEventArgs {
NotificationType = NOTIFICATION_TYPE.NT_FIRMWARE_UPDATE_STATUS, Message = message
});
break;
}
case RETURN_CODE.RETURN_CODE_ENTERING_BOOTLOADER_MODE:
{
Logger.debug("device: entering Bootloader Mode....");
break;
}
case RETURN_CODE.RETURN_CODE_BLOCK_TRANSFER_SUCCESS:
{
int start = data[0];
int end = data[1];
if (data.Length == 4)
{
start = data[0] * 0x100 + data[1];
end = data[2] * 0x100 + data[3];
}
Logger.debug("device: sent block {0} of {1}", start.ToString(), end.ToString());
string [] message = { start.ToString() };
NotificationRaise(new DeviceNotificationEventArgs {
NotificationType = NOTIFICATION_TYPE.NT_FIRMWARE_UPDATE_STEP, Message = message
});
break;
}
default:
{
Logger.debug("device: firmware Update Error Code: 0x{0:X} : {1}", (ushort)transactionResultCode, IDTechSDK.errorCode.getErrorString(transactionResultCode));
break;
}
}
break;
}
}
}
public override void ValidateAidList(ConfigSerializer serializer)
{
try
{
if (serializer != null)
{
byte [][] keys = null;
RETURN_CODE rt = IDT_Augusta.SharedController.emv_retrieveAIDList(ref keys);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("VALIDATE AID LIST ----------------------------------------------------------------------");
// Get Configuration File AID List
AIDList aid = serializer.GetAIDList();
List <Aid> AidList = new List <Aid>();
foreach (byte[] aidName in keys)
{
bool delete = true;
bool found = false;
bool update = false;
KeyValuePair <string, Dictionary <string, string> > cfgCurrentItem = new KeyValuePair <string, Dictionary <string, string> >();
string devAidName = BitConverter.ToString(aidName).Replace("-", string.Empty);
Debug.WriteLine("AID: {0} ===============================================", (object)devAidName);
// Is this item in the approved list?
foreach (var cfgItem in aid.Aid)
{
cfgCurrentItem = cfgItem;
if (cfgItem.Key.Equals(devAidName, StringComparison.CurrentCultureIgnoreCase))
{
found = true;
byte[] value = null;
rt = IDT_Augusta.SharedController.emv_retrieveApplicationData(aidName, ref value);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Dictionary <string, Dictionary <string, string> > dict = Common.processTLV(value);
// Compare values and replace if not the same
foreach (Dictionary <string, string> devCollection in dict.Where(x => x.Key.Equals("unencrypted")).Select(x => x.Value))
{
foreach (var cfgTag in cfgItem.Value)
{
bool tagfound = false;
string cfgTagName = cfgTag.Key;
string cfgTagValue = cfgTag.Value;
foreach (var devTag in devCollection)
{
// Matching TAGNAME: compare keys
if (devTag.Key.Equals(cfgTag.Key, StringComparison.CurrentCultureIgnoreCase))
{
tagfound = true;
//Debug.Write("key: " + devTag.Key);
update = !cfgTag.Value.Equals(devTag.Value, StringComparison.CurrentCultureIgnoreCase);
// Compare value and fix it if mismatched
if (cfgTag.Value.Equals(devTag.Value, StringComparison.CurrentCultureIgnoreCase))
{
//Debug.WriteLine("TAG: {0} FOUND AND IT MATCHES", (object) cfgTagName.PadRight(6,' '));
//Debug.WriteLine(" matches value: {0}", (object) devTag.Value);
}
else
{
Debug.WriteLine("TAG: {0} FOUND AND IT DOES NOT match value: {1}!={2}", cfgTagName.PadRight(6, ' '), cfgTag.Value, devTag.Value);
}
break;
}
}
// No need to continue validating the remaing tags
if (!tagfound || update)
{
break;
}
}
}
}
delete = false;
if (update)
{
byte[] tagCfgName = Device_IDTech.HexStringToByteArray(cfgCurrentItem.Key);
List <byte[]> collection = new List <byte[]>();
foreach (var item in cfgCurrentItem.Value)
{
string payload = string.Format("{0}{1:X2}{2}", item.Key, item.Value.Length / 2, item.Value).ToUpper();
byte [] bytes = Device_IDTech.HexStringToByteArray(payload);
collection.Add(bytes);
}
var flattenedList = collection.SelectMany(bytes => bytes);
byte [] tagCfgValue = flattenedList.ToArray();
Aid cfgAid = new Aid(tagCfgName, tagCfgValue);
AidList.Add(cfgAid);
}
}
}
// DELETE THIS AID
if (delete)
{
Debug.WriteLine("AID: {0} - DELETE (NOT FOUND)", (object)devAidName.PadRight(14, ' '));
byte[] tagName = Device_IDTech.HexStringToByteArray(devAidName);
rt = IDT_Augusta.SharedController.emv_removeApplicationData(tagName);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("AID: {0} DELETED", (object)devAidName.PadRight(6, ' '));
}
}
else if (!found)
{
byte[] tagCfgName = Device_IDTech.HexStringToByteArray(cfgCurrentItem.Key);
List <byte[]> collection = new List <byte[]>();
foreach (var item in cfgCurrentItem.Value)
{
string payload = string.Format("{0}{1:X2}{2}", item.Key, item.Value.Length / 2, item.Value).ToUpper();
byte [] bytes = Device_IDTech.HexStringToByteArray(payload);
collection.Add(bytes);
}
var flattenedList = collection.SelectMany(bytes => bytes);
byte [] tagCfgValue = flattenedList.ToArray();
Aid cfgAid = new Aid(tagCfgName, tagCfgValue);
AidList.Add(cfgAid);
}
}
// Add missing AID(s)
foreach (var aidElement in AidList)
{
byte [] aidName = aidElement.GetAidName();
byte [] aidValue = aidElement.GetAidValue();
rt = IDT_Augusta.SharedController.emv_setApplicationData(aidName, aidValue);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
string cfgTagName = BitConverter.ToString(aidName).Replace("-", string.Empty);
string cfgTagValue = BitConverter.ToString(aidValue).Replace("-", string.Empty);
Debug.WriteLine("AID: {0} UPDATED WITH VALUE: {1}", cfgTagName.PadRight(6, ' '), cfgTagValue);
}
}
}
else
{
Debug.WriteLine("TERMINAL DATA: emv_retrieveAIDList() - ERROR={0}", rt);
}
}
}
catch (Exception exp)
{
Debug.WriteLine("device: ValidateAidList() - exception={0}", (object)exp.Message);
}
}
public override void ValidateTerminalData(ConfigSerializer serializer)
{
try
{
if (serializer != null)
{
byte [] tlv = null;
RETURN_CODE rt = IDT_Augusta.SharedController.emv_retrieveTerminalData(ref tlv);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("VALIDATE TERMINAL DATA ----------------------------------------------------------------------");
// Get Configuration File AID List
SortedDictionary <string, string> cfgTerminalData = serializer.GetTerminalData(serialNumber, EMVKernelVer);
Dictionary <string, Dictionary <string, string> > dict = Common.processTLV(tlv);
bool update = false;
// TAGS from device
foreach (Dictionary <string, string> devCollection in dict.Where(x => x.Key.Equals("unencrypted")).Select(x => x.Value))
{
foreach (var devTag in devCollection)
{
string devTagName = devTag.Key;
string cfgTagValue = "";
bool tagfound = false;
bool tagmatch = false;
foreach (var cfgTag in cfgTerminalData)
{
// Matching TAGNAME: compare keys
if (devTag.Key.Equals(cfgTag.Key, StringComparison.CurrentCultureIgnoreCase))
{
tagfound = true;
//Debug.Write("key: " + devTag.Key);
// Compare value
if (cfgTag.Value.Equals(devTag.Value, StringComparison.CurrentCultureIgnoreCase))
{
tagmatch = true;
//Debug.WriteLine(" matches value: {0}", (object) devTag.Value);
}
else
{
//Debug.WriteLine(" DOES NOT match value: {0}!={1}", devTag.Value, cfgTag.Value);
cfgTagValue = cfgTag.Value;
update = true;
}
break;
}
if (tagfound)
{
break;
}
}
if (tagfound)
{
Debug.WriteLine("TAG: {0} FOUND AND IT {1}", devTagName.PadRight(6, ' '), (tagmatch ? "MATCHES" : "DOES NOT MATCH"));
if (!tagmatch)
{
Debug.WriteLine("{0}!={1}", devTag.Value, cfgTagValue);
}
}
else
{
Debug.WriteLine("TAG: {0} NOT FOUND", (object)devTagName.PadRight(6, ' '));
update = true;
}
}
}
// Update Terminal Data
if (update)
{
TerminalSettings termsettings = serializer.GetTerminalSettings();
string workerstr = termsettings.MajorConfiguration;
string majorcfgstr = Regex.Replace(workerstr, "[^0-9.]", string.Empty);
int majorcfgint = 5;
if (Int32.TryParse(majorcfgstr, out majorcfgint))
{
rt = IDT_Augusta.SharedController.emv_setTerminalMajorConfiguration(majorcfgint);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
try
{
List <byte[]> collection = new List <byte[]>();
foreach (var item in cfgTerminalData)
{
byte [] bytes = null;
string payload = string.Format("{0}{1:X2}{2}", item.Key, item.Value.Length / 2, item.Value).ToUpper();
if (System.Text.RegularExpressions.Regex.IsMatch(item.Value, @"[g-zG-Z\x20\x2E]+"))
{
List <byte> byteArray = new List <byte>();
byteArray.AddRange(Device_IDTech.HexStringToByteArray(item.Key));
byte [] item1 = Encoding.ASCII.GetBytes(item.Value);
byte itemLen = Convert.ToByte(item1.Length);
byte [] item2 = new byte[] { itemLen };
byteArray.AddRange(item2);
byteArray.AddRange(item1);
bytes = new byte[byteArray.Count];
byteArray.CopyTo(bytes);
//Logger.debug( "device: ValidateTerminalData() DATA={0}", BitConverter.ToString(bytes).Replace("-", string.Empty));
}
else
{
bytes = Device_IDTech.HexStringToByteArray(payload);
}
collection.Add(bytes);
}
var flattenedList = collection.SelectMany(bytes => bytes);
byte [] terminalData = flattenedList.ToArray();
rt = IDT_Augusta.SharedController.emv_setTerminalData(terminalData);
if (rt != RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("emv_setTerminalData() error: {0}", rt);
Logger.error("device: ValidateTerminalData() error={0} DATA={1}", rt, BitConverter.ToString(terminalData).Replace("-", string.Empty));
}
}
catch (Exception exp)
{
Debug.WriteLine("device: ValidateTerminalData() - exception={0}", (object)exp.Message);
}
}
}
}
}
else
{
Debug.WriteLine("TERMINAL DATA: emv_retrieveTerminalData() - ERROR={0}", rt);
}
}
}
catch (Exception exp)
{
Debug.WriteLine("device: ValidateTerminalData() - exception={0}", (object)exp.Message);
}
}
void draw()
{
Graphics g = pictureBox1.CreateGraphics();
Pen pn1 = new Pen(Color.White);
Pen pn2 = new Pen(Color.RoyalBlue);
List <Point> points1a = new List <Point>(); //存直线连接的点
List <Point> points1b = new List <Point>(); //存直线连接的点
points1a.Add(new Point(1, 1)); points1a.Add(new Point(1, 1)); //初始化存直线连接的点
points1b.Add(new Point(1, 1)); points1b.Add(new Point(1, 1)); //初始化存直线连接的点
int x = 0;
int i = 0;
while (true)
{
int startTime = System.Environment.TickCount;
int temp = 0;
int data_count = 0;
for (count = 0; count <= 100; count++)
{
DmaData.UserVa = getaddress(buffer);
rc = PlxIntrWait(hDevice, hInterruptEvent, 1000);
if (rc == RETURN_CODE.ApiSuccess)
{
rc = PlxDmaSglTransfer(hDevice, DMA_CHANNEL.PrimaryPciChannel0, ref DmaData, false);
}
i = 0;
temp = 0;
foreach (byte y in buffer)
{
if (i < 3)//前三字节 表示数据
{
temp |= (y << (8 * i));
}
else if (i == 3)
{
if ((temp & 0x00800000) != 0)
{
temp = ~temp;
temp = temp + 1;
temp = temp & 0x00ffffff;//取绝对值
temp = temp >> 8;
temp = temp & 0x0000ffff;
temp = temp / 2;
temp = 150 - temp;
}
else
{
temp = temp >> 8;
temp = temp & 0x0000ffff;
temp = temp / 2;
temp = 150 + temp;
}
if (y == channel)//第四字节 表示通道号
{
data_count++;
skip++;
if (skip == div)//隔div个点取一次数据
{
skip = 0;
x++;
if (x < 800)
{
points1a.Add(new Point(x, temp));
}
else if (x == 800)
{
g.DrawLines(pn1, points1b.ToArray()); //points1b填白清空
points1b.Clear();
g.DrawLines(pn2, points1a.ToArray()); //points1a画黑线
}
else if (x < 1600)
{
points1b.Add(new Point(x - 800, temp));
}
if (x == 1600)
{
g.DrawLines(pn1, points1a.ToArray()); //points1a填白清空
points1a.Clear();
g.DrawLines(pn2, points1b.ToArray()); //points1b画黑线
x = 0;
}
}
}
}
i++;
if (i == 4)
{
i = 0;
temp = 0;
}
}
}
int endTime = System.Environment.TickCount;
int runTime = endTime - startTime;
datarate = 500 * 100 / (float)runTime;
samplerate = data_count / (float)runTime;
data_count = 0;
}
}
private bool PopulateDeviceInfo()
{
serialNumber = "";
RETURN_CODE rt = IDT_Augusta.SharedController.config_getSerialNumber(ref serialNumber);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
deviceInfo.SerialNumber = serialNumber;
Debug.WriteLine("device INFO[Serial Number] : {0}", (object)deviceInfo.SerialNumber);
}
else
{
Debug.WriteLine("device: PopulateDeviceInfo() - failed to get serialNumber reason={0}", rt);
}
string firmwareVersion = "";
rt = IDT_Augusta.SharedController.device_getFirmwareVersion(ref firmwareVersion);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
if (deviceMode == IDTECH_DEVICE_PID.AUGUSTA_KYB || deviceMode == IDTECH_DEVICE_PID.AUGUSTAS_KYB)
{
var result = Regex.Match(firmwareVersion, @"^N\v\n");
if (result.Success)
{
deviceInfo.FirmwareVersion = firmwareVersion.Substring(result.Index + result.Length);
}
else
{
deviceInfo.FirmwareVersion = firmwareVersion.Trim();
}
deviceInfo.Port = "USB-KB";
}
else
{
deviceInfo.FirmwareVersion = ParseFirmwareVersion(firmwareVersion);
deviceInfo.Port = firmwareVersion.Substring(firmwareVersion.IndexOf("USB", StringComparison.Ordinal), 7);
}
Debug.WriteLine("device INFO[Firmware Version] : {0}", (object)deviceInfo.FirmwareVersion);
Debug.WriteLine("device INFO[Port] : {0}", (object)deviceInfo.Port);
}
else
{
Debug.WriteLine("device: PopulateDeviceInfo() - failed to get Firmware version reason={0}", rt);
}
deviceInfo.ModelName = IDTechSDK.Profile.IDT_DEVICE_String(deviceType, deviceConnect);
Debug.WriteLine("device INFO[Model Name] : {0}", (object)deviceInfo.ModelName);
rt = IDT_Augusta.SharedController.config_getModelNumber(ref deviceInfo.ModelNumber);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
if (deviceMode != IDTECH_DEVICE_PID.AUGUSTA_KYB && deviceMode != IDTECH_DEVICE_PID.AUGUSTAS_KYB)
{
deviceInfo.ModelNumber = deviceInfo?.ModelNumber?.Split(' ')[0] ?? "";
}
Debug.WriteLine("device INFO[Model Number] : {0}", (object)deviceInfo.ModelNumber);
}
else
{
Debug.WriteLine("device: PopulateDeviceInfo() - failed to get Model number reason={0}", rt);
}
EMVKernelVer = "";
rt = IDT_Augusta.SharedController.emv_getEMVKernelVersion(ref EMVKernelVer);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
deviceInfo.EMVKernelVersion = EMVKernelVer;
Debug.WriteLine("device INFO[EMV KERNEL V.] : {0}", (object)deviceInfo.EMVKernelVersion);
}
else
{
Debug.WriteLine("device: PopulateDeviceInfo() - failed to get Model number reason={0}", rt);
}
return(true);
}
public Handler(RETURN_CODE returnCode, MESSAGE_ENUM messageCode, Paragraph p1 = null, Paragraph p2 = null, Paragraph p3 = null, Paragraph p4 = null)
{
ReturnCode = returnCode;
MessageCode = messageCode;
Message = Messages.Get(messageCode, p1, p2, p3, p4);
}
private bool PopulateDeviceInfo()
{
if (deviceMode == IDTECH_DEVICE_PID.VP3000_HID)
{
string serialNumber = "";
RETURN_CODE rt = IDT_VP3300.SharedController.config_getSerialNumber(ref serialNumber);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
deviceInfo.SerialNumber = serialNumber.Trim('\0');
Debug.WriteLine("device INFO[Serial Number] : {0}", (object)deviceInfo.SerialNumber);
}
else
{
Debug.WriteLine("DeviceCfg::PopulateDeviceInfo(): failed to get serialNumber reason={0}", rt);
}
string firmwareVersion = "";
rt = IDT_VP3300.SharedController.device_getFirmwareVersion(ref firmwareVersion);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
deviceInfo.FirmwareVersion = ParseFirmwareVersion(firmwareVersion);
Debug.WriteLine("device INFO[Firmware Version] : {0}", (object)deviceInfo.FirmwareVersion);
deviceInfo.Port = firmwareVersion.Substring(firmwareVersion.IndexOf("USB", StringComparison.Ordinal), 7);
Debug.WriteLine("device INFO[Port] : {0}", (object)deviceInfo.Port);
}
else
{
Debug.WriteLine("DeviceCfg::PopulateDeviceInfo(): failed to get Firmware version reason={0}", rt);
}
deviceInfo.ModelName = IDTechSDK.Profile.IDT_DEVICE_String(deviceType, deviceConnect);
Debug.WriteLine("device INFO[Model Name] : {0}", (object)deviceInfo.ModelName);
deviceInfo.ModelNumber = "UNKNOWN";
/*rt = IDT_VP3300.SharedController.config_getModelNumber(ref deviceInfo.ModelNumber);
*
* if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
* {
* Debug.WriteLine("device INFO[Model Number] : {0}", (object) deviceInfo.ModelNumber);
* }
* else
* {
* Debug.WriteLine("DeviceCfg::PopulateDeviceInfo(): failed to get Model number reason={0}", rt);
* }*/
}
else
{
// Initialize Device
HidDevice device = HidDevices.Enumerate(Device_IDTech.IDTechVendorID).FirstOrDefault();
if (device != null)
{
byte[] data;
if (device.ReadSerialNumber(out data))
{
deviceInfo.SerialNumber = GetKeyboardModeSerialNumber();
// VP3300 USB NEO v1.01.107
string [] payload = GetKeyboardModeFirmwareVersion();
if (payload?.Length == 4)
{
deviceInfo.FirmwareVersion = payload[3].Substring(1, payload[3].Length - 1);
deviceInfo.ModelName = payload[0] + " (" + payload[1] + ")";
deviceInfo.ModelNumber = "UNKNOWN";
deviceInfo.Port = payload[1] + "-KB";
}
}
}
}
return(true);
}
public override void ValidateCapKList(ConfigSerializer serializer)
{
try
{
if (serializer != null)
{
byte [] keys = null;
RETURN_CODE rt = IDT_Augusta.SharedController.emv_retrieveCAPKList(ref keys);
if (rt == RETURN_CODE.RETURN_CODE_NO_CA_KEY)
{
keys = new byte[0];
rt = RETURN_CODE.RETURN_CODE_DO_SUCCESS;
}
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("VALIDATE CAPK LIST ----------------------------------------------------------------------");
// Get Configuration File AID List
CAPKList capK = serializer.GetCapKList();
List <Capk> CapKList = new List <Capk>();
List <byte[]> capkNames = new List <byte[]>();
// Convert array to array of arrays
for (int i = 0; i < keys.Length; i += 6)
{
byte[] result = new byte[6];
Array.Copy(keys, i, result, 0, 6);
capkNames.Add(result);
}
foreach (byte[] capkName in capkNames)
{
bool delete = true;
bool found = false;
bool update = false;
KeyValuePair <string, CAPK> cfgCurrentItem = new KeyValuePair <string, CAPK>();
string devCapKName = BitConverter.ToString(capkName).Replace("-", string.Empty);
Debug.WriteLine("CAPK: {0} ===============================================", (object)devCapKName);
// Is this item in the approved list?
foreach (var cfgItem in capK.CAPK)
{
cfgCurrentItem = cfgItem;
string devRID = cfgItem.Value.RID;
string devIdx = cfgItem.Value.Index;
string devItem = devRID + devIdx;
if (devItem.Equals(devCapKName, StringComparison.CurrentCultureIgnoreCase))
{
found = true;
byte[] value = null;
Capk capk = null;
rt = IDT_Augusta.SharedController.emv_retrieveCAPK(capkName, ref value);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
capk = new Capk(value);
// compare modulus
string modulus = cfgItem.Value.Modulus;
update = !modulus.Equals(capk.GetModulus(), StringComparison.CurrentCultureIgnoreCase);
if (!update)
{
// compare exponent
string exponent = cfgItem.Value.Exponent;
update = !exponent.Equals(capk.GetExponent(), StringComparison.CurrentCultureIgnoreCase);
}
}
delete = false;
if (update && capk != null)
{
CapKList.Add(capk);
}
else
{
Debug.WriteLine(" : UP-TO-DATE");
}
}
}
// DELETE CAPK(s)
if (delete)
{
byte[] tagName = Device_IDTech.HexStringToByteArray(devCapKName);
rt = IDT_Augusta.SharedController.emv_removeCAPK(tagName);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("CAPK: {0} DELETED (NOT FOUND)", (object)devCapKName);
}
else
{
Debug.WriteLine("CAPK: {0} DELETE FAILED, ERROR={1}", devCapKName, rt);
}
}
else if (!found)
{
byte[] tagCfgName = Device_IDTech.HexStringToByteArray(cfgCurrentItem.Key);
List <byte[]> collection = new List <byte[]>();
string payload = string.Format("{0}{1}{2}{3}{4}{5}{6:X2}{7:X2}{8}",
cfgCurrentItem.Value.RID, cfgCurrentItem.Value.Index,
_HASH_SHA1_ID_STR, _ENC_RSA_ID_STR,
cfgCurrentItem.Value.Checksum, cfgCurrentItem.Value.Exponent,
(cfgCurrentItem.Value.Modulus.Length / 2) % 256, (cfgCurrentItem.Value.Modulus.Length / 2) / 256,
cfgCurrentItem.Value.Modulus);
byte[] tagCfgValue = Device_IDTech.HexStringToByteArray(payload);
Capk cfgCapK = new Capk(tagCfgValue);
CapKList.Add(cfgCapK);
}
}
// Add/Update CAPK(s)
foreach (var capkElement in CapKList)
{
//capkElement.ShowCapkValues();
byte [] capkValue = capkElement.GetCapkValue();
rt = IDT_Augusta.SharedController.emv_setCAPK(capkValue);
if (rt == RETURN_CODE.RETURN_CODE_DO_SUCCESS)
{
Debug.WriteLine("CAPK: {0} UPDATED", (object)capkElement.GetCapkName());
}
else
{
Debug.WriteLine("CAPK: {0} FAILED TO UPDATE - ERROR={1}", capkElement.GetCapkName(), rt);
}
}
}
else
{
Debug.WriteLine("CAPK: emv_retrieveCAPKList() - ERROR={0}", rt);
}
}
}
catch (Exception exp)
{
Debug.WriteLine("device: ValidateAidList() - exception={0}", (object)exp.Message);
}
}
