From a2fa2c8cebbad73a549369992b332ba96bb6cdc3 Mon Sep 17 00:00:00 2001 From: Tuan Nghia Nguyen Date: Sat, 23 May 2026 18:03:22 +1000 Subject: [PATCH] Support scanning ANSVIS servers device --- modules/ANSUtilities/ANSUtilities.cpp | 420 ++++++++++++++++++ modules/ANSUtilities/ANSUtilities.h | 29 ++ modules/ANSUtilities/CMakeLists.txt | 4 +- modules/ANSUtilities/dllmain.cpp | 78 ++++ .../ANSUtilities-UnitTest.cpp | 41 +- 5 files changed, 568 insertions(+), 4 deletions(-) diff --git a/modules/ANSUtilities/ANSUtilities.cpp b/modules/ANSUtilities/ANSUtilities.cpp index 9529969..0a5c2de 100644 --- a/modules/ANSUtilities/ANSUtilities.cpp +++ b/modules/ANSUtilities/ANSUtilities.cpp @@ -1309,5 +1309,425 @@ namespace ANSCENTER } return result; } +} // 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"; + +// ---- 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 ---------------------------- +void ParseUdpReply(const std::string& body, std::string& name, std::string& firmware) { + 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 = "-"; } +} + +// ---- 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 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; + 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; + ParseUdpReply(body, name, fw); + ANS_DBG("ANSDISC", "UDP reply from %s name=%s fw=%s", + ipStr, name.c_str(), fw.c_str()); + state.merge(ipStr, name, fw, 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, 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(), + INTERNET_DEFAULT_HTTP_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 IPs ------------ +void RunHttpSweep(ScanState& state, const std::vector& subnets) { + std::queue q; + for (const auto& net : subnets) { + for (int h = 1; h <= 254; ++h) { + q.push(net.prefix + std::to_string(h)); + } + } + 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; + std::string ip; + { + std::lock_guard lk(qmu); + if (q.empty()) return; + ip = std::move(q.front()); + q.pop(); + } + std::string ver; + if (ProbeHttp(ip, ver)) { + ANS_DBG("ANSDISC", "HTTP hit %s version=%s", ip.c_str(), ver.c_str()); + state.merge(ip, std::string(), ver, 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 + diff --git a/modules/ANSUtilities/ANSUtilities.h b/modules/ANSUtilities/ANSUtilities.h index 033e8b8..f776cc3 100644 --- a/modules/ANSUtilities/ANSUtilities.h +++ b/modules/ANSUtilities/ANSUtilities.h @@ -20,6 +20,14 @@ #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 source{ 0 }; // 1 = multicast, 2 = HTTP sweep, 3 = both + }; + class ANSULT_API ANSUtilities { private: // Protects all shared mutable data @@ -144,6 +152,20 @@ namespace ANSCENTER { // 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); + + // 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 { @@ -345,6 +367,13 @@ extern "C" ANSULT_API int SendEmail(const char* smtpServer, int port, 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); + // 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); diff --git a/modules/ANSUtilities/CMakeLists.txt b/modules/ANSUtilities/CMakeLists.txt index c13192b..989eb88 100644 --- a/modules/ANSUtilities/CMakeLists.txt +++ b/modules/ANSUtilities/CMakeLists.txt @@ -21,7 +21,9 @@ target_link_libraries(ANSUtilities ) if(WIN32) - target_link_libraries(ANSUtilities PRIVATE ${WIN_COMMON_LIBS} crypt32) + # WIN_COMMON_LIBS covers ws2_32, iphlpapi, etc. winhttp is needed for the + # ScanDevices HTTP /ServerApi sweep. + target_link_libraries(ANSUtilities PRIVATE ${WIN_COMMON_LIBS} crypt32 winhttp) endif() target_compile_definitions(ANSUtilities PRIVATE UNICODE _UNICODE ANSUTILITIES_EXPORTS) diff --git a/modules/ANSUtilities/dllmain.cpp b/modules/ANSUtilities/dllmain.cpp index 80baf47..382a246 100644 --- a/modules/ANSUtilities/dllmain.cpp +++ b/modules/ANSUtilities/dllmain.cpp @@ -2973,3 +2973,81 @@ extern "C" ANSULT_API int DownloadFileStreamANSAWSHandle_V2(uint64_t handleVal, catch (std::exception& e) { return 0; } catch (...) { return 0; } } + +// --------------------------------------------------------------------------- +// ScanANSDevices — discover AIBOX / ANSVIS servers on the local network. +// Returns 1 on success (resultJson populated, possibly with empty "[]"), 0 +// on internal failure. The static C++ method does its own license/error +// handling; this wrapper just serializes the device list to JSON. +// --------------------------------------------------------------------------- +static std::string JsonEscape(const std::string& s) { + std::string out; + out.reserve(s.size() + 2); + for (char c : s) { + switch (c) { + case '"': out += "\\\""; break; + case '\\': out += "\\\\"; break; + case '\n': out += "\\n"; break; + case '\r': out += "\\r"; break; + case '\t': out += "\\t"; break; + default: + if (static_cast(c) < 0x20) { + char buf[8]; + snprintf(buf, sizeof(buf), "\\u%04x", static_cast(c)); + out += buf; + } else { + out += c; + } + } + } + return out; +} + +static std::string DevicesToJson(const std::vector& devs) { + std::string j = "["; + for (size_t i = 0; i < devs.size(); ++i) { + if (i) j += ','; + j += "{\"ip\":\""; j += JsonEscape(devs[i].ip); j += "\","; + j += "\"name\":\""; j += JsonEscape(devs[i].name); j += "\","; + j += "\"firmware\":\""; j += JsonEscape(devs[i].firmware); j += "\","; + j += "\"source\":"; j += std::to_string(devs[i].source); + j += '}'; + } + j += ']'; + return j; +} + +extern "C" ANSULT_API int ScanANSDevicesCpp(int timeoutMs, std::string& resultJson) { + ANS_DBG("ANSUTIL", "ScanANSDevicesCpp: timeoutMs=%d", timeoutMs); + try { + auto devs = ANSCENTER::ANSUtilities::ScanDevices(timeoutMs); + resultJson = DevicesToJson(devs); + return 1; + } + catch (const std::exception& e) { + ANS_DBG("ANSUTIL", "ScanANSDevicesCpp threw: %s", e.what()); + resultJson = "[]"; + return 0; + } + catch (...) { + ANS_DBG("ANSUTIL", "ScanANSDevicesCpp threw unknown"); + resultJson = "[]"; + return 0; + } +} + +extern "C" ANSULT_API int ScanANSDevices(int timeoutMs, LStrHandle resultJson) { + ANS_DBG("ANSUTIL", "ScanANSDevices: timeoutMs=%d", timeoutMs); + if (!resultJson) return -1; + try { + std::string j; + ScanANSDevicesCpp(timeoutMs, j); + int size = static_cast(j.size()); + MgErr error = DSSetHandleSize(resultJson, sizeof(int32) + size * sizeof(uChar)); + if (error != noErr) return -2; + (*resultJson)->cnt = size; + if (size > 0) memcpy((*resultJson)->str, j.data(), size); + return 1; + } + catch (...) { return -1; } +} diff --git a/tests/ANSUtilities-UnitTest/ANSUtilities-UnitTest.cpp b/tests/ANSUtilities-UnitTest/ANSUtilities-UnitTest.cpp index 59f2601..a1cf41b 100644 --- a/tests/ANSUtilities-UnitTest/ANSUtilities-UnitTest.cpp +++ b/tests/ANSUtilities-UnitTest/ANSUtilities-UnitTest.cpp @@ -386,6 +386,39 @@ int ANSLLMOllamaTest() { return 0; } +// Exercise ANSCENTER::ANSUtilities::ScanDevices — discovers AIBOX boxes and +// ANSVIS servers on the local LAN via UDP multicast + HTTP /ServerApi sweep. +// Run on a machine connected to the same subnet as at least one device. +// DebugView (filter "[ANSDISC]") shows per-device hits and per-interface joins. +int ScanDevicesTest() +{ + std::cout << "\n===== ScanDevices (AIBOX / ANSVIS discovery) =====" << std::endl; + + // 1) Direct static C++ call. + const int timeoutMs = 5000; + std::cout << "Scanning for " << timeoutMs << " ms ..." << std::endl; + auto devices = ANSCENTER::ANSUtilities::ScanDevices(timeoutMs); + + std::cout << "Found " << devices.size() << " device(s):" << std::endl; + for (const auto& d : devices) { + const char* src = (d.source == 3) ? "both" + : (d.source == 2) ? "sweep" + : (d.source == 1) ? "multicast" + : "unknown"; + std::cout << " " << d.ip + << " name=\"" << d.name << "\"" + << " firmware=\"" << d.firmware << "\"" + << " source=" << src << std::endl; + } + + // 2) Exercise the C extern entrypoint that LabVIEW uses. + std::string json; + int rc = ScanANSDevicesCpp(timeoutMs, json); + std::cout << "\nScanANSDevicesCpp rc=" << rc << " json=" << json << std::endl; + + return static_cast(devices.size()); +} + int main() { //ANSLLMOllamaTest(); @@ -393,11 +426,13 @@ int main() //std::cout << "===== MinIO (path-style) =====" << std::endl; //ANSFTechMinIOTest(); - std::cout << "\n===== AWS S3 (virtual-host) =====" << std::endl; - ANSAWSTest(); + //std::cout << "\n===== AWS S3 (virtual-host) =====" << std::endl; + //ANSAWSTest(); //ANSLLMTest(); //SendEmailExample(); //uploadFileToGoogleStorage(); - // EncrypyionExample(); + // EncrypyionExample(); + + ScanDevicesTest(); }