#include "MessageHelper.h" #include "terminal_utils.h" #include "aes128.h" #include <QDateTime> #include <QDebug> #define IUC_ASYNCHPOS_COINCOIDE_H 0x09 #define IUC_ASYNCHPOS_COINCOIDE_L 0x78 #define IUC_ASYNCHPOS_MAX_ARRAY_SIZE 1024 #define IUC_ASYNCHPOS_MAX_TX_PACKET_SIZE 300 #define IUC_ASYNCHPOS_MAX_RX_PACKET_SIZE 10000 // 17000 #define IUC_ASYNCHPOS_MIN_PACKET_SIZE 16 #define IUC_ASYNCHPOS_MIN_BASE_DATA_SIZE 32 #define IUC_ASYNCHPOS_MIN_BASE_BYTE_DATA_SIZE 16 #define IUC_ASYNCHPOS_POLYNOME 0xedb88320 // 0x04C11DB7 #define IUC_ASYNCHPOS_POLYNOME_INITIAL 0 // 0xFFFFFFFF #define IUC_ASYNCHPOS_PRINTTIMOUT 1000 #define PACKET_ID_SIZE 8 #define MAX_POSID_LENGTH 255 #define STX ((char)0x01) #define ETX1 ((char)0x02) #define ETX2 ((char)0x03) #define EOT ((char)0x04) #define ENQ ((char)0x05) #define ACK1 ((char)0x06) #define ACK2 ((char)0x07) #define DLE ((char)0x10) #define NAK ((char)0x15) #define DBG_HEADER "(" << __func__ << ":" << __LINE__ << ")" #define DBG_EMERGENCY (0) // System is unusable #define DBG_ALERT (1) // Action must be taken immediately #define DBG_CRITICAL (2) // Critical conditions #define DBG_ERROR (3) // Error conditions #define DBG_WARNING (4) // Warning conditions #define DBG_NOTICE (5) // Normal but significant conditions // Conditions that are not error conditions, but that may require special handling #define DBG_INFORMATION (6) // Informational messages // Confirmation that the program is working as expected #define DBG_DEBUG (7) // Debug-level messages // Messages that contain information normally of use only when debugging a program static int DBG_LEVEL = DBG_INFORMATION; //static int DBG_LEVEL = DBG_DEBUG; struct MessageHeader { uint8_t packetType; uint8_t packetID[PACKET_ID_SIZE]; uint8_t POSIDLength; uint8_t POSID[MAX_POSID_LENGTH]; }; MessageHelper::AsynchBillData MessageHelper::m_asyncBillData; MessageHelper::AuthorizationResult MessageHelper::m_authorizationResult; MessageHelper::MessageHelper(QString const &posID, QString const &apak) : m_posID(posID.toUtf8().constData()) , m_posIDLength(m_posID.size()) , m_messageHeaderPrefix(1 + PACKET_ID_SIZE + 1, 0x00) , m_rawPacket(IUC_ASYNCHPOS_MAX_TX_PACKET_SIZE, 0x00) { m_messageHeaderPrefix[9] = (uint8_t)m_posID.size(); for (int p = 0; p < apak.size(); p+=2) { uint8_t n = strtoul(apak.mid(p, 2).toStdString().c_str(), nullptr, 16); m_apak.push_back(n); } if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << apak << m_apak.toHex(':'); qCritical() << DBG_HEADER << m_posID.toHex(':'); qCritical() << DBG_HEADER << m_messageHeaderPrefix.toHex(':'); } } MessageHelper::MessageHelper(QByteArray const &posID, QString const &apak) : m_posID(posID) , m_posIDLength(m_posID.size()) , m_messageHeaderPrefix(1 + PACKET_ID_SIZE + 1, 0x00) , m_rawPacket(IUC_ASYNCHPOS_MAX_TX_PACKET_SIZE, 0x00) { m_messageHeaderPrefix[9] = (uint8_t)m_posID.size(); for (int p = 0; p < apak.size(); p+=2) { uint8_t n = strtoul(apak.mid(p, 2).toStdString().c_str(), nullptr, 16); m_apak.push_back(n); } if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << apak << m_apak.toHex(':'); qCritical() << DBG_HEADER << m_posID.toHex(':'); qCritical() << DBG_HEADER << m_messageHeaderPrefix.toHex(':'); } } MessageHelper::~MessageHelper() { } void MessageHelper::handleMessage(char const *pData) { #if 0 //unsigned char marker = pData[0]; // unsigned int tagNameLength = pData[1]; unsigned char tagName[IUC_ASYNCHPOS_MIN_BASE_DATA_SIZE]; // unsigned int curElementLength = 0; //unsigned char curElement[IUC_ASYNCHPOS_MIN_BASE_DATA_SIZE]; //unsigned char receiptData[IUC_ASYNCHPOS_MAX_ARRAY_SIZE + 1]; unsigned char rxBuf[20]; // unsigned char flags[129]; // unsigned char docNr[32]; //unsigned char messageType = pData[1]; unsigned int uitmp = 0; unsigned int uitmp2 = 0; iuc_asynchpos_sub_initArray(tagName, IUC_ASYNCHPOS_MIN_BASE_DATA_SIZE); //iuc_asynchpos_sub_initArray(curElement, IUC_ASYNCHPOS_MIN_BASE_DATA_SIZE); uitmp = biox_FindStrInBufferInt("LoginResult",pData) | biox_FindStrInBuffer("LOGINRESULT",pData); if (uitmp) { asynchState = 0x02; //eingeloggt /*rxBuf[0] = 0x45; rxBuf[1] = 0x00; rxBuf[2] = 0x00; vmc_SendWithBuffer(rxBuf,40,0x69,0);*/ } uitmp = biox_FindStrInBufferInt("AuthorizationStarted",pData) | biox_FindStrInBuffer("AUTHORIZATIONSTARTED",pData); if (uitmp) { iuc_asynchpos_sub_initArray(rxBuf,5); rxBuf[0] = 0x53; rxBuf[1] = 0x00; rxBuf[2] = 0x00; vmc_SendWithBuffer(rxBuf,5,0x69,0); } uitmp = biox_FindStrInBufferInt("AuthorizationResult",pData) | biox_FindStrInBuffer("AUTHORIZATIONRESULT",pData); if (uitmp) { asynchState = 0x03; //successfully authorized iuc_asynchpos_sub_clear_message(0x00); uitmp = biox_FindStrInBufferInt("ID",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.id, 0, pData[uitmp + 1]); uitmp = biox_FindStrInBufferInt("DocNr",pData) | biox_FindStrInBuffer("DOCNR",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.docNr, 0, pData[uitmp + 1]); //uitmp = biox_FindStrInBuffer("Result",pData) | biox_FindStrInBuffer("RESULT",pData); //biox_CopyBlock(pData, uitmp + 2, asynchBill.result, 0, pData[uitmp + 1]); brd_SendDiagStr("->IUC ASYNCHPOS message ID: ",0); brd_SendDiagBlock(asynchBill.id,1,36); /*if (iuc_asynch_PrintControl) { brd_SendDiagStr("->IUC ASYNCHPOS print data send AUTH: ",1); vmc_SendWithBuffer(receiptData,IUC_ASYNCHPOS_MAX_ARRAY_SIZE,0x69,0); iuc_asynch_PrintControl = 0x00; //biox_delay_ms(750); } else { brd_SendDiagStr("->IUC ASYNCHPOS sending authorization: ",1); iuc_asynch_PrintControl = 0x01; }*/ uitmp = biox_FindStrInBufferInt("ERROR",pData); if (!uitmp/*biox_FindStrInBuffer("OK",pData) | biox_FindStrInBuffer("Approved",pData) | biox_FindStrInBuffer("APPROVED",asynchBill.result)*/) { iuc_asynch_PrintControl |= 0xF0; /*uitmp = biox_FindStrInBufferInt("Amount",pData) | biox_FindStrInBufferInt("AMOUNT",pData); //if (pData[uitmp + 1] <= 10) { biox_CopyBlock(pData, uitmp + 2, asynchBill.amount, 0, pData[uitmp + 1]); //} else { //biox_CopyBlock(pData, uitmp + 2, asynchBill.amount, 0, 10); //}*/ //uitmp = biox_FindStrInBuffer("Token",pData); //biox_CopyBlock(pData, uitmp + 2, asynchBill.token, 0, pData[uitmp + 1]); /*uitmp = biox_FindStrInBufferInt("Authcode",pData) | biox_FindStrInBufferInt("AUTHCODE",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.authCode, 0, pData[uitmp + 1]); uitmp = biox_FindStrInBufferInt("RRN",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.rrn, 0, pData[uitmp + 1]); uitmp = biox_FindStrInBufferInt("STAN",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.stan, 0, pData[uitmp + 1]); uitmp = biox_FindStrInBufferInt("CardType",pData) | biox_FindStrInBufferInt("CARDTYPE",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.cardtype, 0, pData[uitmp + 1]);*/ asynchState = 0x04; brd_SendDiagStr("->IUC ASYNCHPOS authorization confirmed.",1); /*iuc_asynchpos_sub_initArray(rxBuf,20); rxBuf[0] = 0x45; rxBuf[1] = 0x00; rxBuf[2] = 0x00; vmc_SendWithBuffer(rxBuf,20,0x69,0);*/ //iuc_asynchpos_resetBuffers(0x01); //iuc_asynchpos_command_close_Document(); } else { iuc_asynch_PrintControl |= 0xF0; //uitmp = biox_FindStrInBufferInt("ErrCode",pData) | biox_FindStrInBufferInt("ERRCODE",pData); //biox_CopyBlock(pData, uitmp + 2, asynchBill.errCode, 0, pData[uitmp + 1]); brd_SendDiagStr("->IUC ASYNCHPOS authorization failed.",1); /*iuc_asynchpos_sub_initArray(rxBuf,20); rxBuf[0] = 0x45; rxBuf[1] = 0xFF; biox_CopyBlock(pData, uitmp + 2, rxBuf, 2, pData[uitmp + 1]); vmc_SendWithBuffer(rxBuf,20,0x69,0);*/ iuc_asynch_keepAlive = 0x00; //VendRequest=0; } } uitmp = biox_FindStrInBufferInt("PrintReceipt",pData) | biox_FindStrInBufferInt("PRINTRECEIPT",pData); if (uitmp) { asynchState = 0x03; //Customer receipt recieved //iuc_asynchpos_sub_initArray(flags,129); //uitmp = biox_FindStrInBufferInt("Flag",pData) | biox_FindStrInBufferInt("FLAG",pData) | biox_FindStrInBufferInt("Flags",pData) | biox_FindStrInBufferInt("FLAGS",pData); /*if (uitmp) { biox_CopyBlock(pData, uitmp + 2, flags, 0, pData[uitmp + 1]); uitmp = biox_FindStrInBufferInt("CD",flags) | biox_FindStrInBufferInt("LR",flags); }*/ /*iuc_asynchpos_sub_clear_message(0x00); uitmp = biox_FindStrInBufferInt("ID",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.id, 0, pData[uitmp + 1]); uitmp = biox_FindStrInBufferInt("DocNr",pData) | biox_FindStrInBuffer("DOCNR",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.docNr, 0, pData[uitmp + 1]);*/ iuc_asynchpos_sub_initArray(asynchBill.printId,129); uitmp = biox_FindStrInBufferInt("ID",pData); biox_CopyBlock(pData, uitmp + 2, asynchBill.printId, 0, pData[uitmp + 1]); //if(asynchState == 0x02/* && uitmp biox_FindStrInBufferInt("CD",flags) || biox_FindStrInBufferInt("LR",flags)*/) { if((!iuc_asynch_PRNrecieved) && (biox_FindStrInBufferInt("CD",pData) || biox_FindStrInBufferInt("LR",pData)) ) { iuc_asynch_PRNrecieved = 0x01; iuc_asynchpos_sub_initArray(receiptData,IUC_ASYNCHPOS_MAX_ARRAY_SIZE + 1); uitmp = /*biox_FindStrInBuffer("ReceiptText",pData) | */biox_FindStrInBufferInt("RECEIPTTEXT",pData); uitmp2 = (pData[uitmp] * 256) + pData[uitmp + 1]; //if (uitmp2 <= IUC_ASYNCHPOS_MAX_ARRAY_SIZE) { if (uitmp2 > IUC_ASYNCHPOS_MAX_ARRAY_SIZE) { uitmp2 = IUC_ASYNCHPOS_MAX_ARRAY_SIZE; brd_SendDiagStr("->IUC ASYNCHPOS receipt: ERROR. Receipt too large! Cutting off.",1); /*receiptData[0] = 0x50; biox_CopyBlock(pData, uitmp + 2, receiptData, 1, uitmp2/*IUC_ASYNCHPOS_MAX_ARRAY_SIZE*); //uitmp += IUC_ASYNCHPOS_MAX_ARRAY_SIZE; //uitmp2 -= IUC_ASYNCHPOS_MAX_ARRAY_SIZE; brd_SendDiagStr("->IUC ASYNCHPOS receipt: ",0); brd_SendDiagBlock(receiptData,1,IUC_ASYNCHPOS_MAX_ARRAY_SIZE); iuc_asynch_PrintControl |= 0x0F;*/ /*if (iuc_asynch_PrintControl) { brd_SendDiagStr("->IUC ASYNCHPOS print data send: ",1); vmc_SendWithBuffer(receiptData,IUC_ASYNCHPOS_MAX_ARRAY_SIZE,0x69,0); iuc_asynch_PrintControl = 0x00; } else { brd_SendDiagStr("->IUC ASYNCHPOS print data stored: ",1); iuc_asynch_PrintControl = 0x01; }*/ //biox_delay_ms(750); //iuc_asynchpos_resetBuffers(0x01); //iuc_asynchpos_command_close_Document(); //iuc_asynchpos_resetBuffers(0x02); //iuc_asynchpos_command_print_Result(0x01); } receiptData[0] = 0x50; biox_CopyBlock(pData, uitmp + 2, receiptData, 1, uitmp2/*IUC_ASYNCHPOS_MAX_ARRAY_SIZE*/); brd_SendDiagStr("->IUC ASYNCHPOS receipt: ",0); brd_SendDiagBlock(receiptData,1,IUC_ASYNCHPOS_MAX_ARRAY_SIZE); iuc_asynch_PrintControl |= 0x0F; /* else { //receiptData[0] = 0x50; //iuc_asynchpos_sub_initZero(receiptData,1); brd_SendDiagStr("->IUC ASYNCHPOS receipt: ERROR. Receipt too large!",1); iuc_asynch_PrintControl |= 0x0E; } */ /* else { //iuc_asynchpos_resetBuffers(0x02); iuc_asynchpos_command_print_Result(0x00); }*/ } //++iuc_print_counter; //if(asynchState == 0x04 && iuc_asynch_PrintControl == 0) { //iuc_asynchpos_resetBuffers(0x01); //iuc_asynchpos_resetBuffers(0x00); //iuc_asynchpos_command_print_Result(0x01); /*} /else { //iuc_asynchpos_resetBuffers(0x02); iuc_asynchpos_command_print_Result(0x01); }*/ //iuc_asynchpos_command_print_Result(0x01); /*while (uitmp2 > IUC_ASYNCHPOS_MAX_ARRAY_SIZE) { biox_CopyBlock(pData, uitmp + 2, receiptData, 0, IUC_ASYNCHPOS_MAX_ARRAY_SIZE); uitmp += IUC_ASYNCHPOS_MAX_ARRAY_SIZE; uitmp2 -= IUC_ASYNCHPOS_MAX_ARRAY_SIZE; vmc_SendWithBuffer(receiptData,IUC_ASYNCHPOS_MAX_ARRAY_SIZE,0x69,0); } //Rest des Packets biox_CopyBlock(pData, uitmp + 2, receiptData, 0, uitmp2); vmc_SendWithBuffer(receiptData,uitmp2,0x69,0); //iuc_asynchpos_resetBuffers(0x02); iuc_asynchpos_command_print_Result(0x01);*/ } uitmp = biox_FindStrInBufferInt("VoidResult",pData) | biox_FindStrInBufferInt("VOIDRESULT",pData); if (uitmp) { asynchState = 0x01; //There was a cancel. Relogin and try again. uitmp = biox_FindStrInBufferInt("ERROR",pData); if (uitmp) { rxBuf[0] = 0x45; rxBuf[1] = 0x56; rxBuf[2] = 0x45; vmc_SendWithBuffer(rxBuf,3,0x69,0); } uitmp = biox_FindStrInBufferInt("REFUND",pData); if (uitmp) { rxBuf[0] = 0x45; rxBuf[1] = 0x56; rxBuf[2] = 0x52; vmc_SendWithBuffer(rxBuf,3,0x69,0); //TODO refund bill here. Should not trigger, but it might. } } uitmp = biox_FindStrInBufferInt("DocClosed",pData); if (uitmp) { asynchState = 0x01; //Transaction successful //if (VendRequest) GWstate.VendRequest=0; } #endif } void MessageHelper::handleCommand(AsyncPosCommand command, char status) { //r - registration, a - authorization, c - cancel, s - storno, k - kassenschnitt #if 0 UCHAR tempBuf[3]; UCHAR rxBuf[8]; // UINT uitemp = 0; UINT uitmp= 700; tempBuf[0] = 0x00; tempBuf[1] = 0x00; tempBuf[2] = 0x00; timeHoldISMAS = GWglobTime.SecOfDay; iuc_asynchpos_sub_initArray(rxBuf,8); //iuc_asynchpos_resetBuffers(0x00); switch (command) { case 0x72: //registration //iuc_asynchpos_init(); asynchState = 0x01; iuc_asynchpos_command_Login(); GWstate.VendRequest=1; break; case 0x61: //authorisation iuc_asynch_keepAlive = 0x01; iuc_asynch_PrintControl = 0; iuc_asynchpos_sub_clear_message(0x01); //VendRequest=1; iuc_asynchpos_resetBuffers(0x00); ///#ifdef IUC_ASYCHNPOS_TESTMODE //iuc_asynchpos_command_authorize(uitmp); //#else iuc_asynchpos_command_authorize(Vend.Amount); //#endif break; case 0x63: //cancel case 0x73: //storno /*if (asynchState <= 0x02 != 0) { //Authorization result recieved? iuc_asynchpos_command_cancel_authorize(); } else {*/ iuc_asynchpos_command_close_Document(0x01); //} iuc_asynch_keepAlive = 0x00; //VendRequest=0; break; case 0x6B: //kassenschnitt iuc_asynchpos_command_Logout(); break; case 0x62: //get last bill //iuc_zvt_getLastBill(tempBuf); break; case 0x01: iuc_asynchpos_command_close_Document(0x00); iuc_asynch_keepAlive = 0x00; //VendRequest=0; break; case 0x70: iuc_asynchpos_command_ping_terminal(); break; default: break; } #endif } void MessageHelper::createRawPacket(PacketType packetType, QByteArray const &encryptedPacketID, QByteArray const &message) { if (createMessageHeaderPrefix(packetType, encryptedPacketID)) { QByteArray ba(m_messageHeaderPrefix); ba = ba.append(m_posID); ba = ba.append(message); uint16_t const size = ba.size(); ba.push_front((char)size); ba.push_front((char)(size >> 8)); m_rawPacket = ba; } } bool MessageHelper::setMessageHeaderPacketType(PacketType packetType) { switch (packetType) { case PacketType::POS_ECR: case PacketType::MESSAGE_RECEIVED_POSITIVE_ACK: case PacketType::MESSAGE_RECEIVED_NEGATIVE_ACK: m_messageHeaderPrefix[0] = (uint8_t)packetType; break; default: return false; } return true; } bool MessageHelper::createMessageHeaderPrefix(PacketType packetType, QByteArray const &encryptedPacketID) { if (encryptedPacketID.size() == PACKET_ID_SIZE) { if (setMessageHeaderPacketType(packetType)) { for (int i = 1; i <= 8; ++i) { m_messageHeaderPrefix[i] = (uint8_t)encryptedPacketID[i-1]; } if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << m_messageHeaderPrefix.toHex(':'); } return true; } } return false; } QByteArray const &MessageHelper::generateUniqueTransactionID(QString const &machineNr, QString const &customerNr) { // TODO: wieder entfernen QDateTime dt(QDateTime::fromString("2024-06-18T12:00:00", Qt::ISODate)); uint64_t const transID = MessageHelper::secsSinceJan2017(dt); m_uniqueTransactionID.clear(); m_uniqueTransactionID = m_uniqueTransactionID.append(QByteArray(std::to_string(transID).c_str(), 9).rightJustified(10, '0')); m_uniqueTransactionID = m_uniqueTransactionID.append(QByteArray(machineNr.toStdString().c_str()).rightJustified(5, '0')); m_uniqueTransactionID = m_uniqueTransactionID.append(QByteArray(customerNr.toStdString().c_str()).rightJustified(4, '0')); return m_uniqueTransactionID; } // actual payment. amount to pay is known. void MessageHelper::createAuthorizeMessage() { m_authorizeMessage.clear(); m_authorizeMessage.push_back((char)0x89); // 9 in 0x89 is the size m_authorizeMessage = m_authorizeMessage.append(QByteArray("Authorize")); QString const &price= m_price.setNum(1000); m_authorizeMessage.push_back((char)0x06); m_authorizeMessage = m_authorizeMessage.append(QByteArray("Amount")); m_authorizeMessage.push_back((char)0x00); m_authorizeMessage.push_back((char)price.size()); m_authorizeMessage = m_authorizeMessage.append(QByteArray(price.toStdString().c_str())); m_authorizeMessage.push_back((char)0x04); m_authorizeMessage = m_authorizeMessage.append(QByteArray("Cash")); m_authorizeMessage.push_back((char)0x00); m_authorizeMessage.push_back((char)0x01); m_authorizeMessage.push_back((char)0x30); m_authorizeMessage.push_back((char)0x08); m_authorizeMessage = m_authorizeMessage.append(QByteArray("Currency")); m_authorizeMessage.push_back((char)0x00); m_authorizeMessage.push_back((char)0x03); m_authorizeMessage = m_authorizeMessage.append(QByteArray("978")); m_authorizeMessage.push_back((char)0x05); m_authorizeMessage = m_authorizeMessage.append(QByteArray("DocNr")); m_authorizeMessage.push_back((char)0x00); m_authorizeMessage.push_back((char)0x13); m_authorizeMessage = m_authorizeMessage.append(generateUniqueTransactionID("1000", "100")); m_authorizeMessage.push_back((char)0x04); m_authorizeMessage = m_authorizeMessage.append(QByteArray("Time")); m_authorizeMessage.push_back((char)0x00); m_authorizeMessage.push_back((char)0x13); QDateTime current = QDateTime::currentDateTime(); // TODO: wieder entfernen current.setTime(QTime(12, 0, 0)); current.setDate(QDate(2024, 6, 18)); QByteArray time(current.toString(Qt::ISODate).toStdString().c_str()); time[10] = ' '; m_authorizeMessage = m_authorizeMessage.append(QByteArray(time)); m_authorizeMessage.push_back((char)0x04); m_authorizeMessage = m_authorizeMessage.append(QByteArray("Lang")); m_authorizeMessage.push_back((char)0x00); m_authorizeMessage.push_back((char)0x02); m_authorizeMessage = m_authorizeMessage.append(QByteArray("lt")); m_authorizeMessage.push_back((char)0x00); } void MessageHelper::createCancelAuthorizeMessage() { m_cancelAuthorizeMessage.clear(); m_cancelAuthorizeMessage.push_back((char)0x96); // 0x80 + 0x16 m_cancelAuthorizeMessage = m_cancelAuthorizeMessage.append(QByteArray("AuthorizationCancelled")); m_cancelAuthorizeMessage.push_back((char)0x02); m_cancelAuthorizeMessage = m_authorizeMessage.append(QByteArray("ID")); m_cancelAuthorizeMessage.push_back((char)0x00); m_cancelAuthorizeMessage.push_back((char)QByteArray(m_asyncBillData.id).size()); m_cancelAuthorizeMessage = m_cancelAuthorizeMessage.append(QByteArray(m_asyncBillData.id)); m_cancelAuthorizeMessage.push_back((char)0x00); } void MessageHelper::createPingMessage() { m_pingMessage.clear(); m_pingMessage.push_back((char)0x84); // 4 in 0x84 is the size m_pingMessage = m_pingMessage.append(QByteArray("Ping")); m_pingMessage.push_back((char)0x04); m_pingMessage = m_authorizeMessage.append(QByteArray("Time")); m_pingMessage.push_back((char)0x00); m_pingMessage.push_back((char)0x13); QDateTime current = QDateTime::currentDateTime(); // TODO: wieder entfernen current.setTime(QTime(12, 0, 0)); current.setDate(QDate(2024, 6, 18)); QByteArray time(current.toString(Qt::ISODate).toStdString().c_str()); time[10] = ' '; m_pingMessage = m_pingMessage.append(QByteArray(time)); m_pingMessage.push_back((char)0x00); } void MessageHelper::createCloseDocumentMessage(bool storno) { m_closeDocumentMessage.clear(); m_closeDocumentMessage.push_back((char)0x89); // 9 in 0x89 is the size m_closeDocumentMessage = m_closeDocumentMessage.append(QByteArray("DocClosed")); m_closeDocumentMessage.push_back((char)0x05); m_closeDocumentMessage = m_closeDocumentMessage.append(QByteArray("DocNr")); uint16_t const docNrSize = m_uniqueTransactionID.size(); m_closeDocumentMessage.push_back((char)(docNrSize >> 8)); m_closeDocumentMessage.push_back((char)(docNrSize)); m_closeDocumentMessage = m_closeDocumentMessage.append(m_uniqueTransactionID); if (!storno) { m_closeDocumentMessage.push_back((char)0x06); m_closeDocumentMessage = m_closeDocumentMessage.append(QByteArray("AuthID")); QByteArray ba(m_authorizationResult.m_id.toStdString().c_str()); uint16_t const authIdSize = ba.size(); m_closeDocumentMessage.push_back((char)(authIdSize >> 8)); m_closeDocumentMessage.push_back((char)(authIdSize)); m_closeDocumentMessage = m_closeDocumentMessage.append(ba); } m_closeDocumentMessage.push_back((char)0x00); } void MessageHelper::createPrintResultMessage() { m_printResultMessage.clear(); } uint32_t MessageHelper::secsSinceJan2017(QDateTime const &dt) { return QDateTime(QDateTime::fromString("2017-01-01T00:00:00", Qt::ISODate)).secsTo(dt); } void MessageHelper::createLoginMessage() { m_loginMessage.clear(); m_loginMessage.push_back((char)0x85); // 5 in 0x85 is the size m_loginMessage = m_loginMessage.append(QByteArray("Login")); m_loginMessage.push_back((char)0x04); m_loginMessage = m_loginMessage.append(QByteArray("Time")); m_loginMessage.push_back((char)0x00); m_loginMessage.push_back((char)0x13); QDateTime current = QDateTime::currentDateTime(); // TODO: wieder entfernen current.setTime(QTime(12, 0, 0)); current.setDate(QDate(2024, 6, 18)); QByteArray time(current.toString(Qt::ISODate).toStdString().c_str()); time[10] = ' '; m_loginMessage = m_loginMessage.append(time); m_loginMessage.push_back((char)0x05); m_loginMessage = m_loginMessage.append(QByteArray("Flags")); m_loginMessage.push_back((char)0x00); m_loginMessage.push_back((char)0x06); m_loginMessage = m_loginMessage.append(QByteArray("AP3|LR")); m_loginMessage.push_back((char)0x00); if (DBG_LEVEL >= DBG_INFORMATION) { qCritical() << DBG_HEADER << "loginMessage" << m_loginMessage.toHex(':'); } } void MessageHelper::createLogoutMessage() { m_logoutMessage.clear(); m_logoutMessage.push_back((char)0x86); // 6 in 0x86 is the size m_logoutMessage = m_loginMessage.append(QByteArray("Logout")); m_loginMessage.push_back((char)0x04); m_loginMessage = m_loginMessage.append(QByteArray("Time")); m_loginMessage.push_back((char)0x00); m_loginMessage.push_back((char)0x13); QDateTime current = QDateTime::currentDateTime(); // TODO: wieder entfernen current.setTime(QTime(12, 0, 0)); current.setDate(QDate(2024, 6, 18)); QByteArray time(current.toString(Qt::ISODate).toStdString().c_str()); time[10] = ' '; m_logoutMessage = m_logoutMessage.append(time); m_loginMessage.push_back((char)0x00); if (DBG_LEVEL >= DBG_INFORMATION) { qCritical() << DBG_HEADER << "loginMessage" << m_logoutMessage.toHex(':'); } } QByteArrayList const &MessageHelper::createMessageChunksToSend(AsyncPosCommand cmd, char etx) { QByteArray encryptedPacketID(QByteArray("\x01\x02\x03\x04\x05\x06\x07\x08")); m_messageChunkList.clear(); switch (cmd) { case (int)MessageHelper::AsyncPosCommand::LOGIN: createLoginMessage(); createRawPacket(PacketType::POS_ECR, encryptedPacketID, m_loginMessage); break; case (int)MessageHelper::AsyncPosCommand::LOGOUT: createLogoutMessage(); createRawPacket(PacketType::POS_ECR, encryptedPacketID, m_logoutMessage); break; case (int)MessageHelper::AsyncPosCommand::AUTHORIZE: createAuthorizeMessage(); createRawPacket(PacketType::POS_ECR, encryptedPacketID, m_authorizeMessage); break; case (int)MessageHelper::AsyncPosCommand::CLOSE_DOCUMENT: createCloseDocumentMessage(); // actung: hier default parameter createRawPacket(PacketType::POS_ECR, encryptedPacketID, m_closeDocumentMessage); break; default:; } if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << m_rawPacket.toHex(':'); } QByteArray const &ba = m_rawPacket.mid(11); if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << ba.toHex(':'); } // calculate crc32 on message starting from (including) POSID length uint32_t crc = TU::crc32(ba); if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << "crc32" << hex << crc; } unsigned char cipherText[256]; memset(cipherText, 0, sizeof(cipherText)); // XOR crc32-value (4 bytes) with APAK starting from left // (rest of APAK untouched) QByteArray clearText(m_apak); clearText[0] = clearText[0] ^ ((uint8_t)(crc >> 24)); clearText[1] = clearText[1] ^ ((uint8_t)(crc >> 16)); clearText[2] = clearText[2] ^ ((uint8_t)(crc >> 8)); clearText[3] = clearText[3] ^ ((uint8_t)(crc >> 0)); if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << "clearText" << clearText.toHex(); } // encrypt XOR result with APAK using AES129, ECB mode aes_encrypt((uint8_t *)clearText.data(), (uint8_t *)cipherText, (uint8_t *)m_apak.toStdString().c_str()); // 8 left bytes of encryption result is signature (Packet ID) encryptedPacketID = QByteArray((const char *)cipherText, 8); if (DBG_LEVEL >= DBG_INFORMATION) { qCritical() << DBG_HEADER << "cipherText (new PacketID)" << encryptedPacketID.toHex(':'); } // insert PacketID in packet if (insertEncryptedPacketID(encryptedPacketID)) { // build chunks to be sent over serial line int const chunks = m_rawPacket.size() / IUC_ASYNCHPOS_MIN_PACKET_SIZE; if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << "nr of chunks" << chunks; } int i = 0; for (; i < chunks; ++i) { QByteArray messageChunk = m_rawPacket.mid(IUC_ASYNCHPOS_MIN_PACKET_SIZE*i, IUC_ASYNCHPOS_MIN_PACKET_SIZE); if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << i << "unmasked" << messageChunk.toHex(':'); } messageChunk = MessageHelper::mask(messageChunk); if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << i << " masked" << messageChunk.toHex(':'); } messageChunk.push_back(etx == ACK1 ? ETX2 : ETX1); // etx must be ACK1 or ACK2 char const lrc = TU::lrc(messageChunk); messageChunk.push_back(lrc); messageChunk.push_front(STX); if (DBG_LEVEL >= DBG_INFORMATION) { qCritical() << DBG_HEADER << "chunk to send" << messageChunk.toHex(':'); } m_messageChunkList += messageChunk; } int const rest = m_rawPacket.size() % IUC_ASYNCHPOS_MIN_PACKET_SIZE; if (rest) { QByteArray messageChunk = m_rawPacket.mid(IUC_ASYNCHPOS_MIN_PACKET_SIZE*chunks, rest); if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << i << "unmasked" << messageChunk.toHex(':'); } messageChunk = mask(messageChunk); if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << i << " masked" << messageChunk.toHex(':'); } messageChunk.push_back(etx == ACK1 ? ETX2 : ETX1); // etx must be ACK1 or ACK2 char const lrc = TU::lrc(messageChunk); messageChunk.push_back(lrc); messageChunk.push_front(STX); if (DBG_LEVEL >= DBG_INFORMATION) { qCritical() << DBG_HEADER << "chunk to send" << messageChunk.toHex(':'); } m_messageChunkList += messageChunk; } } return m_messageChunkList; } QByteArrayList MessageHelper::createLoginMessageChunksToSend(char etx) { return createMessageChunksToSend(AsyncPosCommand::LOGIN, etx); } QByteArrayList MessageHelper::createLogoutMessageChunksToSend(char etx) { return createMessageChunksToSend(AsyncPosCommand::LOGOUT, etx); } QByteArrayList MessageHelper::createAuthorizeMessageChunksToSend(char etx) { return createMessageChunksToSend(AsyncPosCommand::AUTHORIZE, etx); } QByteArrayList MessageHelper::createCloseDocumentMessageChunksToSend(char etx) { return createMessageChunksToSend(AsyncPosCommand::CLOSE_DOCUMENT, etx); } bool MessageHelper::insertEncryptedPacketID(QByteArray const &encryptedPacketID) { if (encryptedPacketID.size() == PACKET_ID_SIZE) { // m_rawPacket has already full length for (int i = 0; i < PACKET_ID_SIZE; ++i) { m_messageHeaderPrefix[i+1] = encryptedPacketID[i]; m_rawPacket[i+3] = encryptedPacketID[i]; } if (DBG_LEVEL >= DBG_DEBUG) { qCritical() << DBG_HEADER << m_messageHeaderPrefix.toHex(':'); qCritical() << DBG_HEADER << m_rawPacket.toHex(':'); } return true; } return false; } QByteArray const &MessageHelper::mask(QByteArray &messageChunk) { QByteArray ba; for (int i = 0; i < messageChunk.size(); ++i) { char const c = messageChunk[i]; switch(c) { case STX: __attribute__((fallthrough)); case ETX1: __attribute__((fallthrough)); case ETX2: __attribute__((fallthrough)); case EOT: __attribute__((fallthrough)); case ENQ: __attribute__((fallthrough)); case ACK1: __attribute__((fallthrough)); case ACK2: __attribute__((fallthrough)); case DLE: __attribute__((fallthrough)); case NAK: ba.push_back(char(DLE)); ba.push_back(c + 0x30); break; default: ba.push_back(c); } } messageChunk = ba; return messageChunk; } QByteArray const &MessageHelper::unMask(QByteArray &messageChunk) { QByteArray ba; for (int i = 0; i < messageChunk.size(); ++i) { char c = messageChunk[i]; if (c == (char)0x10) /* DEL */ { if ((i+1) < messageChunk.size()) { c = messageChunk[i+1] - (char)0x30; } } ba.push_back(c); } messageChunk = ba; return messageChunk; }