2026-03-28 16:54:11 +11:00
#ifndef ANSULT_H
#define ANSULT_H
#define ANSULT_API __declspec(dllexport)
#pragma once
#include "LabVIEWHeader/extcode.h"
#include <map>
#include <string>
2026-04-08 08:47:10 +10:00
#include <vector>
2026-03-28 16:54:11 +11:00
#include "ANSLicense.h"
#include <CkRest.h>
#include "CkAuthGoogle.h"
#include "CkByteData.h"
#include <CkAuthAws.h>
#include <CkXml.h>
#include <CkCrypt2.h>
#include <CkSocket.h>
#include <opencv2/opencv.hpp>
#include <thread>
#include <atomic>
2026-08-12 21:24:12 +10:00
#include <chrono>
2026-04-17 07:03:03 +10:00
#include <functional>
2026-03-28 16:54:11 +11:00
namespace ANSCENTER {
2026-05-23 18:03:22 +10:00
// 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)
2026-05-24 08:33:34 +10:00
int port { 0 }; // TCP port the device's HTTP API answers on
// (AIBOX = 80, ANSVIS = 22211). 0 = unknown.
2026-05-23 18:03:22 +10:00
int source { 0 }; // 1 = multicast, 2 = HTTP sweep, 3 = both
};
2026-03-28 16:54:11 +11:00
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 < std :: string >& toEmails ,
const std :: vector < std :: string >& ccEmails ,
const std :: vector < std :: string >& bccEmails );
// Restart PC
[[nodiscard]] static bool RestartPC ();
2026-03-31 14:10:21 +11:00
// 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 );
2026-04-06 14:20:43 +10:00
// 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 );
2026-04-07 07:59:46 +10:00
// 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 );
2026-04-08 08:47:10 +10:00
// 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 < unsigned char > 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 );
2026-04-07 07:59:46 +10:00
// 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 );
2026-05-23 18:03:22 +10:00
2026-05-24 09:19:24 +10:00
// Read every Error-level event from "ANSLogger" in the Windows
// Application event log. Output: one line per event in the form
// "<DD/MM/YYYY h:mm:ss tt>: <event data string>\n"
// Time is converted to the user's local timezone and formatted
// using LOCALE_USER_DEFAULT (matches Event Viewer's display).
//
2026-06-18 05:55:31 +10:00
// 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.
2026-05-24 09:19:24 +10:00
[[nodiscard]] static std :: string GetANSLoggerErrorEvents ( bool clearAfterRead = false );
2026-06-18 05:55:31 +10:00
// 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 );
2026-05-23 18:03:22 +10:00
// 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 "<a>:<b>:<deviceName>:<firmware>".
// 2) HTTP /24 subnet sweep on every local IPv4 interface, GETing
// http://<host>/ServerApi with up to 64 concurrent connections.
// A device is recognized when the JSON body contains
// {"OK": true, "Version": "<firmware>"}.
// `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 < ANSDeviceInfo > ScanDevices ( int timeoutMs = 5000 );
2026-03-28 16:54:11 +11:00
};
// Connection bundle for pool
struct S3Connection {
CkRest rest ;
CkSocket socket ;
CkAuthAws authAws ;
2026-08-12 21:24:12 +10:00
// 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 };
2026-03-28 16:54:11 +11:00
};
class ANSULT_API ANSAWSS3 {
private :
bool _isUnlockCodeValid { false };
bool _isLicenseValid { false };
2026-04-17 07:03:03 +10:00
// Atomic because upload threads read _bConnected without a lock
// while Connect() / RetryLoop() can write it.
std :: atomic < bool > _bConnected { false };
2026-03-28 16:54:11 +11:00
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 < std :: unique_ptr < S3Connection >> _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 };
2026-04-17 07:03:03 +10:00
// 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 < int > _connectTimeoutMs { 10000 }; // 10 s
std :: atomic < int > _idleTimeoutMs { 20000 }; // 20 s
2026-08-12 21:24:12 +10:00
// 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 < int > _reusedIdleTimeoutMs { 5000 }; // 5 s
// Bumped by Connect / SetAuthentication / SetServerProxy. Stamped
// into every S3Connection at creation; see S3Connection::configGen.
std :: atomic < uint64_t > _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 ;
2026-03-28 16:54:11 +11:00
// 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
2026-05-01 11:16:47 +10:00
// 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 < S3Connection > CreateConnection ( bool logOnFailure = true );
2026-03-28 16:54:11 +11:00
std :: unique_ptr < S3Connection > AcquireConnection ();
2026-08-12 21:24:12 +10:00
// Return a healthy connection to the pool for reuse.
2026-03-28 16:54:11 +11:00
void ReleaseConnection ( std :: unique_ptr < S3Connection > conn );
2026-08-12 21:24:12 +10:00
// 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 < S3Connection > conn );
2026-03-28 16:54:11 +11:00
std :: string ExtractFileName ( const std :: string & filePath );
std :: string GetContentType ( const std :: string & filePath );
2026-04-17 07:03:03 +10:00
// ---- 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 };
2026-08-12 21:24:12 +10:00
// 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 < S3Connection > conn ,
std :: string & lastError );
2026-04-17 07:03:03 +10:00
static constexpr int kUploadMaxAttempts = 20 ;
static constexpr int kUploadRetryDelayMs = 100 ;
2026-08-12 21:24:12 +10:00
// 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 ;
2026-04-17 07:03:03 +10:00
bool UploadWithRetry (
const std :: string & opName ,
const std :: function < AttemptResult ( std :: string & lastError ) >& attemptFn );
2026-03-28 16:54:11 +11:00
// Background retry
std :: thread _retryThread ;
std :: atomic < bool > _stopRetry { false };
std :: atomic < bool > _retryInProgress { false };
void StopRetry ();
void RetryLoop ();
bool TryConnect ( bool & awsPath );
public :
2026-08-12 21:24:12 +10:00
// ---- 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 ();
2026-03-28 16:54:11 +11:00
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 );
2026-04-17 07:03:03 +10:00
// 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 );
2026-03-28 16:54:11 +11:00
[[nodiscard]] std :: vector < std :: string > ListBuckets ();
[[nodiscard]] std :: vector < std :: string > ListBucketObjects ( const std :: string & bucketName );
[[nodiscard]] std :: vector < std :: string > 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 );
2026-05-19 10:37:46 +10:00
// 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 "<prefix>/<objectName>", 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 );
2026-03-28 16:54:11 +11:00
};
}
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 ();
2026-05-23 18:03:22 +10:00
// 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 );
2026-05-24 09:19:24 +10:00
// Read all Error-level events from "ANSLogger" in the Windows Application
// event log. Returns a UTF-8 string with one event per line:
// "<DD/MM/YYYY h:mm:ss tt>: <event data>\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 );
2026-06-18 05:55:31 +10:00
// 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 );
2026-03-31 14:10:21 +11:00
// Unicode conversion utilities for LabVIEW
2026-03-31 21:52:47 +11:00
extern "C" ANSULT_API int ANSConvertUTF8ToUTF16LE ( const char * utf8Str , LStrHandle result , int includeBOM = 1 );
2026-03-31 14:10:21 +11:00
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 );
2026-04-06 14:20:43 +10:00
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 );
2026-04-08 08:47:10 +10:00
// 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 );
2026-04-07 07:59:46 +10:00
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 );
2026-03-28 16:54:11 +11:00
// 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 );
2026-05-19 10:37:46 +10:00
extern "C" ANSULT_API int GeneratePresignedURLANSAWSHandle ( ANSCENTER :: ANSAWSS3 ** Handle , const char * bucketName , const char * prefix , const char * objectName , int validDays , LStrHandle presignedURL );
2026-03-28 16:54:11 +11:00
// 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 );
2026-05-19 10:37:46 +10:00
extern "C" ANSULT_API int GeneratePresignedURLANSAWSHandle_CPP ( ANSCENTER :: ANSAWSS3 ** Handle , const char * bucketName , const char * prefix , const char * objectName , int validDays , std :: string & presignedURL );
2026-03-28 16:54:11 +11:00
#endif