#ifndef ANSULT_H #define ANSULT_H #define ANSULT_API __declspec(dllexport) #pragma once #include "LabVIEWHeader/extcode.h" #include #include #include #include "ANSLicense.h" #include #include "CkAuthGoogle.h" #include "CkByteData.h" #include #include #include #include #include #include #include #include #include namespace ANSCENTER { // Discovered AIBOX / ANSVIS server on the local network. struct ANSDeviceInfo { std::string ip; // IPv4 address (dotted-decimal) std::string name; // Device name from UDP probe, empty if HTTP-only std::string firmware; // Version string ("-" if device did not report one) int port{ 0 }; // TCP port the device's HTTP API answers on // (AIBOX = 80, ANSVIS = 22211). 0 = unknown. int source{ 0 }; // 1 = multicast, 2 = HTTP sweep, 3 = both }; class ANSULT_API ANSUtilities { private: // Protects all shared mutable data mutable std::recursive_mutex _mutex; bool _isUnlockCodeValid{ false}; bool _isLicenseValid{ false}; std::string _licenseKey; std::string _unlockCode; std::string _proxyHost; int _proxyPort{ 0 }; std::string _proxyUsername; std::string _proxyPassword; bool _bProxy{ false }; std::string _fireBaseSessionToken; bool _bTls{ true }; int _port{ 443 }; bool _bAutoReconnect{ true }; bool _isAWSConnected{ false }; // Google Cloud Storage Authentication CkAuthGoogle _authGoogle; bool _isAuthenticated{ false }; SPDLogger& _logger = SPDLogger::GetInstance("ANSUtilities", false); std::chrono::system_clock::time_point tokenGeneratedTime; bool tokenInitialized = false; static const int TOKEN_EXPIRY_SECONDS = 3600; public: ANSUtilities(); ~ANSUtilities(); [[nodiscard]] bool Initialize(const std::string& licenseKey); void CheckLicense(); void CheckUnlockCode(); [[nodiscard]] bool SetServerProxy(const std::string& proxyHost, int proxyPort, const std::string& proxyUsername, const std::string& proxyPassword); [[nodiscard]] std::string GetFirebaseCloudMessageAcccessToken(std::string privateKey); //AWS SNS Functions [[nodiscard]] std::string CreateAWSSNSTopic(const std::string& topicName); // Will return the ARN of the topic [[nodiscard]] bool DeleteAWSSNSTopic(const std::string& topicARN); // Will return the ARN of the topic [[nodiscard]] std::string ListAWSSNSTopic(); // Will return the list ARN of the topic in string with ; concatenated [[nodiscard]] std::string SubcribeSMSPhoneNumber(const std::string& topicARN, const std::string& phoneNumber); [[nodiscard]] std::string SubscribeEmailAddress(const std::string& topicARN, const std::string& emailAddress); [[nodiscard]] std::string SendMessageToTopic(const std::string& topicARN, const std::string& subjectContent, const std::string& messageContent);// Return the message ID [[nodiscard]] std::string SendMessageToPhoneNumber(const std::string& phoneNumber, const std::string& messageContent);// Return the message ID // Google Cloud Storage Upload using Chilkat [[nodiscard]] bool AuthenticateGCS(const std::string& jsonKeyString); [[nodiscard]] bool UploadMatToGCS(const std::string& bucketName, const std::string& objectName, const cv::Mat& image); [[nodiscard]] bool UploadMatToGCS(const std::string& bucketName, const std::string& objectName, unsigned char* jpeg_string, int32 bufferLength); [[nodiscard]] static bool CheckUnlockCode_S(); [[nodiscard]] static std::string AESEncryption(const std::string& inputString, const std::string& inputKey); [[nodiscard]] static std::string AESDecryption(const std::string& encryptString, const std::string& inputKey); [[nodiscard]] static std::string MD5HashFile(const std::string& inputFilePath); // SMTP for office360 email sending [[nodiscard]] static bool 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); // Restart PC [[nodiscard]] static bool RestartPC(); // Convert a UTF-8 encoded string to UTF-16LE byte string. // Useful for LabVIEW which can display UTF-16LE Unicode text on Windows. static std::string ConvertUTF8ToUTF16LE(const std::string& utf8Str); // Decode JSON Unicode escape sequences (\uXXXX) to UTF-16LE byte string. // Input: ASCII string with \uXXXX escapes (e.g., "\\u6c5f\\u6771 599") // Output: UTF-16LE byte string for LabVIEW display. static std::string DecodeJsonUnicodeToUTF16LE(const std::string& escapedStr); // Convert a UTF-16LE byte string to UTF-8. // Useful for receiving Unicode text from LabVIEW and converting to UTF-8 for internal processing. static std::string ConvertUTF16LEToUTF8(const char* utf16leBytes, int byteLen); // Convert UTF-16LE byte string (with optional BOM) to Unicode escape sequences (\uXXXX). // Input: raw UTF-16LE bytes (BOM is auto-stripped if present). // Output: ASCII string with \uXXXX for non-ASCII codepoints, plain ASCII chars preserved. static std::string ConvertUTF16LEToUnicodeEscapes(const char* utf16leBytes, int byteLen); // Convert Unicode escape sequences (\uXXXX) to UTF-8 string. // Input: ASCII string with \uXXXX escapes (e.g., "\\u6c5f\\u6771 599") // Output: UTF-8 encoded Unicode string. static std::string ConvertUnicodeEscapesToUTF8(const std::string& escapedStr); // Convert a UTF-8 string to Unicode escape sequences (\uXXXX). // ASCII chars (0x20-0x7E) are preserved, all others become \uXXXX. // Useful for encoding Unicode text into JSON-safe ASCII. static std::string ConvertUTF8ToUnicodeEscapes(const std::string& utf8Str); // Repair mixed-encoding input from LabVIEW text controls. // LabVIEW may produce a mix of UTF-16LE pairs and UTF-8 multi-byte // sequences in a single byte stream. It may also insert space (0x20) as // a single byte without the 0x00 high byte. // This function normalizes everything to proper UTF-16LE pairs. // Input: raw bytes from LStrHandle (BOM should already be stripped). // Output: clean UTF-16LE with proper 2-byte alignment. static std::vector RepairLabVIEWUTF16LE(const unsigned char* data, int len); // Check if a byte sequence is valid UTF-8. // Returns true if all bytes form valid UTF-8 sequences. static bool IsValidUTF8(const unsigned char* data, int len); // Double-escape \uXXXX sequences: \u1ee7 becomes \\u1ee7. // Useful when the string will be embedded in JSON and the literal \uXXXX must survive parsing. static std::string DoubleEscapeUnicode(const std::string& str); // Convert UTF-8 to double-escaped Unicode: "Thủy" becomes "Th\\u1ee7y". // Combines ConvertUTF8ToUnicodeEscapes + DoubleEscapeUnicode in one call. static std::string ConvertUTF8ToDoubleEscapedUnicode(const std::string& utf8Str); // Unescape double-escaped Unicode: "Th\\u1ee7y" becomes "Th\u1ee7y". // Reverses DoubleEscapeUnicode so other languages can parse \uXXXX correctly. static std::string UnescapeDoubleEscapedUnicode(const std::string& str); // Read every Error-level event from "ANSLogger" in the Windows // Application event log. Output: one line per event in the form // "
: \n" // Time is converted to the user's local timezone and formatted // using LOCALE_USER_DEFAULT (matches Event Viewer's display). // // clearAfterRead=true behaviour: // * Calls EvtClearLog on the entire Application channel after // reading. WARNING: this wipes every event from every source // in the Application log, not just ANSLogger entries — there // is no per-event delete API in Windows. // * REQUIRES THE CALLING PROCESS TO BE ELEVATED (run as // Administrator). Without elevation, EvtClearLog returns // ERROR_ACCESS_DENIED (Win32 error 5) and the events remain // in the log. The read still succeeds either way. // * Failures are reported on stderr in the form // "[ANSUtilities] EvtClearLog(Application) FAILED, GetLastError=N" // and via DebugView under the "EVTLOG" tag. The C++ return // value does NOT signal clear success — capture stderr or // check Event Viewer afterwards to confirm. [[nodiscard]] static std::string GetANSLoggerErrorEvents(bool clearAfterRead = false); // Same as GetANSLoggerErrorEvents but only returns events that // have NOT been returned by a previous call from this user // account. The highest EventRecordID seen is persisted to // HKCU\Software\ANSCENTER\ANSUtilities\EventLogWatermark\ANSLogger // (REG_QWORD) and used as a Windows XPath filter // (EventRecordID > N) on the next call. No admin needed for the // skip mechanism — only for the optional clearAfterRead. // // Channel-clear handling: if Windows resets the Application // channel's RecordID counter (typical after EvtClearLog), this // function detects that the channel's current max RecordID is // less than the stored watermark and resets the watermark to 0 // so no newly-written events are accidentally skipped. // // To force a re-read of all events, delete the registry value // above and call again. [[nodiscard]] static std::string GetANSLoggerErrorEventsSinceLastCall(bool clearAfterRead = false); // Scan the local network for AIBOX / ANSVIS servers. // Runs two strategies in parallel and merges results by IP: // 1) UDP multicast probe to 230.50.200.150:58839 (with subnet // broadcast fallback). App listens on UDP/58838 for replies // in the form ":::". // 2) HTTP /24 subnet sweep on every local IPv4 interface, GETing // http:///ServerApi with up to 64 concurrent connections. // A device is recognized when the JSON body contains // {"OK": true, "Version": ""}. // `timeoutMs` is the maximum scan window (default 5000 ms). Shorter // values return faster but may miss slow devices. The call blocks // until the window elapses, then returns the deduplicated list. [[nodiscard]] static std::vector ScanDevices(int timeoutMs = 5000); }; // Connection bundle for pool struct S3Connection { CkRest rest; CkSocket socket; CkAuthAws authAws; // When this connection last completed a request successfully. A socket // that a NAT/firewall silently killed while idle costs a full // IdleTimeoutMs to discover, so anything idle longer than // kMaxPooledIdleMs is dropped rather than handed out again. std::chrono::steady_clock::time_point lastUsed{ std::chrono::steady_clock::now() }; // Value of ANSAWSS3::_configGen when this connection was built. // A mismatch means it predates a Connect / SetAuthentication / // SetServerProxy call — e.g. the background RetryLoop finished a // connect just after SetAuthentication cleared the pool — so its // endpoint, proxy or SigV4 state is stale and it must not be reused. uint64_t configGen{ 0 }; }; class ANSULT_API ANSAWSS3 { private: bool _isUnlockCodeValid{ false }; bool _isLicenseValid{ false }; // Atomic because upload threads read _bConnected without a lock // while Connect() / RetryLoop() can write it. std::atomic _bConnected{ false }; bool _bAwsPath{ true }; // true = virtual-hosted (AWS), false = path-style (MinIO) std::string _licenseKey; std::string _unlockCode; // ── Connection pool (replaces single _rest/_socket/_authAws) ── std::mutex _poolMutex; std::vector> _pool; // ── Config (read-only after setup, protected by _configMutex) ── std::mutex _configMutex; std::string _fullAWSURL; // AWS S3 service URL bool _bTls{ true }; int _port{ 443 }; bool _bAutoReconnect{ true }; std::string _serviceName; std::string _bucketRegion; std::string _baseDomain; std::string _accessKey; std::string _secretKey; bool _authReady{ false }; // Request timeouts applied to every new S3Connection. // _connectTimeoutMs : max time to wait for TCP/TLS connect. // _idleTimeoutMs : max gap between bytes on a send/recv. // Atomic so SetTimeouts can update them without holding _configMutex. std::atomic _connectTimeoutMs{ 10000 }; // 10 s std::atomic _idleTimeoutMs { 20000 }; // 20 s // Shorter idle timeout used for the FIRST request on a connection // taken from the pool. A pooled socket may have been silently // dropped by a middlebox since it was last used; without this the // caller pays the full _idleTimeoutMs (20 s by default) just to // discover that. A fresh connection still gets the full // _idleTimeoutMs, so the retry after a stale-socket failure is not // penalised. Derived from _idleTimeoutMs by SetTimeouts(). std::atomic _reusedIdleTimeoutMs{ 5000 }; // 5 s // Bumped by Connect / SetAuthentication / SetServerProxy. Stamped // into every S3Connection at creation; see S3Connection::configGen. std::atomic _configGen{ 1 }; // A pooled connection idle longer than this is closed instead of // reused. Kept below the ~20 s after which S3 (and most NAT // devices) stop caring about an idle keep-alive flow. static constexpr int kMaxPooledIdleMs = 15000; // Proxy settings std::string _proxyHost; int _proxyPort{ 0 }; std::string _proxyUsername; std::string _proxyPassword; bool _bProxy{ false }; SPDLogger& _logger = SPDLogger::GetInstance("ANSAWSS3", false); // Pool helpers // logOnFailure=false suppresses error-level logging on failure (still emits ANS_DBG). // Used by TryConnect's first attempt, which is allowed to fail for path-style/MinIO servers. std::unique_ptr CreateConnection(bool logOnFailure = true); std::unique_ptr AcquireConnection(); // Return a healthy connection to the pool for reuse. void ReleaseConnection(std::unique_ptr conn); // Close and destroy a connection instead of pooling it. Use on any // TRANSPORT failure (send/recv failed, timeout): that socket is // suspect, and putting it back means the next worker inherits the // same stall. An HTTP error status is NOT a transport failure — the // server answered — so those still go through ReleaseConnection. void DiscardConnection(std::unique_ptr conn); std::string ExtractFileName(const std::string& filePath); std::string GetContentType(const std::string& filePath); // ---- Retry helper for transient / network-stability failures ---- // Each upload function delegates its per-attempt body to a lambda. // The lambda returns one of these outcomes: // Success -> stop, UploadWithRetry returns true // Transient -> retry (up to kUploadMaxAttempts total) // Permanent -> stop, UploadWithRetry returns false // The lambda should write a short human-readable reason into // `lastError` on any non-Success outcome so it can be logged. enum class AttemptResult { Success, Transient, Permanent }; // Record the outcome of the current call for the calling thread. static void SetCallStatus(int status); // Shared licence / unlock / connected check for the upload entry // points. Logs the reason and sets the per-thread call status // (permanent for a licence problem, not-connected for a link that // has not come up yet). Returns false if the call must not proceed. bool CheckUploadPreconditions(const std::string& opName); // Decide what a failed Chilkat request means, and dispose of the // connection accordingly. Chilkat reports failure for an HTTP 4xx // delivered during an Expect: 100-continue exchange, so "the call // returned false" does NOT imply the network failed — a 404 // NoSuchBucket arrives this way. Retrying those wastes the whole // retry budget and reports the wrong class to the caller. // 4xx (except 408/429) -> Permanent, socket healthy -> pooled // anything else -> Transient, socket suspect -> discarded // Takes ownership of `conn`, and rewrites `lastError` into one // readable line. AttemptResult ClassifyFailedRequest(std::unique_ptr conn, std::string& lastError); static constexpr int kUploadMaxAttempts = 20; static constexpr int kUploadRetryDelayMs = 100; // Wall-clock budget for one upload call, across all attempts. The // attempt cap alone is not a bound on time: 20 attempts that each // hit a 20 s idle timeout would block the caller for ~400 s. A new // attempt is only started while inside this budget, so the worst // case is the budget plus one in-flight attempt. static constexpr int kUploadDeadlineMs = 30000; bool UploadWithRetry( const std::string& opName, const std::function& attemptFn); // Background retry std::thread _retryThread; std::atomic _stopRetry{ false }; std::atomic _retryInProgress{ false }; void StopRetry(); void RetryLoop(); bool TryConnect(bool& awsPath); public: // ---- Call status codes ------------------------------------------- // Every upload entry point records one of these for the CALLING // THREAD, so the C exports can tell the caller whether a retry is // worth attempting without changing any function signature. // // These EXTEND the codes the C wrappers already return; they do not // redefine any of them. Full set seen by a LabVIEW caller: // 1 success // 0 null / invalid argument passed to the export // -1 handle not in the registry // -2 upload failed, reason not classified (fallback) // -3 std::exception escaped // -4 unknown exception escaped // -20 permanent: bad argument, licence, bucket, or HTTP 4xx // -21 not connected yet / reconnect in progress // -22 transient: network, timeout or 5xx after internal retries // // Retry rule for the caller: retry on -21 and -22 (and -2/-3/-4 if // it wants to be generous); do NOT retry on -20 or 0 — those need a // configuration or code fix. Success stays the only positive value, // so both `rc == 1` and `rc != 1` remain correct tests. static constexpr int kCallSuccess = 1; static constexpr int kCallPermanentError = -20; static constexpr int kCallNotConnected = -21; static constexpr int kCallTransientError = -22; // Status of the most recent upload call made ON THIS THREAD. // Thread-local, so concurrent workers sharing one handle never see // each other's result. Read it immediately after the call. static int LastCallStatus(); ANSAWSS3(); ~ANSAWSS3(); [[nodiscard]] bool Initialize(const std::string& licenseKey); void CheckLicense(); void CheckUnlockCode(); [[nodiscard]] bool SetServerProxy(const std::string& proxyHost, int proxyPort, const std::string& proxyUsername, const std::string& proxyPassword); // Returns: 1 = connected, 0 = failed (bad auth/URL), 2 = no internet (background retry started) [[nodiscard]] int Connect(const std::string& baseDomain, const std::string& bucketRegion, const std::string& serviceName, int port, bool bTls, bool autoReconnect, bool& awsPath); [[nodiscard]] bool SetAuthentication(const std::string& accessKey, const std::string& secretKey); // Pre-populate the connection pool with `count` ready-to-use // S3Connections. Creating a connection performs a TLS handshake // inside CreateConnection(); doing it up-front in parallel keeps // the first `count` concurrent uploads from serializing on handshake. // Safe to call after Connect() + SetAuthentication() have succeeded. // Returns the number of connections actually added to the pool // (may be less than `count` on transient network issues). int PrewarmConnectionPool(int count); // Update request timeouts used by every new connection, and // propagate them to all already-pooled connections so the new // values take effect on the very next request. // connectMs: max time to wait for TCP/TLS connect (>= 1000 ms) // idleMs : max gap between bytes on send/recv (>= 1000 ms) // Returns false on invalid input (values are left unchanged). bool SetTimeouts(int connectMs, int idleMs); [[nodiscard]] std::vector ListBuckets(); [[nodiscard]] std::vector ListBucketObjects(const std::string& bucketName); [[nodiscard]] std::vector ListBucketObjectsWithPrefix(const std::string& bucketName, const std::string& prefix); [[nodiscard]] bool CreateBucket(const std::string& bucketName); [[nodiscard]] bool DeleteBucket(const std::string& bucketName); [[nodiscard]] bool CreateFolder(const std::string& bucketName, const std::string& prefix); [[nodiscard]] bool DeleteFolder(const std::string& bucketName, const std::string& prefix); [[nodiscard]] bool DeleteBucketObject(const std::string& bucketName, const std::string& objectName); [[nodiscard]] std::string GetBucketRegion(const std::string& bucketName); // Upload data to AWS S3 [[nodiscard]] bool UploadTextData(const std::string& bucketName, const std::string &textFilePath, std::string& uploadedFilePath); [[nodiscard]] bool UploadFileStream(const std::string& bucketName, const std::string& dataFilePath, std::string& uploadedFilePath); [[nodiscard]] bool UploadBinaryData(const std::string& bucketName, const std::string& dataFilePath, std::string& uploadedFilePath); [[nodiscard]] bool UploadPrefixBinaryData(const std::string& bucketName, const std::string& prefix, const std::string& dataFilePath, const std::string& objectName, std::string& uploadedFilePath); [[nodiscard]] bool UploadMultipartData(const std::string& bucketName, const std::string& dataFilePath, std::string& uploadedFilePath, int partSize=5242880); [[nodiscard]] bool UploadPrefixMultipartData(const std::string& bucketName, const std::string& prefix, const std::string& dataFilePath, const std::string& fileName, std::string& uploadedFilePath, int partSize= 5242880); [[nodiscard]] bool UploadPrefixJpegImage(const std::string& bucketName, const std::string& prefix, unsigned char* jpeg_string, int32 bufferLength, const std::string& fileName, std::string& uploadedFilePath); [[nodiscard]] bool UploadJpegImage(const std::string& bucketName, unsigned char* jpeg_string, int32 bufferLength, const std::string& fileName, std::string& uploadedFilePath); [[nodiscard]] bool DownloadFile(const std::string& bucketName, const std::string& objectName, const std::string& saveFilePath); // Generate a temporary pre-signed URL (AWS Signature V4) for an // object already stored in S3, so public users can access it // without AWS credentials until it expires. // bucketName, prefix, objectName: the SAME three values passed // to UploadPrefixJpegImage when the object was uploaded. // (objectName is what UploadPrefixJpegImage calls its // `fileName` parameter — the last segment of the S3 key.) // validDays: URL validity in days, 1..7 (AWS caps pre-signed // URLs at 7 days). // The object key is rebuilt as "/", so the URL // points at exactly the key that was uploaded. This is a local // signing operation: it performs no network I/O, but // Connect()/SetAuthentication() must have been called so the // credentials and endpoint are known. [[nodiscard]] bool GeneratePresignedURL(const std::string& bucketName, const std::string& prefix, const std::string& objectName, int validDays, std::string& presignedURL); }; } extern "C" ANSULT_API int CreateANSUtilityHandle(ANSCENTER::ANSUtilities** Handle, const char* licenseKey); extern "C" ANSULT_API int ReleaseANSUtilityHandle(ANSCENTER::ANSUtilities** Handle); extern "C" ANSULT_API int GetFCMAccessToken(ANSCENTER::ANSUtilities** Handle, const char* privateKey, LStrHandle accessToken); extern "C" ANSULT_API int CreateAWSSNSTopic(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, LStrHandle arnTopic); extern "C" ANSULT_API int DeleteAWSSNSTopic(ANSCENTER::ANSUtilities** Handle, const char* arnTopic); extern "C" ANSULT_API int ListASWTopics(ANSCENTER::ANSUtilities** Handle, LStrHandle arnTopics); extern "C" ANSULT_API int AESEncryption(const char* inputString, const char* inputKey, LStrHandle encryptionMessage); extern "C" ANSULT_API int AESDecryption(const char* encryptedString, const char* inputKey, LStrHandle decryptionMessage); extern "C" ANSULT_API int MD5HashFile(const char* filePath, LStrHandle decryptionMessage); extern "C" ANSULT_API int SubcribeSMSPhoneNumberAWSSNSTopic(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, const char* phoneNumber, LStrHandle subscribedARN); extern "C" ANSULT_API int SubcribeEmailAddressAWSSNSTopic(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, const char* emailAddress, LStrHandle subscribedARN); extern "C" ANSULT_API int SendMessageToAWSSNSTopic(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, const char* subjectContent,const char * messageContent, LStrHandle messageId); extern "C" ANSULT_API int SendMessageToPhoneNumber(ANSCENTER::ANSUtilities** Handle, const char* phoneNumber, const char* messageContent, LStrHandle messageId); extern "C" ANSULT_API int GetFCMAccessTokenCpp(ANSCENTER::ANSUtilities** Handle, const char* privateKey, std::string &accessToken); extern "C" ANSULT_API int CreateAWSSNSTopicCpp(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, std::string& arnTopic); extern "C" ANSULT_API int SubcribeSMSPhoneNumberAWSSNSTopicCpp(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, const char* phoneNumber, std::string& subscribedARN); extern "C" ANSULT_API int SubcribeEmailAddressAWSSNSTopicCpp(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, const char* emailAddress, std::string& subscribedARN); extern "C" ANSULT_API int SendMessageToAWSSNSTopicCpp(ANSCENTER::ANSUtilities** Handle, const char* snsTopicName, const char* subjectContent, const char* messageContent, std::string& messageId); extern "C" ANSULT_API int SendMessageToPhoneNumberCpp(ANSCENTER::ANSUtilities** Handle, const char* phoneNumber, const char* messageContent, std::string& messageId); extern "C" ANSULT_API int ListASWTopicsCpp(ANSCENTER::ANSUtilities** Handle, std::string& arnTopics); // Static functions extern "C" ANSULT_API int AESEncryptionCpp(const char* inputString, const char* inputKey, std::string& encryptedString); extern "C" ANSULT_API int AESDecryptionCpp(const char* encryptedString, const char* inputKey, std::string& decryptionMessage); // Google Cloud Storage extern "C" ANSULT_API int SetupServerProxy(ANSCENTER::ANSUtilities** Handle, const char* hostName, int port, const char* userName, const char* passWord); extern "C" ANSULT_API int AuthenticateGCS(ANSCENTER::ANSUtilities** Handle, const char* jsonKeyString); extern "C" ANSULT_API int UploadMatToGCS(ANSCENTER::ANSUtilities** Handle, const char* bucketName, const char* objectName, unsigned char* jpeg_string, int32 bufferLength); extern "C" ANSULT_API int UploadImageToGCS(ANSCENTER::ANSUtilities** Handle, const char* bucketName, const char* objectName, cv::Mat image); extern "C" ANSULT_API int SendEmail(const char* smtpServer, int port, const char* userName, const char* password, const char* title, const char* bodyHTMLContent, const char* bodyTextContent, const char* fromEmailSender, const char* toEmails, const char* ccEmails, const char* bccEmails); extern "C" ANSULT_API int RebootSystem(); // Discover AIBOX / ANSVIS servers on the local network. // Returns a JSON array of objects: [{"ip":"...","name":"...","firmware":"...","source":3}, ...] // `source` is 1 = multicast, 2 = HTTP sweep, 3 = both. // `timeoutMs` caps the scan duration (typical: 3000-10000 ms). extern "C" ANSULT_API int ScanANSDevices(int timeoutMs, LStrHandle resultJson); extern "C" ANSULT_API int ScanANSDevicesCpp(int timeoutMs, std::string& resultJson); // Read all Error-level events from "ANSLogger" in the Windows Application // event log. Returns a UTF-8 string with one event per line: // "
: \n" // `clearAfterRead` != 0 clears the entire Application channel afterwards // (requires Administrator; see header comment on the C++ method). extern "C" ANSULT_API int GetANSLoggerErrorEvents(int clearAfterRead, LStrHandle result); extern "C" ANSULT_API int GetANSLoggerErrorEventsCpp(int clearAfterRead, std::string& result); // Watermarked variant: only returns events not seen by previous calls. // Watermark is stored in HKCU\Software\ANSCENTER\ANSUtilities\EventLogWatermark\ANSLogger // (REG_QWORD). No admin needed for the skip; only for clearAfterRead. extern "C" ANSULT_API int GetANSLoggerErrorEventsSinceLastCall(int clearAfterRead, LStrHandle result); extern "C" ANSULT_API int GetANSLoggerErrorEventsSinceLastCallCpp(int clearAfterRead, std::string& result); // Unicode conversion utilities for LabVIEW extern "C" ANSULT_API int ANSConvertUTF8ToUTF16LE(const char* utf8Str, LStrHandle result, int includeBOM = 1); extern "C" ANSULT_API int ANSDecodeJsonUnicodeToUTF16LE(const char* escapedStr, LStrHandle result); extern "C" ANSULT_API int ANSConvertUTF16LEToUTF8(const unsigned char* utf16leBytes, int byteLen, LStrHandle result); extern "C" ANSULT_API int ANSConvertUTF16LEToUnicodeEscapes(const unsigned char* utf16leBytes, int byteLen, LStrHandle result); extern "C" ANSULT_API int ANSConvertUnicodeEscapesToUTF8(const char* escapedStr, LStrHandle result); // LStrHandle-safe versions: input is LStrHandle (preserves null bytes in UTF-16LE data) extern "C" ANSULT_API int ANSConvertUTF16LEToUTF8_LV(LStrHandle input, LStrHandle result); extern "C" ANSULT_API int ANSConvertUTF16LEToUnicodeEscapes_LV(LStrHandle input, LStrHandle result); extern "C" ANSULT_API int ANSConvertUTF8ToUnicodeEscapes(const char* utf8Str, LStrHandle result); extern "C" ANSULT_API int ANSDoubleEscapeUnicode(const char* str, LStrHandle result); extern "C" ANSULT_API int ANSConvertUTF8ToDoubleEscapedUnicode(const char* utf8Str, LStrHandle result); extern "C" ANSULT_API int ANSUnescapeDoubleEscapedUnicode(const char* str, LStrHandle result); // AWS S3 class extern "C" ANSULT_API int CreateANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* licenseKey); extern "C" ANSULT_API int ReleaseANSAWSHandle(ANSCENTER::ANSAWSS3** Handle); extern "C" ANSULT_API int ConnectANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* baseDomain, const char* bucketRegion, const char* serviceName, int port, int bTls, int autoReconnect, int* awsPath); extern "C" ANSULT_API int SetProxyANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* proxyHost, int proxyPort, const char* proxyUsername, const char* proxyPassword); extern "C" ANSULT_API int SetAuthenticationANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* accessKey, const char* secretKey); extern "C" ANSULT_API int ListBucketANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, std::string &bucketList); extern "C" ANSULT_API int ListBucketObjectsANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, std::string& bucketNameList); extern "C" ANSULT_API int ListBucketObjectsWithPrefixANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, std::string& bucketNameList); extern "C" ANSULT_API int GetRegionANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, std::string& region); extern "C" ANSULT_API int ListBucketANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, LStrHandle bucketList); extern "C" ANSULT_API int ListBucketObjectsANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, LStrHandle bucketNameList); extern "C" ANSULT_API int ListBucketObjectsWithPrefixANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, LStrHandle bucketNameList); extern "C" ANSULT_API int GetRegionANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, LStrHandle region); extern "C" ANSULT_API int CreateBucketANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName); extern "C" ANSULT_API int DeleteBucketANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName); extern "C" ANSULT_API int CreateBucketPrefixANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char *prefix); extern "C" ANSULT_API int DeleteBucketPrefixANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix); extern "C" ANSULT_API int DeleteBucketObjectANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* bucketObject); extern "C" ANSULT_API int UploadTextDataANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* textDataPath, LStrHandle uploadedFilePath); extern "C" ANSULT_API int UploadBinaryDataANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* binaryDataPath, LStrHandle uploadedFilePath); extern "C" ANSULT_API int UploadFileStreamDataANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* fileDataPath, LStrHandle uploadedFilePath); extern "C" ANSULT_API int UploadMultiPartDataANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* fileDataPath, int fileSize, LStrHandle uploadedFilePath); extern "C" ANSULT_API int UploadJpegImageANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, unsigned char* jpeg_string, int32 bufferLength, const char* fileName, LStrHandle uploadedFilePath); extern "C" ANSULT_API int UploadPrefixBinaryDataANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, const char* binaryDataPath, const char* objectName, LStrHandle uploadedFilePath); extern "C" ANSULT_API int UploadPrefixMultiPartDataANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, const char* fileDataPath, const char* objectName, int fileSize, LStrHandle uploadedFilePath); extern "C" ANSULT_API int UploadPrefixJpegImageANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, unsigned char* jpeg_string, int32 bufferLength, const char* fileName, LStrHandle uploadedFilePath); extern "C" ANSULT_API int DownloadFileStreamANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* objectName, const char* savedFilePath); extern "C" ANSULT_API int GeneratePresignedURLANSAWSHandle(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, const char* objectName, int validDays, LStrHandle presignedURL); // C++ test APIs (use std::string& instead of LStrHandle) extern "C" ANSULT_API int UploadTextDataANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* textDataPath, std::string& uploadedFilePath); extern "C" ANSULT_API int UploadBinaryDataANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* binaryDataPath, std::string& uploadedFilePath); extern "C" ANSULT_API int UploadFileStreamDataANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* fileDataPath, std::string& uploadedFilePath); extern "C" ANSULT_API int UploadMultiPartDataANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* fileDataPath, int fileSize, std::string& uploadedFilePath); extern "C" ANSULT_API int UploadJpegImageANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, unsigned char* jpeg_string, int32 bufferLength, const char* fileName, std::string& uploadedFilePath); extern "C" ANSULT_API int UploadPrefixBinaryDataANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, const char* binaryDataPath, const char* objectName, std::string& uploadedFilePath); extern "C" ANSULT_API int UploadPrefixMultiPartDataANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, const char* fileDataPath, const char* objectName, int fileSize, std::string& uploadedFilePath); extern "C" ANSULT_API int UploadPrefixJpegImageANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, unsigned char* jpeg_string, int32 bufferLength, const char* fileName, std::string& uploadedFilePath); extern "C" ANSULT_API int GeneratePresignedURLANSAWSHandle_CPP(ANSCENTER::ANSAWSS3** Handle, const char* bucketName, const char* prefix, const char* objectName, int validDays, std::string& presignedURL); #endif