Support scanning ANSVIS servers device

This commit is contained in:
2026-05-23 18:03:22 +10:00
parent 4678d87e33
commit a2fa2c8ceb
5 changed files with 568 additions and 4 deletions
+420
View File
@@ -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
// "<a>:<b>:<deviceName>:<firmware>".
// HTTP: GET http://<ip>/ServerApi -> 200 + JSON with
// {"OK": true, "Version": "<firmware>"}.
//
// 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 <winsock2.h>
#include <ws2tcpip.h>
#include <iphlpapi.h>
#include <winhttp.h>
#include <mutex>
#include <condition_variable>
#include <unordered_map>
#include <chrono>
#include <queue>
#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<LocalSubnet> EnumerateLocalSubnets() {
std::vector<LocalSubnet> out;
ULONG bufLen = 16 * 1024;
std::vector<char> buf(bufLen);
DWORD rc = GetAdaptersAddresses(AF_INET,
GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER,
nullptr, reinterpret_cast<PIP_ADAPTER_ADDRESSES>(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<PIP_ADAPTER_ADDRESSES>(buf.data()), &bufLen);
}
if (rc != NO_ERROR) {
ANS_DBG("ANSDISC", "GetAdaptersAddresses failed rc=%lu", static_cast<unsigned long>(rc));
return out;
}
auto* adapter = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(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<sockaddr_in*>(ua->Address.lpSockaddr);
// Skip APIPA 169.254.x.x — multicast on link-local rarely useful.
unsigned char b0 = reinterpret_cast<unsigned char*>(&sin->sin_addr)[0];
unsigned char b1 = reinterpret_cast<unsigned char*>(&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 "<a>:<b>:<name>:<firmware>" reply ----------------------------
void ParseUdpReply(const std::string& body, std::string& name, std::string& firmware) {
std::vector<std::string> 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<std::string, ANSCENTER::ANSDeviceInfo> found;
std::atomic<bool> stop{false};
void merge(const std::string& ip, const std::string& name,
const std::string& firmware, int srcBit) {
std::lock_guard<std::mutex> 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<LocalSubnet>& 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<char*>(&on), sizeof(on));
setsockopt(s, SOL_SOCKET, SO_BROADCAST, reinterpret_cast<char*>(&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<sockaddr*>(&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<char*>(&mreq), sizeof(mreq)) != 0) {
ANS_DBG("ANSDISC", "IP_ADD_MEMBERSHIP on %.*s failed err=%d",
static_cast<int>(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<sockaddr*>(&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<LocalSubnet>& 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<char*>(&on), sizeof(on));
int ttl = kMulticastTtl;
setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL,
reinterpret_cast<char*>(&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<const char*>(&net.localAddr),
sizeof(net.localAddr));
sendto(s, kProbeMessage, static_cast<int>(strlen(kProbeMessage)), 0,
reinterpret_cast<sockaddr*>(&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<int>(strlen(kProbeMessage)), 0,
reinterpret_cast<sockaddr*>(&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<DWORD>(-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<char> 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<LocalSubnet>& subnets) {
std::queue<std::string> 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<std::mutex> 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<std::thread> 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<ANSDeviceInfo> 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<ANSDeviceInfo> result;
{
std::lock_guard<std::mutex> 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
+29
View File
@@ -20,6 +20,14 @@
#include <functional>
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 "<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);
};
// 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);
+3 -1
View File
@@ -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)
+78
View File
@@ -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<unsigned char>(c) < 0x20) {
char buf[8];
snprintf(buf, sizeof(buf), "\\u%04x", static_cast<unsigned char>(c));
out += buf;
} else {
out += c;
}
}
}
return out;
}
static std::string DevicesToJson(const std::vector<ANSCENTER::ANSDeviceInfo>& 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<int>(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; }
}
@@ -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<int>(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();
}