#include "ANSUtilities.h" #ifdef _WIN32 #include #include // EvtQuery / EvtRender for GetANSLoggerErrorEvents #pragma comment(lib, "wevtapi.lib") #endif #include #include #include #include #include #include #include #include #include static bool ansutilityLicenceValid = false; static std::once_flag ansutilityLicenseOnceFlag; std::timed_mutex timeImageMutex; namespace ANSCENTER { // Helper: detect if a std::string is actually UTF-16LE (e.g. from LabVIEW). // Heuristic: length >= 4, even, and first printable ASCII char is followed by 0x00. static bool IsLikelyUTF16LE(const std::string& str) { if (str.size() < 4 || (str.size() % 2 != 0)) return false; unsigned char b0 = static_cast(str[0]); unsigned char b1 = static_cast(str[1]); return (b0 >= 0x20 && b0 <= 0x7E && b1 == 0x00); } static void VerifyGlobalANSUltilityLicense(const std::string& licenseKey) { try { static const std::vector> licenseChecks = { {1000, "ANNHUB-LV"}, {1001, "DLHUB-LV"}, {1002, "ODHUB-LV"}, {1003, "ANSVIS"}, {1004, "ANSFR"}, {1005, "ANSOCR"}, {1006, "ANSALPR"}, {1007, "ANSCV"}, {1008, "ANSSRT"} }; ansutilityLicenceValid = false; for (const auto& [productId, productName] : licenseChecks) { if (ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, productId, productName)) { ansutilityLicenceValid = true; break; // Stop at the first valid license } } } catch (const std::exception& e) { ansutilityLicenceValid = false; } } ANSUtilities::ANSUtilities() { _unlockCode = "ANSDRC.CB1122026_MEQCIFwO1IFQCG0BhZwsXFO68QUU6mDB5uge4duOsqOJanEyAiAB67ahqnXin4SRy0vIegISgbFlpldmbuS5gbU21GYVqA==";// "ANSDRC.CB1082025_Ax6P3M7F8B3d";// _fireBaseSessionToken = ""; _proxyHost = ""; _proxyPort = 0; _proxyUsername = ""; _proxyPassword = ""; _bProxy = false; } void ANSUtilities::CheckLicense() { std::lock_guard lock(_mutex); try { // Check once globally std::call_once(ansutilityLicenseOnceFlag, [this]() { VerifyGlobalANSUltilityLicense(_licenseKey); }); // Update this instance's local license flag _isLicenseValid = ansutilityLicenceValid; } catch (const std::exception& e) { this->_logger.LogFatal("ANSUtilities::CheckLicense. Error:", e.what(), __FILE__, __LINE__); } } void ANSUtilities::CheckUnlockCode() { std::lock_guard lock(_mutex); try { CkGlobal glob; _unlockCode = "ANSDRC.CB1122026_MEQCIFwO1IFQCG0BhZwsXFO68QUU6mDB5uge4duOsqOJanEyAiAB67ahqnXin4SRy0vIegISgbFlpldmbuS5gbU21GYVqA==";// "ANSDRC.CB1082025_Ax6P3M7F8B3d"; _isUnlockCodeValid = glob.UnlockBundle(_unlockCode.c_str()); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::CheckUnlockCode", glob.lastErrorText(), __FILE__, __LINE__); return; } int status = glob.get_UnlockStatus(); if (status != 2) { _logger.LogDebug("ANSUtilities::CheckUnlockCode", "Unlocked in trial mode.", __FILE__, __LINE__); } } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::CheckUnlockCode", e.what(), __FILE__, __LINE__); } } ANSUtilities::~ANSUtilities() { _fireBaseSessionToken = ""; } bool ANSUtilities::Initialize(const std::string& licenseKey) { std::lock_guard lock(_mutex); try { _licenseKey = licenseKey; CheckLicense(); CheckUnlockCode(); return _isLicenseValid && _isUnlockCodeValid; } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::Initialize", e.what(), __FILE__, __LINE__); return false; } } bool ANSUtilities::SetServerProxy(const std::string& proxyHost, int proxyPort, const std::string& proxyUsername, const std::string& proxyPassword) { std::lock_guard lock(_mutex); try { _proxyHost = proxyHost; _proxyPort = proxyPort; _proxyUsername = proxyUsername; _proxyPassword = proxyPassword; _bProxy = false; if (!_proxyHost.empty() && (_proxyPort > 0)) { _bProxy = true; } else { _bProxy = false; } return true; } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::SetServerProxy", e.what(), __FILE__, __LINE__); return false; } } std::string ANSUtilities::GetFirebaseCloudMessageAcccessToken(std::string privateKey) { std::lock_guard lock(_mutex); if (!_isLicenseValid) { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", "Error: Invalid license key", __FILE__, __LINE__); return "Error: Invalid license key"; } if (!_isUnlockCodeValid) { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", "Error: Invalid unlock code", __FILE__, __LINE__); return "Error: Invalid unlock code"; } try { auto currentTime = std::chrono::system_clock::now(); // Check if we need to generate a new token bool needNewToken = false; if (!tokenInitialized) { std::cout << "First time calling getToken(), generating initial token..." << std::endl; needNewToken = true; } else { // Calculate time difference in seconds since token was generated auto timeDiff = std::chrono::duration_cast(currentTime - tokenGeneratedTime); long secondsElapsed = timeDiff.count(); std::cout << "Time since token generated: " << secondsElapsed << " seconds" << std::endl; if (secondsElapsed >= TOKEN_EXPIRY_SECONDS) { std::cout << "Token expired (" << secondsElapsed << "s >= " << TOKEN_EXPIRY_SECONDS << "s), regenerating..." << std::endl; needNewToken = true; } else { long remainingTime = TOKEN_EXPIRY_SECONDS - secondsElapsed; std::cout << "Token still valid, " << remainingTime << " seconds remaining" << std::endl; } } if (needNewToken) { CkFileAccess fac; const char* jsonKey = "{" "\"type\": \"service_account\"," "\"project_id\": \"ansaiboxpushnotifications\"," "\"private_key_id\": \"62f7485c308b9ea613866c24c98736fec498d47d\"," "\"private_key\": \"-----BEGIN PRIVATE KEY-----\\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDSwXb/N4vPkANa\\nA7nwOTxS9NVCup/9mIdyR7FRYJNV8uHY7699I8LCCvG5rIhWGZ/Rb4Z9ocJKuuj9\\nRelsjTDEWeBU/o8ip41Ru8K3KlOO25HIVDckyhbmfDzzlf8Ham1HhOUZmfDUfQ2d\\n5YoUXflqoCyvOi8aqUgfcP9uZuIpEhyQvjqDfY0d0B36NoXpilFE8IuIlBsnpfZn\\nYkeHs/Cl6CDaKxGeUZmrqinyMH5f7m4Nz30V5s8Xdl4WZdoYhVatn1or57Zjy/zl\\ng+4rWeHRbYrBUJlMb8/7IaaZ7KuDkh0awEFIDvLuNvjXkaGKJT33vxKSsaH4yrhg\\nYiR5OVY3AgMBAAECggEADiUS5f0l4ofhWbS/UXqd7FlnSMO6wivvB0H9ih8ntFCJ\\nTOSFTCpOw3Q1lgcY3WJ54fYQujTVk+togLsk9/af68W2cy3kkGhbaT1nS6DJG+Dr\\nr1zLmKoBkHWNJ7IM/EPt0qt+LtIwoipEdDD4K/bEqx3V8eq/R5RN9WJBmnjIPAZO\\nXYGtTBu66yTjMVX9AFqYGJwaW96mHAi3lI5Mso5wTmFA8tSBiWmiYgpDDUNzu+4w\\nPnbDJabMbv4xnC6UtiqLIvv+P3BWWyLz0bzZ7W9P2fGK9Rz04leTXZlNcfC/IIAr\\nXDPVZfF7E5Wici53Cwc/QnxoCVH9n9hqsyTTUrKYbQKBgQD9WuCLVZRwKnAsW2Wx\\nZjh8Z92aGjIoc/lJTYaFsYGT7Hx496izhmg18kUillUDe/L9gHuDJPIMv89irjV1\\n07jN+z+tANyFT+h/NHCSxreG8FDbo8F88snekMEsBym3CicE/P6aWVx+lIig8rPS\\nHAqA1WOwdFzto/rG4zFKIiajYwKBgQDU9LxgERHwoy8mt2U5h/hg4oiKlycFJCFV\\nsgEqhVFN7Cs8jlov4tJh9863tVeYYGSKrP1HS9dVUE+7VY2qgPbyAtR5QZeHIV+b\\nzMx8o4HVLN4ffmld+/mYiAzIQiQeZOoC0mczakQpRDE8sghQQoYLwEcKXcTkLr75\\nk1XIpT4cHQKBgQCmMSzGeZbrlQsMLdAhdHptMPzuj2yDmL/X0+EAZhYn4KMt/tdN\\nHEfTy16Kd67AoFge7l8XAe89ab0ycDBlYEMD62IzrDL7yBUtDEskHPJas912lo7f\\n1auSMcZliTVV+nTqEsM4oJHJ/sk5Oru2gepp5JCGOW6T/FMOkA3PIWPTHQKBgQCG\\n456Om0Fp03OCaphLoLzLYbJrVuL4drJGvcHPVTLy0K1yZhjqTBpGw9jEtLEPa79D\\nt9+W0YtMFtrqJn7diWLiWLiNNebtSU5uOYMtT8Rla04nVMMZLQoke8jc8EhAmFtB\\n/lQwVRdnrDIj6AEsFXci6mAVSN/2SUXegFzOAx0cYQKBgBYCGGKWd/EFvszO5VS6\\nnegR3fpx4GRShA4iWfbQhPcjPunKthUAUguN4m+FfQuSA6xaBsz+om9hRiSCHe2l\\nGio/U7z2QYznnl/furGXEhS6yE+u3cSN82N0PV/c4XY0DUqKycE6cx9GVTOmx7NP\\n897fh7f103RrGgIRivtM1g3g\\n-----END PRIVATE KEY-----\\n\"," "\"client_email\": \"firebase-adminsdk-tcw8f@ansaiboxpushnotifications.iam.gserviceaccount.com\"," "\"client_id\": \"108921284506387607836\"," "\"auth_uri\": \"https://accounts.google.com/o/oauth2/auth\"," "\"token_uri\": \"https://oauth2.googleapis.com/token\"," "\"auth_provider_x509_cert_url\": \"https://www.googleapis.com/oauth2/v1/certs\"," "\"client_x509_cert_url\": \"https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-tcw8f%40ansaiboxpushnotifications.iam.gserviceaccount.com\"," "\"universe_domain\": \"googleapis.com\"" "}"; if (!_isLicenseValid) { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", "Error: Invalid license key", __FILE__, __LINE__); _fireBaseSessionToken = ""; return "Error: Invalid license key"; } if (!_isUnlockCodeValid) { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", "Error: Invalid unlock code", __FILE__, __LINE__); _fireBaseSessionToken = ""; return "Error: Invalid unlock code"; } if (privateKey != "62f7485c308b9ea613866c24c98736fec498d47d") { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", "Error: Invalid private key", __FILE__, __LINE__); _fireBaseSessionToken = ""; return "Error: Invalid private key"; } CkAuthGoogle gAuth; gAuth.put_JsonKey(jsonKey); gAuth.put_Scope("https://www.googleapis.com/auth/cloud-platform"); gAuth.put_ExpireNumSeconds(TOKEN_EXPIRY_SECONDS); gAuth.put_SubEmailAddress(""); CkSocket tlsSock; bool success = tlsSock.Connect("www.googleapis.com", 443, true, 5000); if (success != true) { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", tlsSock.lastErrorText(), __FILE__, __LINE__); _fireBaseSessionToken = ""; return std::string("Error:") + tlsSock.lastErrorText(); } success = gAuth.ObtainAccessToken(tlsSock); if (success != true) { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", gAuth.lastErrorText(), __FILE__, __LINE__); _fireBaseSessionToken = ""; return std::string("Error:") + tlsSock.lastErrorText(); } _fireBaseSessionToken = gAuth.accessToken(); tokenGeneratedTime = currentTime; // Reset the time when token is generated tokenInitialized = true; } return _fireBaseSessionToken; } catch (std::exception& e) { this->_logger.LogFatal("ANSUtilities::GetFirebaseCloudMessageAcccessToken()", e.what(), __FILE__, __LINE__); _fireBaseSessionToken = ""; return "Error: " + std::string(e.what()); } } std::string ANSUtilities::CreateAWSSNSTopic(const std::string& topicName) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::CreateAWSSNSTopic", "Error: Invalid unlock code", __FILE__, __LINE__); return "Error: Invalid unlock code"; } if (!_isLicenseValid) { _logger.LogFatal("ANSUtilities::CreateAWSSNSTopic", "Error: Invalid license key", __FILE__, __LINE__); return "Error: Invalid license key"; } try { CkRest _rest; _rest.AddQueryParam("Action", "CreateTopic"); _rest.AddQueryParam("Name", topicName.c_str()); const char* responseXml = _rest.fullRequestNoBody("GET", "/"); if (!_rest.get_LastMethodSuccess()) { _logger.LogFatal("ANSUtilities::CreateAWSSNSTopic", _rest.lastErrorText(), __FILE__, __LINE__); return "Error: " + std::string(_rest.lastErrorText()); } if (_rest.get_ResponseStatusCode() != 200) { _logger.LogError("ANSUtilities::CreateAWSSNSTopic", _rest.responseHeader(), __FILE__, __LINE__); return "Error: " + std::string(_rest.responseHeader()); } CkXml xml; xml.LoadXml(responseXml); return xml.chilkatPath("CreateTopicResult|TopicArn|*"); } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::CreateAWSSNSTopic", e.what(), __FILE__, __LINE__); return "Error: " + std::string(e.what()); } } bool ANSUtilities::DeleteAWSSNSTopic(const std::string& topicARN) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::DeleteAWSSNSTopic", "Error: Invalid unlock code", __FILE__, __LINE__); return false; } if (!_isLicenseValid) { _logger.LogFatal("ANSUtilities::DeleteAWSSNSTopic", "Error: Invalid license key", __FILE__, __LINE__); return false; } try { CkRest _rest; _rest.AddQueryParam("Action", "DeleteTopic"); _rest.AddQueryParam("TopicArn", topicARN.c_str()); const char* responseXml = _rest.fullRequestNoBody("GET", "/"); if (!_rest.get_LastMethodSuccess()) { _logger.LogFatal("ANSUtilities::DeleteAWSSNSTopic", _rest.lastErrorText(), __FILE__, __LINE__); return false; } if (_rest.get_ResponseStatusCode() != 200) { _logger.LogError("ANSUtilities::DeleteAWSSNSTopic", _rest.responseHeader(), __FILE__, __LINE__); return false; } return true; } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::DeleteAWSSNSTopic", e.what(), __FILE__, __LINE__); return false; } } std::string ANSUtilities::SubcribeSMSPhoneNumber(const std::string& topicARN, const std::string& phoneNumber) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::SubscribeSMSPhoneNumber", "Error: Invalid unlock code", __FILE__, __LINE__); return "Error: Invalid unlock code"; } if (!_isLicenseValid) { _logger.LogFatal("ANSUtilities::SubscribeSMSPhoneNumber", "Error: Invalid license key", __FILE__, __LINE__); return "Error: Invalid license key"; } try { CkRest _rest; _rest.AddQueryParam("Action", "Subscribe"); _rest.AddQueryParam("Endpoint", phoneNumber.c_str()); // Phone number in E.164 format _rest.AddQueryParam("Protocol", "sms"); _rest.AddQueryParam("TopicArn", topicARN.c_str()); const char* responseXml = _rest.fullRequestNoBody("GET", "/"); if (!_rest.get_LastMethodSuccess()) { _logger.LogError("ANSUtilities::SubscribeSMSPhoneNumber", _rest.lastErrorText(), __FILE__, __LINE__); return "Error: " + std::string(_rest.lastErrorText()); } if (_rest.get_ResponseStatusCode() != 200) { _logger.LogError("ANSUtilities::SubscribeSMSPhoneNumber", _rest.responseHeader(), __FILE__, __LINE__); return "Error: " + std::string(_rest.responseHeader()); } CkXml xml; xml.LoadXml(responseXml); return xml.chilkatPath("SubscribeResult|SubscriptionArn|*"); } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::SubscribeSMSPhoneNumber", e.what(), __FILE__, __LINE__); return "Error: " + std::string(e.what()); } } std::string ANSUtilities::SubscribeEmailAddress(const std::string& topicARN, const std::string& emailAddress) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::SubscribeEmailAddress", "Error: Invalid unlock code", __FILE__, __LINE__); return "Error: Invalid unlock code"; } if (!_isLicenseValid) { _logger.LogFatal("ANSUtilities::SubscribeEmailAddress", "Error: Invalid license key", __FILE__, __LINE__); return "Error: Invalid license key"; } try { CkRest _rest; _rest.AddQueryParam("Action", "Subscribe"); _rest.AddQueryParam("Endpoint", emailAddress.c_str()); _rest.AddQueryParam("Protocol", "email"); _rest.AddQueryParam("TopicArn", topicARN.c_str()); const char* responseXml = _rest.fullRequestNoBody("GET", "/"); if (!_rest.get_LastMethodSuccess()) { _logger.LogError("ANSUtilities::SubscribeEmailAddress", _rest.lastErrorText(), __FILE__, __LINE__); return "Error: " + std::string(_rest.lastErrorText()); } if (_rest.get_ResponseStatusCode() != 200) { _logger.LogError("ANSUtilities::SubscribeEmailAddress", _rest.responseHeader(), __FILE__, __LINE__); return "Error: " + std::string(_rest.responseHeader()); } CkXml xml; xml.LoadXml(responseXml); return xml.chilkatPath("SubscribeResult|SubscriptionArn|*"); // Usually "pending confirmation" } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::SubscribeEmailAddress", e.what(), __FILE__, __LINE__); return "Error: " + std::string(e.what()); } } std::string ANSUtilities::SendMessageToTopic(const std::string& topicARN, const std::string& subjectContent, const std::string& messageContent) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::SendMessageToTopic", "Error: Invalid unlock code", __FILE__, __LINE__); return "Error: Invalid unlock code"; } if (!_isLicenseValid) { _logger.LogFatal("ANSUtilities::SendMessageToTopic", "Error: Invalid license key", __FILE__, __LINE__); return "Error: Invalid license key"; } try { CkRest _rest; _rest.AddQueryParam("Action", "Publish"); _rest.AddQueryParam("TopicArn", topicARN.c_str()); _rest.AddQueryParam("Subject", subjectContent.c_str()); // Subject line for emails _rest.AddQueryParam("Message", messageContent.c_str()); // The message body const char* responseXml = _rest.fullRequestNoBody("GET", "/"); if (!_rest.get_LastMethodSuccess()) { _logger.LogError("ANSUtilities::SendMessageToTopic", _rest.lastErrorText(), __FILE__, __LINE__); return "Error: " + std::string(_rest.lastErrorText()); } if (_rest.get_ResponseStatusCode() != 200) { _logger.LogError("ANSUtilities::SendMessageToTopic", _rest.responseHeader(), __FILE__, __LINE__); return "Error: " + std::string(_rest.responseHeader()); } CkXml xml; xml.LoadXml(responseXml); return xml.chilkatPath("PublishResult|MessageId|*"); // Return the MessageId } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::SendMessageToTopic", e.what(), __FILE__, __LINE__); return "Error: " + std::string(e.what()); } } std::string ANSUtilities::SendMessageToPhoneNumber(const std::string& phoneNumber, const std::string& messageContent) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::SendMessageToPhoneNumber", "Error: Invalid unlock code", __FILE__, __LINE__); return "Error: Invalid unlock code"; } if (!_isLicenseValid) { _logger.LogFatal("ANSUtilities::SendMessageToPhoneNumber", "Error: Invalid license key", __FILE__, __LINE__); return "Error: Invalid license key"; } try { CkRest _rest; _rest.AddQueryParam("Action", "Publish"); _rest.AddQueryParam("PhoneNumber", phoneNumber.c_str()); _rest.AddQueryParam("Message", messageContent.c_str()); const char* responseXml = _rest.fullRequestNoBody("GET", "/"); if (!_rest.get_LastMethodSuccess()) { _logger.LogError("ANSUtilities::SendMessageToPhoneNumber", _rest.lastErrorText(), __FILE__, __LINE__); return "Error: " + std::string(_rest.lastErrorText()); } if (_rest.get_ResponseStatusCode() != 200) { _logger.LogError("ANSUtilities::SendMessageToPhoneNumber", _rest.responseHeader(), __FILE__, __LINE__); return "Error: " + std::string(_rest.responseHeader()); } CkXml xml; xml.LoadXml(responseXml); return xml.chilkatPath("PublishResult|MessageId|*"); // Return the MessageId } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::SendMessageToPhoneNumber", e.what(), __FILE__, __LINE__); return "Error: " + std::string(e.what()); } } std::string ANSUtilities::ListAWSSNSTopic() { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::ListAWSSNSTopic", "Error: Invalid unlock code", __FILE__, __LINE__); return "Error: Invalid unlock code"; } if (!_isLicenseValid) { _logger.LogFatal("ANSUtilities::ListAWSSNSTopic", "Error: Invalid license key", __FILE__, __LINE__); return "Error: Invalid license key"; } try { CkRest _rest; _rest.AddQueryParam("Action", "ListTopics"); const char* responseXml = _rest.fullRequestNoBody("GET", "/"); if (!_rest.get_LastMethodSuccess()) { _logger.LogError("ANSUtilities::ListAWSSNSTopic", _rest.lastErrorText(), __FILE__, __LINE__); return "Error: " + std::string(_rest.lastErrorText()); } if (_rest.get_ResponseStatusCode() != 200) { _logger.LogError("ANSUtilities::ListAWSSNSTopic", _rest.responseHeader(), __FILE__, __LINE__); return "Error: " + std::string(_rest.responseHeader()); } CkXml xml; xml.LoadXml(responseXml); // Move to Topics list xml.chilkatPath("ListTopicsResult|Topics|$"); int numTopics = xml.get_NumChildren(); std::vector topics; topics.reserve(numTopics); // Slight optimization for (int i = 0; i < numTopics; ++i) { xml.GetChild2(i); topics.emplace_back(xml.getChildContent("TopicArn")); xml.GetParent2(); } if (topics.empty()) { _logger.LogError("ANSUtilities::ListAWSSNSTopic", "No topics found", __FILE__, __LINE__); return ""; } // Concatenate topics with ';' std::string topicsStr; for (size_t i = 0; i < topics.size(); ++i) { topicsStr += topics[i]; if (i + 1 != topics.size()) { topicsStr += ";"; } } return topicsStr; } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::ListAWSSNSTopic", e.what(), __FILE__, __LINE__); return "Error: " + std::string(e.what()); } } bool ANSUtilities::AuthenticateGCS(const std::string& jsonKeyFile) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::AuthenticateGCS", "Error: Invalid unlock code", __FILE__, __LINE__); return false; } if (_isAuthenticated) { return true; } try { _authGoogle.put_JsonKey(jsonKeyFile.c_str()); _authGoogle.put_Scope("https://www.googleapis.com/auth/cloud-platform"); _authGoogle.put_ExpireNumSeconds(3600); // 1 hour token _authGoogle.put_SubEmailAddress(""); CkSocket tlsSock; bool success = tlsSock.Connect("www.googleapis.com", 443, true, 5000); if (!success) { _logger.LogError("ANSUtilities::AuthenticateGCS", tlsSock.lastErrorText(), __FILE__, __LINE__); return false; } success = _authGoogle.ObtainAccessToken(tlsSock); if (!success) { _logger.LogError("ANSUtilities::AuthenticateGCS", _authGoogle.lastErrorText(), __FILE__, __LINE__); return false; } if (!_authGoogle.accessToken()) { _logger.LogError("ANSUtilities::AuthenticateGCS", _authGoogle.lastErrorText(), __FILE__, __LINE__); return false; } _isAuthenticated = true; return true; } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::AuthenticateGCS", e.what(), __FILE__, __LINE__); return false; } } bool ANSUtilities::UploadMatToGCS(const std::string& bucketName, const std::string& objectName, const cv::Mat& image) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", "Error: Invalid unlock code", __FILE__, __LINE__); return false; } if (!_isAuthenticated) { _logger.LogError("ANSUtilities::UploadMatToGCS", "Not authenticated. Call AuthenticateGCS() first.", __FILE__, __LINE__); return false; } try { CkRest rest; CkSocket _gcsSocket; std::string gcsHost = "www.googleapis.com"; bool bTls = true; bool autoReconnect = true; int port = 443; int maxWaitMs = 15000; if (_bProxy) { if (!_proxyHost.empty() && (_proxyPort > 0)) { _gcsSocket.put_HttpProxyHostname(_proxyHost.c_str()); _gcsSocket.put_HttpProxyPort(_proxyPort); _gcsSocket.put_HttpProxyUsername(_proxyUsername.c_str()); _gcsSocket.put_HttpProxyPassword(_proxyPassword.c_str()); _gcsSocket.put_HttpProxyForHttp(true); if (!_gcsSocket.Connect(gcsHost.c_str(), port, bTls, maxWaitMs)) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", _gcsSocket.lastErrorText(), __FILE__, __LINE__); return false; } // Bind socket to rest if (!rest.UseConnection(_gcsSocket, autoReconnect)) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", rest.lastErrorText(), __FILE__, __LINE__); return false; } rest.SetAuthGoogle(_authGoogle); } else { _logger.LogFatal("ANSUtilities::UploadMatToGCS", "Invalid proxy hostname and port", __FILE__, __LINE__); return false; } } else { // No proxy rest.SetAuthGoogle(_authGoogle); // Connect to Google Cloud Storage REST API if (!rest.Connect(gcsHost.c_str(), port, bTls, autoReconnect)) { _logger.LogError("ANSUtilities::UploadMatToGCS", rest.lastErrorText(), __FILE__, __LINE__); return false; } } // Convert cv::Mat to JPEG binary std::vector jpegBuffer; std::vector compressionParams = { cv::IMWRITE_JPEG_QUALITY, 90 }; if (!cv::imencode(".jpg", image, jpegBuffer, compressionParams)) { _logger.LogError("ANSUtilities::UploadMatToGCS", "Failed to encode cv::Mat as JPEG.", __FILE__, __LINE__); return false; } // Convert std::vector to CkByteData CkByteData jpegBytes; if (!jpegBuffer.empty()) { jpegBytes.append2(jpegBuffer.data(), static_cast(jpegBuffer.size())); } // Prepare the HTTP request to upload the file std::string urlPath = "/upload/storage/v1/b/" + bucketName + "/o?uploadType=media&name=" + objectName; rest.AddHeader("Content-Type", "image/jpeg"); // Upload the JPEG data to GCS std::string jsonResponse = rest.fullRequestBinary("POST", urlPath.c_str(), jpegBytes); if (!rest.get_LastMethodSuccess()) { _logger.LogError("ANSUtilities::UploadMatToGCS", rest.lastErrorText(), __FILE__, __LINE__); return false; } int statusCode = rest.get_ResponseStatusCode(); if (statusCode != 200) { _logger.LogError("ANSUtilities::UploadMatToGCS", rest.responseHeader(), __FILE__, __LINE__); return false; } _logger.LogDebug("ANSUtilities::UploadMatToGCS", "Upload successful. Status Code: " + std::to_string(statusCode), __FILE__, __LINE__); return true; } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", e.what(), __FILE__, __LINE__); return false; } } bool ANSUtilities::UploadMatToGCS(const std::string& bucketName, const std::string& objectName, unsigned char* jpeg_string, int32 bufferLength) { std::lock_guard lock(_mutex); if (!_isUnlockCodeValid) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", "Error: Invalid unlock code", __FILE__, __LINE__); return false; } if (!_isAuthenticated) { _logger.LogError("ANSUtilities::UploadMatToGCS", "Not authenticated. Call AuthenticateGCS() first.", __FILE__, __LINE__); return false; } if(bufferLength<=0) { _logger.LogError("ANSUtilities::UploadMatToGCS", "Invalid buffer length", __FILE__, __LINE__); return false; } try { CkRest rest; CkSocket _gcsSocket; std::string gcsHost = "www.googleapis.com"; bool bTls = true; bool autoReconnect = true; int port = 443; int maxWaitMs = 15000; if (_bProxy) { if (!_proxyHost.empty() && (_proxyPort > 0)) { _gcsSocket.put_HttpProxyHostname(_proxyHost.c_str()); _gcsSocket.put_HttpProxyPort(_proxyPort); _gcsSocket.put_HttpProxyUsername(_proxyUsername.c_str()); _gcsSocket.put_HttpProxyPassword(_proxyPassword.c_str()); _gcsSocket.put_HttpProxyForHttp(true); if (!_gcsSocket.Connect(gcsHost.c_str(), port, bTls, maxWaitMs)) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", _gcsSocket.lastErrorText(), __FILE__, __LINE__); return false; } // Bind socket to rest if (!rest.UseConnection(_gcsSocket, autoReconnect)) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", rest.lastErrorText(), __FILE__, __LINE__); return false; } rest.SetAuthGoogle(_authGoogle); } else { _logger.LogFatal("ANSUtilities::UploadMatToGCS", "Invalid proxy hostname and port", __FILE__, __LINE__); return false; } } else { // No proxy rest.SetAuthGoogle(_authGoogle); // Connect to Google Cloud Storage REST API if (!rest.Connect(gcsHost.c_str(), port, bTls, autoReconnect)) { _logger.LogError("ANSUtilities::UploadMatToGCS", rest.lastErrorText(), __FILE__, __LINE__); return false; } } // Convert std::vector to CkByteData CkByteData jpegBytes; jpegBytes.append2(jpeg_string, static_cast(bufferLength)); // Prepare the HTTP request to upload the file std::string urlPath = "/upload/storage/v1/b/" + bucketName + "/o?uploadType=media&name=" + objectName; rest.AddHeader("Content-Type", "image/jpeg"); // Upload the JPEG data to GCS std::string jsonResponse = rest.fullRequestBinary("POST", urlPath.c_str(), jpegBytes); if (!rest.get_LastMethodSuccess()) { _logger.LogError("ANSUtilities::UploadMatToGCS", rest.lastErrorText(), __FILE__, __LINE__); return false; } int statusCode = rest.get_ResponseStatusCode(); if (statusCode != 200) { _logger.LogError("ANSUtilities::UploadMatToGCS", rest.responseHeader(), __FILE__, __LINE__); return false; } _logger.LogDebug("ANSUtilities::UploadMatToGCS", "Upload successful. Status Code: " + std::to_string(statusCode), __FILE__, __LINE__); return true; } catch (const std::exception& e) { _logger.LogFatal("ANSUtilities::UploadMatToGCS", e.what(), __FILE__, __LINE__); return false; } } bool ANSUtilities::SendEmail(const std::string& smtpServer, int port, const std::string& userName, const std::string& password, const std::string& subjectContent, const std::string& bodyHTMLContent, const std::string& bodyTextContent, const std::string& fromEmailSender, const std::vector& toEmails, const std::vector& ccEmails, const std::vector& bccEmails) { std::unique_lock lock(timeImageMutex, std::defer_lock); if (!lock.try_lock_for(std::chrono::milliseconds(45000))) { std::cerr << "Error: Mutex timeout in ANSUtilities::SendEmail!" << std::endl; return false; } if (!CheckUnlockCode_S()) { return false; } try { // The mailman object is used for sending and receiving email. CkMailMan mailman; mailman.put_SmtpHost(smtpServer.c_str()); mailman.put_SmtpPort(port); mailman.put_StartTLS(true);//STARTTLS // Set the SMTP login/password mailman.put_SmtpUsername(userName.c_str()); mailman.put_SmtpPassword(password.c_str()); CkEmail email; if (!bodyHTMLContent.empty()) { CkMht mht; mht.put_UseCids(true); const char* mime = 0; mime = mht.htmlToEML(bodyHTMLContent.c_str()); bool setmime = email.SetFromMimeText(mime); email.ConvertInlineImages(); } email.put_Subject(subjectContent.c_str()); if (!bodyTextContent.empty()) email.put_Body(bodyTextContent.c_str()); email.put_From(fromEmailSender.c_str()); for (const auto& toEmail : toEmails) { email.AddTo("", toEmail.c_str()); } for (const auto& ccEmail : ccEmails) { email.AddCC("", ccEmail.c_str()); } for (const auto& bccEmail : bccEmails) { email.AddBcc("", bccEmail.c_str()); } bool success = mailman.SendEmail(email); if (success != true) { return false; } success = mailman.CloseSmtpConnection(); if (success != true) { } return success; } catch (const std::exception& e) { return false; } } bool ANSUtilities::CheckUnlockCode_S() { static std::once_flag unlockOnceFlag; static bool isUnlockValid = false; try { std::call_once(unlockOnceFlag, []() { CkGlobal glob; const std::string unlockCode = "ANSDRC.CB1122026_MEQCIFwO1IFQCG0BhZwsXFO68QUU6mDB5uge4duOsqOJanEyAiAB67ahqnXin4SRy0vIegISgbFlpldmbuS5gbU21GYVqA==";// "ANSDRC.CB1082025_Ax6P3M7F8B3d"; if (glob.UnlockBundle(unlockCode.c_str()) && glob.get_UnlockStatus() == 2) { isUnlockValid = true; } }); return isUnlockValid; } catch (...) { return false; } } std::string ANSUtilities::AESEncryption(const std::string& inputString, const std::string& inputKey) { if (!CheckUnlockCode_S()) { return ""; } try { CkCrypt2 crypt; // AES is also known as Rijndael. crypt.put_CryptAlgorithm("aes"); // CipherMode may be "ecb", "cbc", "ofb", "cfb", "gcm", etc. crypt.put_CipherMode("cbc"); // KeyLength may be 128, 192, 256 crypt.put_KeyLength(256); // The padding scheme determines the contents of the bytes // that are added to pad the result to a multiple of the // encryption algorithm's block size. AES has a block // size of 16 bytes, so encrypted output is always // a multiple of 16. crypt.put_PaddingScheme(0); // 0 = RFC 1423 padding scheme // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.put_EncodingMode("base64"); // Ensure inputKey is exactly 16 characters for IV. std::string ivKey = inputKey.substr(0, std::min(16, inputKey.size())); if (ivKey.size() < 16) { ivKey.append(16 - ivKey.size(), 'A'); // Pad with spaces if less than 16 characters } crypt.SetEncodedIV(ivKey.c_str(), "ascii"); // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. std::string secreteKey = inputKey.substr(0, std::min(32, inputKey.size())); if (secreteKey.size() < 32) { secreteKey.append(32 - secreteKey.size(), 'A'); // Pad with spaces if less than 32 characters } crypt.SetEncodedKey(secreteKey.c_str(), "ascii"); const char* encStr = crypt.encryptStringENC(inputString.c_str()); return encStr ? std::string(encStr) : std::string(); } catch (const std::exception& e) { // Optional: If you want logging, consider static logging in static functions return ""; } } std::string ANSUtilities::AESDecryption(const std::string& encryptString, const std::string& inputKey) { if (!CheckUnlockCode_S()) { return ""; } try { CkCrypt2 crypt; // AES is also known as Rijndael. crypt.put_CryptAlgorithm("aes"); // CipherMode may be "ecb", "cbc", "ofb", "cfb", "gcm", etc. crypt.put_CipherMode("cbc"); // KeyLength may be 128, 192, 256 crypt.put_KeyLength(256); // The padding scheme determines the contents of the bytes // that are added to pad the result to a multiple of the // encryption algorithm's block size. AES has a block // size of 16 bytes, so encrypted output is always // a multiple of 16. crypt.put_PaddingScheme(0); // 0 = RFC 1423 padding scheme // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.put_EncodingMode("base64"); // Ensure inputKey is exactly 16 characters for IV. std::string ivKey = inputKey.substr(0, std::min(16, inputKey.size())); if (ivKey.size() < 16) { ivKey.append(16 - ivKey.size(), 'A'); // Pad with spaces if less than 16 characters } crypt.SetEncodedIV(ivKey.c_str(), "ascii"); // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. std::string secreteKey = inputKey.substr(0, std::min(32, inputKey.size())); if (secreteKey.size() < 32) { secreteKey.append(32 - secreteKey.size(), 'A'); // Pad with spaces if less than 32 characters } crypt.SetEncodedKey(secreteKey.c_str(), "ascii"); const char* decStr = crypt.decryptStringENC(encryptString.c_str()); return decStr ? std::string(decStr) : std::string(); } catch (const std::exception& e) { // Optional: If you want logging, consider static logging in static functions return ""; } } std::string ANSUtilities::MD5HashFile(const std::string& inputFilePath) { if (!CheckUnlockCode_S()) { return ""; } try { CkCrypt2 crypt; // Set the name of the hash algorithm. // Other choices include "sha1", "sha256", "sha384", "sha512", "md2", "md5", and "haval". crypt.put_HashAlgorithm("md5"); // EncodingMode specifies the encoding of the hash output. // It may be "hex", "url", "base64", or "quoted-printable". crypt.put_EncodingMode("hex"); // Files of any type may be hashed -- it doesn't matter // if the file is binary or text... const char* hashStr = nullptr; hashStr = crypt.hashFileENC(inputFilePath.c_str()); return hashStr ? std::string(hashStr) : std::string(); } catch (const std::exception& e) { // Optional: If you want logging, consider static logging in static functions return ""; } } bool ANSUtilities::RestartPC() { try { return system("shutdown /r /t 0") == 0; } catch (...) { return false; } } std::string ANSUtilities::DecodeJsonUnicodeToUTF16LE(const std::string& escapedStr) { std::string result; result.reserve(escapedStr.size() * 2); size_t i = 0; while (i < escapedStr.size()) { if (i + 5 < escapedStr.size() && escapedStr[i] == '\\' && escapedStr[i + 1] == 'u') { char hex[5] = { escapedStr[i + 2], escapedStr[i + 3], escapedStr[i + 4], escapedStr[i + 5], 0 }; uint16_t codepoint = (uint16_t)strtoul(hex, nullptr, 16); result += static_cast(codepoint & 0xFF); result += static_cast((codepoint >> 8) & 0xFF); i += 6; } else { result += escapedStr[i]; result += '\0'; i++; } } return result; } std::string ANSUtilities::ConvertUTF16LEToUTF8(const char* utf16leBytes, int byteLen) { #ifdef _WIN32 if (!utf16leBytes || byteLen <= 0) return ""; int wideLen = byteLen / (int)sizeof(wchar_t); const wchar_t* wideStr = reinterpret_cast(utf16leBytes); // First call: get required UTF-8 buffer size int utf8Len = WideCharToMultiByte(CP_UTF8, 0, wideStr, wideLen, nullptr, 0, nullptr, nullptr); if (utf8Len <= 0) return ""; std::string utf8Str(utf8Len, 0); WideCharToMultiByte(CP_UTF8, 0, wideStr, wideLen, &utf8Str[0], utf8Len, nullptr, nullptr); return utf8Str; #else return std::string(utf16leBytes, byteLen); #endif } std::string ANSUtilities::ConvertUTF8ToUTF16LE(const std::string& utf8Str) { #ifdef _WIN32 if (utf8Str.empty()) return ""; int wideLen = MultiByteToWideChar(CP_UTF8, 0, utf8Str.c_str(), (int)utf8Str.size(), nullptr, 0); if (wideLen <= 0) return ""; std::wstring wideStr(wideLen, 0); MultiByteToWideChar(CP_UTF8, 0, utf8Str.c_str(), (int)utf8Str.size(), &wideStr[0], wideLen); const char* rawBytes = reinterpret_cast(wideStr.data()); return std::string(rawBytes, wideLen * sizeof(wchar_t)); #else return utf8Str; #endif } std::vector ANSUtilities::RepairLabVIEWUTF16LE(const unsigned char* data, int len) { std::vector repaired; if (!data || len <= 0) return repaired; repaired.reserve(len + 32); // Helper: emit a BMP codepoint as UTF-16LE pair auto emitU16 = [&](uint16_t cp) { repaired.push_back(static_cast(cp & 0xFF)); repaired.push_back(static_cast((cp >> 8) & 0xFF)); }; for (int i = 0; i < len; ) { unsigned char b = data[i]; // --- 1. Detect embedded UTF-8 multi-byte sequences --- // LabVIEW text controls may mix UTF-8 encoded characters into a // UTF-16LE stream. UTF-8 lead bytes (C2-F4) followed by valid // continuation bytes (80-BF) are a strong signal. // We decode the UTF-8 codepoint and re-encode as UTF-16LE. // 2-byte UTF-8: 110xxxxx 10xxxxxx (U+0080 .. U+07FF) if (b >= 0xC2 && b <= 0xDF && i + 1 < len) { unsigned char b1 = data[i + 1]; if ((b1 & 0xC0) == 0x80) { uint32_t cp = ((b & 0x1F) << 6) | (b1 & 0x3F); emitU16(static_cast(cp)); i += 2; continue; } } // 3-byte UTF-8: 1110xxxx 10xxxxxx 10xxxxxx (U+0800 .. U+FFFF) if (b >= 0xE0 && b <= 0xEF && i + 2 < len) { unsigned char b1 = data[i + 1]; unsigned char b2 = data[i + 2]; if ((b1 & 0xC0) == 0x80 && (b2 & 0xC0) == 0x80) { uint32_t cp = ((b & 0x0F) << 12) | ((b1 & 0x3F) << 6) | (b2 & 0x3F); // Reject overlong encodings and surrogates if (cp >= 0x0800 && (cp < 0xD800 || cp > 0xDFFF)) { emitU16(static_cast(cp)); i += 3; continue; } } } // 4-byte UTF-8: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx (U+10000 .. U+10FFFF) if (b >= 0xF0 && b <= 0xF4 && i + 3 < len) { unsigned char b1 = data[i + 1]; unsigned char b2 = data[i + 2]; unsigned char b3 = data[i + 3]; if ((b1 & 0xC0) == 0x80 && (b2 & 0xC0) == 0x80 && (b3 & 0xC0) == 0x80) { uint32_t cp = ((b & 0x07) << 18) | ((b1 & 0x3F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F); if (cp >= 0x10000 && cp <= 0x10FFFF) { // Surrogate pair cp -= 0x10000; emitU16(static_cast(0xD800 + (cp >> 10))); emitU16(static_cast(0xDC00 + (cp & 0x3FF))); i += 4; continue; } } } // --- 2. Normal UTF-16LE pair (low byte + 0x00 high byte) --- if (i + 1 < len && data[i + 1] == 0x00) { repaired.push_back(data[i]); repaired.push_back(0x00); i += 2; } // --- 3. Lone space byte — LabVIEW dropped the 0x00 high byte --- else if (b == 0x20 && (i + 1 >= len || data[i + 1] != 0x00)) { repaired.push_back(0x20); repaired.push_back(0x00); i += 1; } // --- 4. Non-ASCII UTF-16LE pair (e.g. ễ = C5 1E) --- else if (i + 1 < len) { repaired.push_back(data[i]); repaired.push_back(data[i + 1]); i += 2; } // --- 5. Trailing odd byte — skip --- else { i++; } } return repaired; } bool ANSUtilities::IsValidUTF8(const unsigned char* data, int len) { if (!data || len <= 0) return false; bool hasMultiByte = false; for (int i = 0; i < len; ) { unsigned char b = data[i]; if (b <= 0x7F) { // ASCII — valid, but alone doesn't prove UTF-8 i++; } else if (b >= 0xC2 && b <= 0xDF) { // 2-byte sequence if (i + 1 >= len || (data[i + 1] & 0xC0) != 0x80) return false; hasMultiByte = true; i += 2; } else if (b >= 0xE0 && b <= 0xEF) { // 3-byte sequence if (i + 2 >= len || (data[i + 1] & 0xC0) != 0x80 || (data[i + 2] & 0xC0) != 0x80) return false; uint32_t cp = ((b & 0x0F) << 12) | ((data[i + 1] & 0x3F) << 6) | (data[i + 2] & 0x3F); if (cp < 0x0800 || (cp >= 0xD800 && cp <= 0xDFFF)) return false; // overlong or surrogate hasMultiByte = true; i += 3; } else if (b >= 0xF0 && b <= 0xF4) { // 4-byte sequence if (i + 3 >= len || (data[i + 1] & 0xC0) != 0x80 || (data[i + 2] & 0xC0) != 0x80 || (data[i + 3] & 0xC0) != 0x80) return false; uint32_t cp = ((b & 0x07) << 18) | ((data[i + 1] & 0x3F) << 12) | ((data[i + 2] & 0x3F) << 6) | (data[i + 3] & 0x3F); if (cp < 0x10000 || cp > 0x10FFFF) return false; hasMultiByte = true; i += 4; } else { return false; // invalid lead byte (C0, C1, F5-FF) } } // Only confirm UTF-8 if we found at least one multi-byte sequence. // Pure ASCII is ambiguous — let the caller decide. return hasMultiByte; } std::string ANSUtilities::ConvertUTF16LEToUnicodeEscapes(const char* utf16leBytes, int byteLen) { if (!utf16leBytes || byteLen <= 0) return ""; int offset = 0; // Strip BOM (FF FE) if present if (byteLen >= 2 && static_cast(utf16leBytes[0]) == 0xFF && static_cast(utf16leBytes[1]) == 0xFE) { offset = 2; } int remaining = byteLen - offset; if (remaining <= 0) return ""; // Drop trailing odd byte if present (e.g. null terminator appended by LabVIEW) if (remaining % 2 != 0) remaining--; int endPos = offset + remaining; // safe end position (even-aligned) std::string result; result.reserve(remaining * 3); for (int i = offset; i + 1 < endPos; i += 2) { uint16_t codepoint = static_cast(utf16leBytes[i]) | (static_cast(utf16leBytes[i + 1]) << 8); // Pass through printable ASCII (0x20-0x7E) and common whitespace (tab, LF, CR) // Escape other control characters and non-ASCII as \uXXXX if ((codepoint >= 0x20 && codepoint <= 0x7E) || codepoint == 0x09 || codepoint == 0x0A || codepoint == 0x0D) { result += static_cast(codepoint); } else { char buf[7]; snprintf(buf, sizeof(buf), "\\u%04X", codepoint); result += buf; } } return result; } std::string ANSUtilities::ConvertUTF8ToUnicodeEscapes(const std::string& utf8Str) { if (utf8Str.empty()) return ""; // Auto-detect UTF-16LE input (LabVIEW may pass UTF-16LE strings) if (IsLikelyUTF16LE(utf8Str)) { std::string asUtf8 = ConvertUTF16LEToUTF8(utf8Str.data(), static_cast(utf8Str.size())); return ConvertUTF8ToUnicodeEscapes(asUtf8); } std::string result; result.reserve(utf8Str.size() * 2); size_t i = 0; while (i < utf8Str.size()) { unsigned char c = static_cast(utf8Str[i]); if ((c >= 0x20 && c <= 0x7E) || c == '\t' || c == '\n' || c == '\r') { // Printable ASCII (0x20-0x7E) and common whitespace (tab, LF, CR) — pass through result += utf8Str[i]; i++; } else if (c <= 0x7F) { // Other control chars (0x00-0x08, 0x0B, 0x0C, 0x0E-0x1F), DEL (0x7F) — escape as \uXXXX char buf[7]; snprintf(buf, sizeof(buf), "\\u%04x", c); result += buf; i++; } else { // Multi-byte UTF-8 sequence -- decode to Unicode codepoint uint32_t codepoint = 0; int seqLen = 0; if ((c & 0xE0) == 0xC0) { codepoint = c & 0x1F; seqLen = 2; } else if ((c & 0xF0) == 0xE0) { codepoint = c & 0x0F; seqLen = 3; } else if ((c & 0xF8) == 0xF0) { codepoint = c & 0x07; seqLen = 4; } else { result += utf8Str[i]; i++; continue; } // invalid lead byte bool valid = true; for (int j = 1; j < seqLen && i + j < utf8Str.size(); j++) { unsigned char b = static_cast(utf8Str[i + j]); if ((b & 0xC0) != 0x80) { valid = false; break; } codepoint = (codepoint << 6) | (b & 0x3F); } if (!valid || i + seqLen > utf8Str.size()) { result += utf8Str[i]; i++; continue; // skip invalid } if (codepoint <= 0xFFFF) { char buf[7]; snprintf(buf, sizeof(buf), "\\u%04x", codepoint); result += buf; } else { // Surrogate pair for codepoints above U+FFFF codepoint -= 0x10000; uint16_t high = 0xD800 + (uint16_t)(codepoint >> 10); uint16_t low = 0xDC00 + (uint16_t)(codepoint & 0x3FF); char buf[14]; snprintf(buf, sizeof(buf), "\\u%04x\\u%04x", high, low); result += buf; } i += seqLen; } } return result; } std::string ANSUtilities::ConvertUnicodeEscapesToUTF8(const std::string& escapedStr) { if (escapedStr.empty()) return ""; // First decode \uXXXX to UTF-16LE, then convert to UTF-8 std::string utf16le; utf16le.reserve(escapedStr.size() * 2); size_t i = 0; while (i < escapedStr.size()) { if (i + 5 < escapedStr.size() && escapedStr[i] == '\\' && escapedStr[i + 1] == 'u') { char hex[5] = { escapedStr[i + 2], escapedStr[i + 3], escapedStr[i + 4], escapedStr[i + 5], 0 }; uint16_t codepoint = (uint16_t)strtoul(hex, nullptr, 16); utf16le += static_cast(codepoint & 0xFF); utf16le += static_cast((codepoint >> 8) & 0xFF); i += 6; } else { utf16le += escapedStr[i]; utf16le += '\0'; i++; } } return ConvertUTF16LEToUTF8(utf16le.data(), (int)utf16le.size()); } std::string ANSUtilities::DoubleEscapeUnicode(const std::string& str) { if (str.empty()) return ""; // Auto-detect UTF-16LE input (LabVIEW may pass UTF-16LE strings) if (IsLikelyUTF16LE(str)) { std::string asUtf8 = ConvertUTF16LEToUTF8(str.data(), static_cast(str.size())); return DoubleEscapeUnicode(asUtf8); } std::string result; result.reserve(str.size() + str.size() / 4); for (size_t i = 0; i < str.size(); i++) { if (str[i] == '\\' && i + 1 < str.size() && str[i + 1] == 'u') { result += "\\\\u"; i++; // skip 'u', loop advances past '\' } else { result += str[i]; } } return result; } std::string ANSUtilities::ConvertUTF8ToDoubleEscapedUnicode(const std::string& utf8Str) { if (utf8Str.empty()) return ""; // Auto-detect UTF-16LE input (LabVIEW may pass UTF-16LE strings) std::string inputStr = IsLikelyUTF16LE(utf8Str) ? ConvertUTF16LEToUTF8(utf8Str.data(), static_cast(utf8Str.size())) : utf8Str; return DoubleEscapeUnicode(ConvertUTF8ToUnicodeEscapes(inputStr)); } std::string ANSUtilities::UnescapeDoubleEscapedUnicode(const std::string& str) { if (str.empty()) return ""; // Auto-detect UTF-16LE input (LabVIEW may pass UTF-16LE strings) if (IsLikelyUTF16LE(str)) { std::string asUtf8 = ConvertUTF16LEToUTF8(str.data(), static_cast(str.size())); return UnescapeDoubleEscapedUnicode(asUtf8); } // Quick scan: if no \\u pattern exists, return original string unchanged bool found = false; for (size_t i = 0; i + 2 < str.size(); i++) { if (str[i] == '\\' && str[i + 1] == '\\' && str[i + 2] == 'u') { found = true; break; } } if (!found) return str; std::string result; result.reserve(str.size()); for (size_t i = 0; i < str.size(); i++) { if (str[i] == '\\' && i + 2 < str.size() && str[i + 1] == '\\' && str[i + 2] == 'u') { result += "\\u"; i += 2; // skip past '\\' and 'u', loop will advance past first '\' } else { result += str[i]; } } return result; } // ==================================================================== // GetANSLoggerErrorEvents / GetANSLoggerErrorEventsSinceLastCall // // Reads every Error-level event written by the "ANSLogger" source in // the Application channel using the modern winevt API. Events are // produced by WindowsEventSink in ANSLicensingSystem (see // ANSLicense.cpp::ReportEventW) — each carries a single inserted // string in .... // // DebugView: filter "[EVTLOG]". // ==================================================================== // ---- Watermark helpers (HKCU, no admin needed) ---------------------- static constexpr const wchar_t* kWatermarkRegKey = L"Software\\ANSCENTER\\ANSUtilities\\EventLogWatermark"; static constexpr const wchar_t* kWatermarkValueName = L"ANSLogger"; static uint64_t ReadAnsLoggerWatermark() { HKEY hKey = nullptr; if (RegOpenKeyExW(HKEY_CURRENT_USER, kWatermarkRegKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS) { return 0; } uint64_t value = 0; DWORD size = sizeof(value), type = 0; LONG rc = RegQueryValueExW(hKey, kWatermarkValueName, nullptr, &type, reinterpret_cast(&value), &size); RegCloseKey(hKey); return (rc == ERROR_SUCCESS && type == REG_QWORD) ? value : 0; } static void WriteAnsLoggerWatermark(uint64_t value) { HKEY hKey = nullptr; if (RegCreateKeyExW(HKEY_CURRENT_USER, kWatermarkRegKey, 0, nullptr, REG_OPTION_NON_VOLATILE, KEY_WRITE, nullptr, &hKey, nullptr) != ERROR_SUCCESS) { ANS_DBG("EVTLOG", "watermark RegCreateKey failed err=%lu", GetLastError()); return; } LONG rc = RegSetValueExW(hKey, kWatermarkValueName, 0, REG_QWORD, reinterpret_cast(&value), sizeof(value)); if (rc != ERROR_SUCCESS) { ANS_DBG("EVTLOG", "watermark RegSetValue failed err=%ld", rc); } RegCloseKey(hKey); } // Extracts NNN from a rendered event XML. // Returns 0 if not present (shouldn't happen — every Windows event has one). static uint64_t ExtractRecordIdFromXml(const std::wstring& xml) { auto open = xml.find(L""); if (open == std::wstring::npos) return 0; open += 15; // length of "" auto close = xml.find(L"", open); if (close == std::wstring::npos) return 0; std::wstring numStr = xml.substr(open, close - open); return std::wcstoull(numStr.c_str(), nullptr, 10); } // Returns the RecordID of the most recently written event in `channel`. // Used to detect channel clears: if our stored watermark > channelMax, // the channel was cleared and the new event counter restarted at 1, so // we must reset our watermark or risk skipping all new events. static uint64_t GetChannelMaxRecordId(const wchar_t* channel) { EVT_HANDLE hQuery = EvtQuery(nullptr, channel, nullptr, EvtQueryChannelPath | EvtQueryReverseDirection); if (!hQuery) return 0; EVT_HANDLE hEvent = nullptr; DWORD returned = 0; uint64_t maxId = 0; if (EvtNext(hQuery, 1, &hEvent, 1000, 0, &returned) && returned > 0) { std::vector buf(4096); DWORD used = 0, propCount = 0; BOOL ok = EvtRender(nullptr, hEvent, EvtRenderEventXml, static_cast(buf.size() * sizeof(wchar_t)), buf.data(), &used, &propCount); if (!ok && GetLastError() == ERROR_INSUFFICIENT_BUFFER) { buf.resize(used / sizeof(wchar_t) + 1); ok = EvtRender(nullptr, hEvent, EvtRenderEventXml, static_cast(buf.size() * sizeof(wchar_t)), buf.data(), &used, &propCount); } if (ok) maxId = ExtractRecordIdFromXml(std::wstring(buf.data())); EvtClose(hEvent); } EvtClose(hQuery); return maxId; } // ---- Shared implementation ----------------------------------------- // Runs `query` against the Application channel, formats events as // "
: \n" // and optionally clears the channel afterwards. If trackWatermark is // true, also persists the highest EventRecordID seen to HKCU on return. static std::string ReadAnsLoggerEventsImpl(const wchar_t* query, bool clearAfterRead, bool trackWatermark) { EVT_HANDLE hResults = EvtQuery(nullptr, L"Application", query, EvtQueryChannelPath | EvtQueryForwardDirection); if (!hResults) { ANS_DBG("EVTLOG", "EvtQuery failed err=%lu", GetLastError()); return std::string(); } std::string out; uint64_t highestRecordId = 0; constexpr DWORD kBatch = 64; EVT_HANDLE events[kBatch]; DWORD returned = 0; // Render-buffer reused across events to avoid per-event allocation. std::vector buf(8192); while (EvtNext(hResults, kBatch, events, INFINITE, 0, &returned)) { for (DWORD i = 0; i < returned; ++i) { DWORD used = 0, propCount = 0; if (!EvtRender(nullptr, events[i], EvtRenderEventXml, static_cast(buf.size() * sizeof(wchar_t)), buf.data(), &used, &propCount)) { DWORD lastErr = GetLastError(); if (lastErr == ERROR_INSUFFICIENT_BUFFER) { buf.resize(used / sizeof(wchar_t) + 1); if (!EvtRender(nullptr, events[i], EvtRenderEventXml, static_cast(buf.size() * sizeof(wchar_t)), buf.data(), &used, &propCount)) { EvtClose(events[i]); continue; } } else { ANS_DBG("EVTLOG", "EvtRender failed err=%lu", lastErr); EvtClose(events[i]); continue; } } std::wstring xml(buf.data()); // Track the highest RecordID we've seen this call so we can // persist it as the new watermark on exit. Done before the // continue-on-malformed-XML paths below so an unrenderable // event still advances the watermark. if (trackWatermark) { uint64_t rid = ExtractRecordIdFromXml(xml); if (rid > highestRecordId) highestRecordId = rid; } // ---- TimeCreated SystemTime='2026-05-18T11:52:07.123Z' ---- // EvtRender produces either single- or double-quoted attrs // depending on Windows version, so handle both. std::string formattedTime; auto tcPos = xml.find(L"TimeCreated SystemTime="); if (tcPos != std::wstring::npos) { tcPos += 23; // length of "TimeCreated SystemTime=" if (tcPos < xml.size() && (xml[tcPos] == L'"' || xml[tcPos] == L'\'')) { wchar_t quote = xml[tcPos]; ++tcPos; auto endQuote = xml.find(quote, tcPos); if (endQuote != std::wstring::npos) { std::wstring iso = xml.substr(tcPos, endQuote - tcPos); int Y = 0, M = 0, D = 0, h = 0, m = 0, s = 0; if (swscanf_s(iso.c_str(), L"%d-%d-%dT%d:%d:%d", &Y, &M, &D, &h, &m, &s) == 6) { SYSTEMTIME utc{}; utc.wYear = (WORD)Y; utc.wMonth = (WORD)M; utc.wDay = (WORD)D; utc.wHour = (WORD)h; utc.wMinute = (WORD)m; utc.wSecond = (WORD)s; SYSTEMTIME local{}; if (!SystemTimeToTzSpecificLocalTime(nullptr, &utc, &local)) { local = utc; // fallback: show UTC } wchar_t dateBuf[64] = {}, timeBuf[64] = {}; GetDateFormatW(LOCALE_USER_DEFAULT, 0, &local, nullptr, dateBuf, _countof(dateBuf)); GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &local, nullptr, timeBuf, _countof(timeBuf)); std::wstring combined = std::wstring(dateBuf) + L" " + timeBuf; int need = WideCharToMultiByte(CP_UTF8, 0, combined.c_str(), -1, nullptr, 0, nullptr, nullptr); if (need > 1) { formattedTime.resize(need - 1); WideCharToMultiByte(CP_UTF8, 0, combined.c_str(), -1, formattedTime.data(), need, nullptr, nullptr); } } // close: if (swscanf_s ... == 6) } // close: if (endQuote != npos) } // close: if (xml[tcPos] is quote) } // close: if (tcPos != npos) // ---- Concatenate every ... inside ---- // ReportEventW with N strings produces N consecutive // elements. ANSLogger sends just one but we handle the general // case so the function works for other sources too. std::wstring wdata; auto edStart = xml.find(L"", edStart); if (edStart != std::wstring::npos && edEnd != std::wstring::npos) { auto bodyEnd = edEnd; auto cursor = edStart; while (cursor < bodyEnd) { auto dOpen = xml.find(L"= bodyEnd) break; auto dGt = xml.find(L'>', dOpen); if (dGt == std::wstring::npos || dGt >= bodyEnd) break; auto dClose = xml.find(L"", dGt); if (dClose == std::wstring::npos || dClose > bodyEnd) break; if (!wdata.empty()) wdata += L' '; wdata.append(xml, dGt + 1, dClose - dGt - 1); cursor = dClose + sizeof("") - 1; } } std::string utf8Data; if (!wdata.empty()) { int need = WideCharToMultiByte(CP_UTF8, 0, wdata.c_str(), -1, nullptr, 0, nullptr, nullptr); if (need > 1) { utf8Data.resize(need - 1); WideCharToMultiByte(CP_UTF8, 0, wdata.c_str(), -1, utf8Data.data(), need, nullptr, nullptr); } } // Flatten embedded CR/LF in the message body so the // "one line per event" contract holds. ChilkatLog and // similar multi-line payloads otherwise break callers // that split on '\n'. for (char& c : utf8Data) if (c == '\r' || c == '\n') c = ' '; out += formattedTime; out += ": "; out += utf8Data; out += '\n'; EvtClose(events[i]); } } DWORD lastErr = GetLastError(); if (lastErr != ERROR_NO_MORE_ITEMS) { ANS_DBG("EVTLOG", "EvtNext stopped err=%lu", lastErr); } EvtClose(hResults); // Persist watermark BEFORE clearing — once EvtClearLog succeeds, // future events restart at RecordID 1, and we'd never see them // again if the watermark stayed at e.g. 547. // Special case: if clear is also going to succeed, the new // watermark is irrelevant (we'll reset on next call via the // GetChannelMaxRecordId check), so writing it here is harmless. if (trackWatermark && highestRecordId > 0) { WriteAnsLoggerWatermark(highestRecordId); ANS_DBG("EVTLOG", "watermark updated to %llu", highestRecordId); } if (clearAfterRead) { // Clears the entire Application channel — see header warning. // DIAGNOSTIC: also print to stderr so callers without DebugView // can see what's going on. Common failure codes: // 5 ERROR_ACCESS_DENIED — process is not elevated // 1314 ERROR_PRIVILEGE_NOT_HELD — token missing SeSecurityPriv // 87 ERROR_INVALID_PARAMETER — channel name wrong if (!EvtClearLog(nullptr, L"Application", nullptr, 0)) { DWORD e = GetLastError(); ANS_DBG("EVTLOG", "EvtClearLog failed err=%lu (need admin)", e); std::fprintf(stderr, "[ANSUtilities] EvtClearLog(Application) FAILED, " "GetLastError=%lu (5=AccessDenied, 1314=PrivNotHeld)\n", e); } else { ANS_DBG("EVTLOG", "EvtClearLog: Application channel cleared"); std::fprintf(stderr, "[ANSUtilities] EvtClearLog(Application) OK\n"); // Clear succeeded → counter resets to 1, so our watermark // is stale. Reset it now so the next call doesn't skip // legitimate new events whose RecordID < old watermark. if (trackWatermark) { WriteAnsLoggerWatermark(0); ANS_DBG("EVTLOG", "watermark reset to 0 after clear"); } } } return out; } // ---- Public: full read, no skip ------------------------------------ std::string ANSUtilities::GetANSLoggerErrorEvents(bool clearAfterRead) { // XPath: Provider name "ANSLogger" AND Level 2 (EVENTLOG_ERROR_TYPE). // Forward direction keeps chronological insertion order so output // matches a fresh "oldest first" scroll through Event Viewer. return ReadAnsLoggerEventsImpl( L"*[System[Provider[@Name='ANSLogger'] and Level=2]]", clearAfterRead, /*trackWatermark=*/false); } // ---- Public: incremental read using HKCU watermark ----------------- std::string ANSUtilities::GetANSLoggerErrorEventsSinceLastCall(bool clearAfterRead) { uint64_t watermark = ReadAnsLoggerWatermark(); // Channel-clear detection: if the channel's current max RecordID // is lower than our stored watermark, the log was cleared (by us // or by something else like Event Viewer's "Clear Log") and the // counter restarted at 1. Reset the watermark so we don't skip // events 1..watermark that are actually fresh. uint64_t channelMax = GetChannelMaxRecordId(L"Application"); if (channelMax > 0 && watermark > channelMax) { ANS_DBG("EVTLOG", "watermark reset: stored=%llu channelMax=%llu " "(channel was cleared externally)", watermark, channelMax); watermark = 0; WriteAnsLoggerWatermark(0); } // Embed the watermark in the XPath so Windows does the filtering; // we never see events <= watermark, which is more efficient than // post-filtering thousands of events on the client side. wchar_t queryBuf[256]; swprintf_s(queryBuf, _countof(queryBuf), L"*[System[Provider[@Name='ANSLogger'] and Level=2 and " L"(EventRecordID>%llu)]]", watermark); ANS_DBG("EVTLOG", "GetANSLoggerErrorEventsSinceLastCall watermark=%llu", watermark); return ReadAnsLoggerEventsImpl(queryBuf, clearAfterRead, /*trackWatermark=*/true); } } // namespace ANSCENTER // ============================================================================ // ScanDevices — AIBOX / ANSVIS discovery on the local LAN // // Port of the AIBOX Flutter app's MulticastService // (lib/src/core/network/multicast/multicast_service.dart). AIBOX boxes and // ANSVIS servers answer the same UDP probe and the same /ServerApi HTTP // endpoint, so one scan finds both. DebugView: filter "[ANSDISC]". // // Wire protocol: // UDP: probe text "Hello, Multicast" -> 230.50.200.150:58839 and subnet // broadcast :58839. Devices reply to UDP/58838 with // ":::". // HTTP: GET http:///ServerApi -> 200 + JSON with // {"OK": true, "Version": ""}. // // Implementation: a UDP listener thread + a periodic UDP sender + a 64-way // HTTP sweep populate one mutex-guarded map. After `timeoutMs` the map is // converted to a deduplicated vector and returned. // ============================================================================ #include #include #include #include #include #include #include #include #include #pragma comment(lib, "ws2_32.lib") #pragma comment(lib, "iphlpapi.lib") #pragma comment(lib, "winhttp.lib") namespace { // ---- Protocol constants (mirror AIBOX MulticastService) ----------------- constexpr const char* kMulticastGroup = "230.50.200.150"; constexpr unsigned short kProbePort = 58839; // device listens here constexpr unsigned short kListenPort = 58838; // we listen here constexpr const char* kProbeMessage = "Hello, Multicast"; constexpr int kMulticastTtl = 225; constexpr int kHttpConcurrency = 64; constexpr int kHttpConnectTimeoutMs = 700; constexpr int kHttpProbeTimeoutMs = 2500; constexpr int kUdpProbeIntervalMs = 2000; constexpr const wchar_t* kHttpUserAgent = L"ANSUtilities-Scan/1.0"; constexpr const wchar_t* kHttpPath = L"/ServerApi"; // HTTP ports answered by AIBOX boxes / ANSVIS servers. AIBOX listens on the // default HTTP port; the ANSVIS LabVIEW web server (App_serverConfig.httpPort // in ANSVIS.lvproj) listens on 22211. Each host gets probed on both ports. constexpr unsigned short kPortAibox = 80; constexpr unsigned short kPortAnsvis = 22211; constexpr unsigned short kSweepPorts[] = { kPortAibox, kPortAnsvis }; // ---- Winsock init (refcounted; safe to call repeatedly) ----------------- struct WsaScope { bool ok{false}; WsaScope() { WSADATA d{}; ok = (WSAStartup(MAKEWORD(2, 2), &d) == 0); } ~WsaScope() { if (ok) WSACleanup(); } WsaScope(const WsaScope&) = delete; WsaScope& operator=(const WsaScope&) = delete; }; // ---- Local IPv4 interfaces ---------------------------------------------- struct LocalSubnet { std::string prefix; // "192.168.1." (final dot included) in_addr localAddr{}; in_addr broadcast{}; }; std::vector EnumerateLocalSubnets() { std::vector out; ULONG bufLen = 16 * 1024; std::vector buf(bufLen); DWORD rc = GetAdaptersAddresses(AF_INET, GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER, nullptr, reinterpret_cast(buf.data()), &bufLen); if (rc == ERROR_BUFFER_OVERFLOW) { buf.resize(bufLen); rc = GetAdaptersAddresses(AF_INET, GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER, nullptr, reinterpret_cast(buf.data()), &bufLen); } if (rc != NO_ERROR) { ANS_DBG("ANSDISC", "GetAdaptersAddresses failed rc=%lu", static_cast(rc)); return out; } auto* adapter = reinterpret_cast(buf.data()); for (; adapter; adapter = adapter->Next) { if (adapter->OperStatus != IfOperStatusUp) continue; if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK) continue; for (auto* ua = adapter->FirstUnicastAddress; ua; ua = ua->Next) { if (!ua->Address.lpSockaddr || ua->Address.lpSockaddr->sa_family != AF_INET) continue; auto* sin = reinterpret_cast(ua->Address.lpSockaddr); // Skip APIPA 169.254.x.x — multicast on link-local rarely useful. unsigned char b0 = reinterpret_cast(&sin->sin_addr)[0]; unsigned char b1 = reinterpret_cast(&sin->sin_addr)[1]; if (b0 == 169 && b1 == 254) continue; if (b0 == 127) continue; char ipStr[INET_ADDRSTRLEN] = {}; inet_ntop(AF_INET, &sin->sin_addr, ipStr, sizeof(ipStr)); std::string s(ipStr); auto lastDot = s.find_last_of('.'); if (lastDot == std::string::npos) continue; LocalSubnet net; net.prefix = s.substr(0, lastDot + 1); net.localAddr = sin->sin_addr; inet_pton(AF_INET, (net.prefix + "255").c_str(), &net.broadcast); out.push_back(net); ANS_DBG("ANSDISC", "iface ip=%s subnet=%s/24", ipStr, net.prefix.c_str()); } } return out; } // ---- Parse ":::" reply ---------------------------- // parts[0] and parts[1] are not used by the AIBOX Flutter app but the device // still sends them. Observed devices put their listen port in one of those // two fields, so we try both — first numeric wins. Unparseable -> port = 0. void ParseUdpReply(const std::string& body, std::string& name, std::string& firmware, int& port) { std::vector parts; size_t start = 0; for (size_t i = 0; i <= body.size(); ++i) { if (i == body.size() || body[i] == ':') { parts.emplace_back(body.data() + start, i - start); start = i + 1; } } if (parts.size() > 3) { name = parts[2]; firmware = parts[3]; } else { name = "Unknown"; firmware = "-"; } port = 0; auto tryPort = [&](const std::string& s) { if (port != 0 || s.empty() || s.size() > 5) return; for (char c : s) if (c < '0' || c > '9') return; int v = std::atoi(s.c_str()); if (v > 0 && v < 65536) port = v; }; if (parts.size() > 0) tryPort(parts[0]); if (parts.size() > 1) tryPort(parts[1]); } // ---- Parse {"OK":true,"Version":"x"} ------------------------------------ // Tiny scan rather than a JSON dependency. Looks for the two keys with any // amount of whitespace; rejects anything that doesn't say "OK":true. bool ParseServerApiJson(const std::string& body, std::string& version) { auto pos = body.find("\"OK\""); if (pos == std::string::npos) return false; pos = body.find(':', pos); if (pos == std::string::npos) return false; ++pos; while (pos < body.size() && (body[pos] == ' ' || body[pos] == '\t')) ++pos; if (body.compare(pos, 4, "true") != 0) return false; version.clear(); pos = body.find("\"Version\""); if (pos == std::string::npos) { version = "-"; return true; } pos = body.find(':', pos); if (pos == std::string::npos) { version = "-"; return true; } pos = body.find('"', pos); if (pos == std::string::npos) { version = "-"; return true; } ++pos; auto end = body.find('"', pos); if (end == std::string::npos) { version = "-"; return true; } version = body.substr(pos, end - pos); if (version.empty()) version = "-"; return true; } // ---- Shared scan state -------------------------------------------------- enum SourceMask { kSrcMulticast = 1, kSrcSweep = 2 }; struct ScanState { std::mutex mu; std::unordered_map found; std::atomic stop{false}; void merge(const std::string& ip, const std::string& name, const std::string& firmware, int port, int srcBit) { std::lock_guard lk(mu); auto& d = found[ip]; if (d.ip.empty()) d.ip = ip; // Prefer non-empty / non-"-" values, regardless of which source ran first. if (!name.empty() && d.name.empty()) d.name = name; if (!firmware.empty() && firmware != "-" && (d.firmware.empty() || d.firmware == "-")) d.firmware = firmware; else if (!firmware.empty() && d.firmware.empty()) d.firmware = firmware; // Port precedence: an HTTP probe proves the port actually responds, // so a sweep-supplied port overwrites whatever UDP parsing guessed. // A UDP-supplied port is only kept if HTTP hasn't filled it in. if (port > 0) { const bool fromHttp = (srcBit == kSrcSweep); const bool fromHttpAlready = (d.source & kSrcSweep) != 0; if (fromHttp || !fromHttpAlready) d.port = port; } d.source |= srcBit; } }; // ---- UDP listener thread ------------------------------------------------- // Single socket bound to 0.0.0.0:58838, joined to 230.50.200.150 on every // local interface. Reads with a short timeout so it can poll `stop`. void RunUdpListener(ScanState& state, const std::vector& subnets) { SOCKET s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (s == INVALID_SOCKET) { ANS_DBG("ANSDISC", "UDP socket() failed err=%d", WSAGetLastError()); return; } BOOL on = TRUE; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast(&on), sizeof(on)); setsockopt(s, SOL_SOCKET, SO_BROADCAST, reinterpret_cast(&on), sizeof(on)); sockaddr_in bindAddr{}; bindAddr.sin_family = AF_INET; bindAddr.sin_port = htons(kListenPort); bindAddr.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(s, reinterpret_cast(&bindAddr), sizeof(bindAddr)) != 0) { ANS_DBG("ANSDISC", "UDP bind :%u failed err=%d", kListenPort, WSAGetLastError()); closesocket(s); return; } // Join multicast group on every interface so we receive replies on any path. for (const auto& net : subnets) { ip_mreq mreq{}; inet_pton(AF_INET, kMulticastGroup, &mreq.imr_multiaddr); mreq.imr_interface = net.localAddr; if (setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP, reinterpret_cast(&mreq), sizeof(mreq)) != 0) { ANS_DBG("ANSDISC", "IP_ADD_MEMBERSHIP on %.*s failed err=%d", static_cast(net.prefix.size() - 1), net.prefix.c_str(), WSAGetLastError()); } } char buf[2048]; sockaddr_in from{}; int fromLen = sizeof(from); while (!state.stop.load(std::memory_order_relaxed)) { fd_set rfds; FD_ZERO(&rfds); FD_SET(s, &rfds); timeval tv{ 0, 200 * 1000 }; // 200 ms int sel = select(0, &rfds, nullptr, nullptr, &tv); if (sel <= 0) continue; int n = recvfrom(s, buf, sizeof(buf), 0, reinterpret_cast(&from), &fromLen); if (n <= 0) continue; std::string body(buf, n); if (body == kProbeMessage) continue; // our own echo char ipStr[INET_ADDRSTRLEN] = {}; inet_ntop(AF_INET, &from.sin_addr, ipStr, sizeof(ipStr)); std::string name, fw; int port = 0; ParseUdpReply(body, name, fw, port); ANS_DBG("ANSDISC", "UDP reply from %s name=%s fw=%s port=%d raw=%s", ipStr, name.c_str(), fw.c_str(), port, body.c_str()); state.merge(ipStr, name, fw, port, kSrcMulticast); } closesocket(s); } // ---- UDP sender thread --------------------------------------------------- // Sends "Hello, Multicast" to the multicast group out each interface and // to each subnet broadcast. Repeats every kUdpProbeIntervalMs. void RunUdpSender(ScanState& state, const std::vector& subnets) { SOCKET s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (s == INVALID_SOCKET) { ANS_DBG("ANSDISC", "sender socket() failed err=%d", WSAGetLastError()); return; } BOOL on = TRUE; setsockopt(s, SOL_SOCKET, SO_BROADCAST, reinterpret_cast(&on), sizeof(on)); int ttl = kMulticastTtl; setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, reinterpret_cast(&ttl), sizeof(ttl)); sockaddr_in mc{}; mc.sin_family = AF_INET; mc.sin_port = htons(kProbePort); inet_pton(AF_INET, kMulticastGroup, &mc.sin_addr); auto sendOnce = [&]() { for (const auto& net : subnets) { // Pin multicast egress to this interface so it leaves each NIC. setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, reinterpret_cast(&net.localAddr), sizeof(net.localAddr)); sendto(s, kProbeMessage, static_cast(strlen(kProbeMessage)), 0, reinterpret_cast(&mc), sizeof(mc)); sockaddr_in bc{}; bc.sin_family = AF_INET; bc.sin_port = htons(kProbePort); bc.sin_addr = net.broadcast; sendto(s, kProbeMessage, static_cast(strlen(kProbeMessage)), 0, reinterpret_cast(&bc), sizeof(bc)); } }; sendOnce(); auto next = std::chrono::steady_clock::now() + std::chrono::milliseconds(kUdpProbeIntervalMs); while (!state.stop.load(std::memory_order_relaxed)) { auto now = std::chrono::steady_clock::now(); if (now >= next) { sendOnce(); next = now + std::chrono::milliseconds(kUdpProbeIntervalMs); } else { std::this_thread::sleep_for(std::chrono::milliseconds(100)); } } closesocket(s); } // ---- One synchronous HTTP probe via WinHTTP ----------------------------- // On AIBOX/ANSVIS reply: out_version is set and returns true. Otherwise false. bool ProbeHttp(const std::string& ip, unsigned short port, std::string& out_version) { HINTERNET hSession = WinHttpOpen(kHttpUserAgent, WINHTTP_ACCESS_TYPE_NO_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0); if (!hSession) return false; WinHttpSetTimeouts(hSession, kHttpConnectTimeoutMs, kHttpConnectTimeoutMs, kHttpProbeTimeoutMs, kHttpProbeTimeoutMs); std::wstring host(ip.begin(), ip.end()); HINTERNET hConn = WinHttpConnect(hSession, host.c_str(), static_cast(port), 0); if (!hConn) { WinHttpCloseHandle(hSession); return false; } HINTERNET hReq = WinHttpOpenRequest(hConn, L"GET", kHttpPath, nullptr, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0); if (!hReq) { WinHttpCloseHandle(hConn); WinHttpCloseHandle(hSession); return false; } bool ok = false; if (WinHttpSendRequest(hReq, L"Accept: application/json\r\n", static_cast(-1L), WINHTTP_NO_REQUEST_DATA, 0, 0, 0) && WinHttpReceiveResponse(hReq, nullptr)) { DWORD status = 0, statusSize = sizeof(status); if (WinHttpQueryHeaders(hReq, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, WINHTTP_HEADER_NAME_BY_INDEX, &status, &statusSize, WINHTTP_NO_HEADER_INDEX) && status == 200) { std::string body; DWORD avail = 0; // Cap body at 64 KB — /ServerApi is a few hundred bytes. while (body.size() < 65536 && WinHttpQueryDataAvailable(hReq, &avail) && avail) { std::vector buf(avail); DWORD read = 0; if (!WinHttpReadData(hReq, buf.data(), avail, &read)) break; body.append(buf.data(), read); } ok = ParseServerApiJson(body, out_version); } } WinHttpCloseHandle(hReq); WinHttpCloseHandle(hConn); WinHttpCloseHandle(hSession); return ok; } // ---- HTTP sweep: 64-way worker pool consuming a queue of (ip, port) ----- // Each host is probed on every port in kSweepPorts (80 + 22211) so one // sweep covers both AIBOX and ANSVIS. void RunHttpSweep(ScanState& state, const std::vector& subnets) { struct Target { std::string ip; unsigned short port; }; std::queue q; for (const auto& net : subnets) { for (int h = 1; h <= 254; ++h) { std::string ip = net.prefix + std::to_string(h); for (unsigned short p : kSweepPorts) q.push({ ip, p }); } } ANS_DBG("ANSDISC", "HTTP sweep targets=%zu workers=%d", q.size(), kHttpConcurrency); std::mutex qmu; auto worker = [&]() { for (;;) { if (state.stop.load(std::memory_order_relaxed)) return; Target t; { std::lock_guard lk(qmu); if (q.empty()) return; t = std::move(q.front()); q.pop(); } std::string ver; if (ProbeHttp(t.ip, t.port, ver)) { ANS_DBG("ANSDISC", "HTTP hit %s:%u version=%s", t.ip.c_str(), static_cast(t.port), ver.c_str()); state.merge(t.ip, std::string(), ver, static_cast(t.port), kSrcSweep); } } }; std::vector pool; pool.reserve(kHttpConcurrency); for (int i = 0; i < kHttpConcurrency; ++i) pool.emplace_back(worker); for (auto& t : pool) t.join(); } } // anonymous namespace namespace ANSCENTER { std::vector ANSUtilities::ScanDevices(int timeoutMs) { if (timeoutMs < 500) timeoutMs = 500; // floor: enough for one UDP burst ANS_DBG("ANSDISC", "ScanDevices: enter timeoutMs=%d", timeoutMs); WsaScope wsa; if (!wsa.ok) { ANS_DBG("ANSDISC", "WSAStartup failed"); return {}; } auto subnets = EnumerateLocalSubnets(); if (subnets.empty()) { ANS_DBG("ANSDISC", "no usable IPv4 interfaces; aborting scan"); return {}; } ScanState state; std::thread tListen([&]{ RunUdpListener(state, subnets); }); std::thread tSend ([&]{ RunUdpSender (state, subnets); }); std::thread tSweep ([&]{ RunHttpSweep (state, subnets); }); std::this_thread::sleep_for(std::chrono::milliseconds(timeoutMs)); state.stop.store(true, std::memory_order_relaxed); tListen.join(); tSend.join(); tSweep.join(); std::vector result; { std::lock_guard lk(state.mu); result.reserve(state.found.size()); for (auto& kv : state.found) result.push_back(std::move(kv.second)); } ANS_DBG("ANSDISC", "ScanDevices: exit found=%zu", result.size()); return result; } } // namespace ANSCENTER