/* ========================================================================== * sleela_synchro.c -- Synchro implementation (honest measured latency). * * Portable UDP probe/measurement. A probe binds a connected UDP socket to the * destination, sends timestamped datagrams, and matches echoed replies. All * timing uses a monotonic clock; the distribution is measured, never promised. * * The socket layer is deliberately self-contained (BSD/Winsock directly) so the * module has no dependency beyond the platform sockets already required by the * engine. It follows the same OS split the rest of the core uses. * ========================================================================== */ #if !defined(_WIN32) && !defined(_WIN64) && !defined(_POSIX_C_SOURCE) #define _POSIX_C_SOURCE 200809L #endif #include "sleela_synchro.h" #include #include #include #include #ifdef _WIN32 #include #include #else #include #include #include #include #include #include #include #endif struct SLSynchro { #ifdef _WIN32 SOCKET fd; #else int fd; #endif char host[256]; uint16_t port; int64_t sent; int64_t received; uint32_t seq; /* monotonically increasing probe id */ #ifdef _WIN32 int winsock_started; /* balanced WSAStartup/WSACleanup lease */ #endif int nsamples; /* retained matched RTT samples (us) */ int64_t samples[SL_SYNCHRO_MAX_SAMPLES]; }; /* Monotonic nanoseconds (portable). */ static int64_t mono_ns(void) { #ifdef _WIN32 static LARGE_INTEGER freq; static int have = 0; LARGE_INTEGER c; if (!have) { QueryPerformanceFrequency(&freq); have = 1; } QueryPerformanceCounter(&c); return (int64_t)((c.QuadPart * 1000000000LL) / freq.QuadPart); #else struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (int64_t)ts.tv_sec * 1000000000LL + (int64_t)ts.tv_nsec; #endif } SLSynchro* slsynchro_open(const char* host, uint16_t port) { if (!host || !*host) return NULL; #ifdef _WIN32 /* Standalone callers may not have initialized the runtime network layer. * Hold one balanced Winsock reference for each live Synchro handle. */ WSADATA winsock_data; if (WSAStartup(MAKEWORD(2, 2), &winsock_data) != 0) return NULL; #endif char service[16]; snprintf(service, sizeof(service), "%u", (unsigned)port); struct addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; struct addrinfo* list = NULL; if (getaddrinfo(host, service, &hints, &list) != 0) { #ifdef _WIN32 WSACleanup(); #endif return NULL; } SLSynchro* s = (SLSynchro*)calloc(1, sizeof(SLSynchro)); if (!s) { freeaddrinfo(list); #ifdef _WIN32 WSACleanup(); #endif return NULL; } #ifdef _WIN32 s->fd = INVALID_SOCKET; s->winsock_started = 1; #else s->fd = -1; #endif for (struct addrinfo* p = list; p; p = p->ai_next) { #ifdef _WIN32 SOCKET fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol); if (fd == INVALID_SOCKET) continue; if (connect(fd, p->ai_addr, (int)p->ai_addrlen) == 0) { s->fd = fd; break; } closesocket(fd); #else int fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol); if (fd < 0) continue; /* connect() on a UDP socket fixes the peer so send/recv work and * replies from other sources are filtered by the kernel. */ if (connect(fd, p->ai_addr, p->ai_addrlen) == 0) { s->fd = fd; break; } close(fd); #endif } freeaddrinfo(list); #ifdef _WIN32 if (s->fd == INVALID_SOCKET) { if (s->winsock_started) WSACleanup(); free(s); return NULL; } #else if (s->fd < 0) { free(s); return NULL; } #endif snprintf(s->host, sizeof(s->host), "%s", host); s->port = port; return s; } /* Wait up to timeout_ms for the socket to be readable. Returns 1 readable, * 0 timeout, -1 error. */ static int wait_readable(SLSynchro* s, int timeout_ms) { #ifdef _WIN32 fd_set rf; FD_ZERO(&rf); FD_SET(s->fd, &rf); struct timeval tv; tv.tv_sec = timeout_ms / 1000; tv.tv_usec = (timeout_ms % 1000) * 1000; int r = select(0, &rf, NULL, NULL, &tv); return r > 0 ? 1 : (r == 0 ? 0 : -1); #else struct pollfd pfd; pfd.fd = s->fd; pfd.events = POLLIN; int r = poll(&pfd, 1, timeout_ms); return r > 0 ? 1 : (r == 0 ? 0 : -1); #endif } int64_t slsynchro_dispatch(SLSynchro* s, size_t payload_len, int timeout_ms) { if (!s || timeout_ms < 0) return -1; if (payload_len < 8) payload_len = 8; /* room for the 8-byte tag */ if (payload_len > 1472) payload_len = 1472; /* keep within a typical MTU */ /* Build a probe: 4-byte magic-seq tag then filler. The reply must echo the * tag for the sample to be counted (honest matching, never fabricated). */ unsigned char buf[1472]; uint32_t seq = ++s->seq; memset(buf, 0, payload_len); buf[0] = (unsigned char)(seq >> 24); buf[1] = (unsigned char)(seq >> 16); buf[2] = (unsigned char)(seq >> 8); buf[3] = (unsigned char)(seq); buf[4] = 'S'; buf[5] = 'Y'; buf[6] = 'N'; buf[7] = 'C'; s->sent++; int64_t t0 = mono_ns(); #ifdef _WIN32 int w = send(s->fd, (const char*)buf, (int)payload_len, 0); #else ssize_t w = send(s->fd, buf, payload_len, 0); #endif if (w < 0) return -1; /* send failure counts as loss */ for (;;) { int64_t elapsed_ms = (mono_ns() - t0) / 1000000LL; int remaining = timeout_ms - (int)elapsed_ms; if (remaining < 0) remaining = 0; int ready = wait_readable(s, remaining); if (ready <= 0) return -1; /* timeout or error = loss */ unsigned char rbuf[1472]; #ifdef _WIN32 int n = recv(s->fd, (char*)rbuf, (int)sizeof(rbuf), 0); #else ssize_t n = recv(s->fd, rbuf, sizeof(rbuf), 0); #endif if (n < 4) { if ((int)((mono_ns() - t0) / 1000000LL) >= timeout_ms) return -1; continue; } uint32_t rseq = ((uint32_t)rbuf[0] << 24) | ((uint32_t)rbuf[1] << 16) | ((uint32_t)rbuf[2] << 8) | (uint32_t)rbuf[3]; if (rseq != seq) { /* A stale/mismatched reply: keep waiting within the budget. */ if ((int)((mono_ns() - t0) / 1000000LL) >= timeout_ms) return -1; continue; } int64_t rtt_us = (mono_ns() - t0) / 1000LL; s->received++; if (s->nsamples < SL_SYNCHRO_MAX_SAMPLES) s->samples[s->nsamples++] = rtt_us; else s->samples[s->seq % SL_SYNCHRO_MAX_SAMPLES] = rtt_us; return rtt_us; } } int64_t slsynchro_sent(const SLSynchro* s) { return s ? s->sent : 0; } int64_t slsynchro_received(const SLSynchro* s) { return s ? s->received : 0; } int64_t slsynchro_mean_us(const SLSynchro* s) { if (!s || s->nsamples == 0) return -1; int64_t sum = 0; for (int i = 0; i < s->nsamples; i++) sum += s->samples[i]; return sum / s->nsamples; } int64_t slsynchro_min_us(const SLSynchro* s) { if (!s || s->nsamples == 0) return -1; int64_t m = s->samples[0]; for (int i = 1; i < s->nsamples; i++) if (s->samples[i] < m) m = s->samples[i]; return m; } int64_t slsynchro_max_us(const SLSynchro* s) { if (!s || s->nsamples == 0) return -1; int64_t m = s->samples[0]; for (int i = 1; i < s->nsamples; i++) if (s->samples[i] > m) m = s->samples[i]; return m; } static int cmp_i64(const void* a, const void* b) { int64_t x = *(const int64_t*)a, y = *(const int64_t*)b; return (x > y) - (x < y); } int64_t slsynchro_percentile_us(const SLSynchro* s, int p) { if (!s || s->nsamples == 0) return -1; if (p < 0) p = 0; if (p > 100) p = 100; int64_t* tmp = (int64_t*)malloc((size_t)s->nsamples * sizeof(int64_t)); if (!tmp) return -1; memcpy(tmp, s->samples, (size_t)s->nsamples * sizeof(int64_t)); qsort(tmp, (size_t)s->nsamples, sizeof(int64_t), cmp_i64); /* nearest-rank percentile */ int rank = (int)(((int64_t)p * (s->nsamples - 1) + 50) / 100); if (rank < 0) rank = 0; if (rank >= s->nsamples) rank = s->nsamples - 1; int64_t v = tmp[rank]; free(tmp); return v; } int64_t slsynchro_loss_permille(const SLSynchro* s) { if (!s || s->sent == 0) return 0; int64_t lost = s->sent - s->received; if (lost < 0) lost = 0; return (lost * 1000) / s->sent; } int slsynchro_report(const SLSynchro* s, char* out, size_t cap) { if (!out || cap == 0) return 0; if (!s) { out[0] = 0; return 0; } int n = snprintf(out, cap, "synchro %s:%u sent=%lld recv=%lld loss=%lldpermille mean=%lldus p95=%lldus min=%lldus max=%lldus", s->host, (unsigned)s->port, (long long)s->sent, (long long)s->received, (long long)slsynchro_loss_permille(s), (long long)slsynchro_mean_us(s), (long long)slsynchro_percentile_us(s, 95), (long long)slsynchro_min_us(s), (long long)slsynchro_max_us(s)); if (n < 0) { out[0] = 0; return 0; } return ((size_t)n < cap) ? n : (int)(cap - 1); } void slsynchro_close(SLSynchro* s) { if (!s) return; #ifdef _WIN32 if (s->fd != INVALID_SOCKET) closesocket(s->fd); if (s->winsock_started) WSACleanup(); #else if (s->fd >= 0) close(s->fd); #endif free(s); }