refactor: S10.17 Network primitives conformance

DEVLOG.md

@@ -1,5 +1,149 @@
 # Dev Log
 
+## 2026-05-22 — S10.17 Network primitives conformance
+
+Closes S10.17 (#428). Sixth per-group conformance story in E10. Network
+primitives cluster: `Datagram`, `Stream`, `Resolver`, `Address`, `Sleep`,
+plus their POSIX / Windows / FreeRTOS / OpenSSL impls. Started from the
+CI report at run 26303038083 (`main@2952760`, post-S08.08), which surfaced
+52 unsuppressed cppcheck-misra findings in scope; clang-tidy was clean.
+
+### Headline
+
+Seven commits, one per logical fix cluster. Two refactor-shaped fixes
+(Patterns B, C), two simple per-site fixes (D, E), one mechanical sweep
+(A), and two suppression-list reorganisations (G, F).
+
+### Pattern A — `== true` at pool-allocator IsValid call sites (MISRA 14.4)
+
+The S10.05 audit's verdict on rule 14.4 was "single site, fixable"; the
+E11 PoolAllocator rollout multiplied it to 22 sites across every pool-backed
+`*Static.c::_Create`. cppcheck-misra's essential-type tracker doesn't
+follow `bool`-returning function calls across the call boundary, so
+`if (IsValid(...))` is flagged even though the function genuinely returns
+`bool`.
+
+Two experiments before committing the form:
+
+1. De-inline `SolidSyslogPoolAllocator_IndexIsValid` from header into .c
+   — no effect. The cppcheck-misra tracker has the same limitation
+   against extern functions as against static inlines.
+2. Explicit `if (... == true)` — works. The comparison yields bool,
+   which the tracker unambiguously sees as essentially-Boolean.
+
+The `== true` form is a code-smell shape (redundant comparison on a
+`bool`) and David's first reaction was that he didn't like it; we
+preferred it to a new deviation D.012 on weighing-up. Tree-wide sweep
+applies it to all 23 sites (the 22 found in CI scope plus
+`MbedTlsStreamStatic.c` which CI doesn't currently include — applying
+the fix here means S10.20's CI scope widen verifies MbedTls pre-clean).
+
+### Pattern B — Address Static pool/fallback move (MISRA 8.9)
+
+Same 8.9 pattern S10.16 swept across the null-objects: file-scope
+storage that's only used inside a single helper. Each Address Static
+had two such statics — the pool array (used only inside
+`_HandleFromIndex`) and the pool-exhaustion fallback singleton (used
+only inside `_Create`). Both move inside their using function as
+function-scope `static`. Local names drop the `<Class>_` prefix per
+Tier 4 lowerCamelCase for locals. `InUse` and `Allocator` stay at
+file scope — `InUse` is referenced at file scope in the Allocator
+initializer (8.9 doesn't fire), and `Allocator` is referenced from
+both `_Create` and `_Destroy` (two functions — 8.9 doesn't fire).
+
+### Pattern C — FreeRtos timing constants move (MISRA 8.9)
+
+`FreeRtosTcpStream` and `FreeRtosDatagram` each had `static const
+TickType_t XXX = pdMS_TO_TICKS(N)` timing constants at file scope but
+each used inside one function. Move inside the using function as
+function-scope `static const`. `pdMS_TO_TICKS` is a compile-time
+constant expression given `configTICK_RATE_HZ`, so the initialiser
+stays valid.
+
+`READ_FAILED` in `FreeRtosTcpStream` stays at file scope — used by
+both `_Send` and `_Read`.
+
+### Pattern D — `(void) memset` in Address.c Initialise (MISRA 17.7)
+
+Three identical sites — `Posix`, `Winsock`, `FreeRtos` Address
+`_Initialise` — each calling `memset(&self->Sockaddr, 0, ...)` and
+discarding the `void*` return value implicitly. Explicit `(void)`
+cast satisfies 17.7.
+
+### Pattern E — Capture errno at the call site (MISRA 22.10)
+
+Three sites: PosixDatagram `sendto`, PosixTcpStream `connect`, and the
+shared `PosixTcpStream_WouldBlock` helper. cppcheck-misra rule 22.10
+requires errno reads to sit immediately after the C-library function
+that may set it, with no intervening calls — the `else if (errno == ...)`
+shape after a `>= 0` check trips the rule, and a helper that reads
+errno at the bottom of a call stack can't satisfy the locality test at
+all.
+
+Three fixes:
+- PosixDatagram_SendTo: `int sendErrno = (sent < 0) ? errno : 0;`
+  immediately after `sendto`; test the local.
+- PosixTcpStream_Connect: same shape with `connectErrno`.
+- PosixTcpStream_WouldBlock: change signature to take `int err` so
+  the helper is pure; `_Read` captures `recvErrno` immediately after
+  `recv` and passes it in.
+
+### Pattern G — D.009 widens to absorb 7 anonymous-enum 5.7 sites + 1 new entry + 1 unmasked 2.4
+
+Seven 5.7-on-anonymous-enum suppressions migrated from the D.003 block
+to the D.009 block: `TlsStream`, `GetAddrInfoResolver`, `PosixDatagram`,
+`PosixSleep`, `PosixTcpStream`, `WinsockResolver`, `WinsockTcpStream`,
+plus `FreeRtosTcpStream` whose anchor also shifted :45 → :27 after
+Pattern C removed three file-scope timing constants.
+
+One new D.009 entry for `FreeRtosResolver.c:21` — the
+`GETADDRINFO_SUCCESS` anonymous enum landed by S08.08.
+
+One new D.009 2.4 entry for `UdpPayload.h:15` — the 2.4 was always
+there but masked by cppcheck's dedup against the existing 5.7
+suppression; surfaced once Pattern C narrowed the FreeRtos transport
+inclusion chain. Same unmasking phenomenon S10.16's DEVLOG flagged.
+
+Only one true struct-tag 5.7 in scope (`SolidSyslogAddress.h:10`)
+stays in the D.003 block.
+
+### Pattern F — D.002 anchor refresh + new sites
+
+Pattern B/C/E moves shifted line numbers in several files. Anchor
+refresh on the affected D.002 11.2 / 11.3 / 11.5 suppressions
+(11 in-scope refreshes), plus:
+
+- 3 new 11.2 entries for Address.c sources — cppcheck-misra fires both
+  11.2 and 11.3 at the same opaque-impl downcast line in `_Initialise`;
+  only 11.3 was historically suppressed.
+- 4 11.3 orphan refreshes outside S10.17's strict scope
+  (StdAtomicCounter, WindowsAtomicCounter, FreeRtosMutex, FatFsFile) —
+  pre-existing anchor drift caused by the E11 `*Static.c` split. Same
+  fix-when-we-see-it precedent as S10.16's null-object sweep, no need
+  to revisit closed S10.13.
+
+### Acceptance
+
+- Zero in-scope cppcheck-misra unsuppressed findings.
+- Zero in-scope `analyze-tidy` warnings.
+- 1290 / 1290 tests pass on `debug` and `sanitize` (ASan + UBSan).
+- Tree-wide coverage 99.9% (2924 / 2928 lines, 602 / 602 functions);
+  uncovered lines sit in `BlockStoreStatic.c` and `PosixMutex.c` and
+  are pre-existing — none of the changed files lost coverage.
+- clang-format clean tree-wide.
+- No new deviation rows in `docs/misra-deviations.md`; count bumps on
+  D.002 (3 new 11.2 entries) and D.009 (1 new 5.7 + 1 new 2.4).
+
+### Carry-forward for S10.18 / S10.19 / S10.20
+
+- Same `== true` form will need extending to any new pool-backed class
+  that lands before S10.20 (rare — most classes are already split).
+- Sister anonymous-enum 5.7 sites in the D.003 block belong to storage
+  / engine groups (`BlockSequence`, `RecordStore`, `Circular*`, `Crc16`,
+  `FileBlockDevice`, etc.) — S10.18 / S10.19 migrate them.
+
+---
+
 ## 2026-05-22 — S10.16 Senders conformance
 
 Closes S10.16 (#389). Fifth per-group conformance story in E10,

Platform/Atomics/Source/SolidSyslogStdAtomicCounterStatic.c

@@ -27,7 +27,7 @@ struct SolidSyslogAtomicCounter* SolidSyslogStdAtomicCounter_Create(void)
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&StdAtomicCounter_Allocator);
     struct SolidSyslogAtomicCounter* handle = SolidSyslogNullAtomicCounter_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&StdAtomicCounter_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&StdAtomicCounter_Allocator, index) == true)
     {
         StdAtomicCounter_Initialise(&StdAtomicCounter_Pool[index].Base);
         handle = &StdAtomicCounter_Pool[index].Base;

Platform/FatFs/Source/SolidSyslogFatFsFileStatic.c

@@ -24,7 +24,7 @@ struct SolidSyslogFile* SolidSyslogFatFsFile_Create(void)
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&FatFsFile_Allocator);
     struct SolidSyslogFile* handle = SolidSyslogNullFile_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&FatFsFile_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&FatFsFile_Allocator, index) == true)
     {
         FatFsFile_Initialise(&FatFsFile_Pool[index].Base);
         handle = &FatFsFile_Pool[index].Base;

Platform/FreeRtos/Source/SolidSyslogFreeRtosAddress.c

@@ -7,7 +7,7 @@ struct SolidSyslogAddress;
 void FreeRtosAddress_Initialise(struct SolidSyslogAddress* base)
 {
     struct SolidSyslogFreeRtosAddress* self = (struct SolidSyslogFreeRtosAddress*) base;
-    memset(&self->Sockaddr, 0, sizeof(self->Sockaddr));
+    (void) memset(&self->Sockaddr, 0, sizeof(self->Sockaddr));
 }
 
 void FreeRtosAddress_Cleanup(struct SolidSyslogAddress* base)

Platform/FreeRtos/Source/SolidSyslogFreeRtosAddressStatic.c

@@ -17,24 +17,24 @@ static inline size_t FreeRtosAddress_IndexFromHandle(const struct SolidSyslogAdd
 static inline void FreeRtosAddress_CleanupAtIndex(size_t index, void* context);
 
 static bool FreeRtosAddress_InUse[SOLIDSYSLOG_ADDRESS_POOL_SIZE];
-static struct SolidSyslogFreeRtosAddress FreeRtosAddress_Pool[SOLIDSYSLOG_ADDRESS_POOL_SIZE];
 static struct SolidSyslogPoolAllocator FreeRtosAddress_Allocator = {
     FreeRtosAddress_InUse,
     SOLIDSYSLOG_ADDRESS_POOL_SIZE
 };
 
-/* TU-private fallback returned when the pool is exhausted. Sized as a real
- * SolidSyslogFreeRtosAddress so a Resolver overwrite at the exhausted-fallback
- * call site is bounded — same freertos_sockaddr storage as any pooled slot.
- * Not a per-Sender slot: multi-overflow integrators share this storage and
- * race on it. Bumping SOLIDSYSLOG_ADDRESS_POOL_SIZE removes the race. */
-static struct SolidSyslogFreeRtosAddress FreeRtosAddress_Fallback;
-
 struct SolidSyslogAddress* SolidSyslogFreeRtosAddress_Create(void)
 {
+    /* TU-private fallback returned when the pool is exhausted. Sized as
+     * a real SolidSyslogFreeRtosAddress so a Resolver overwrite at the
+     * exhausted-fallback call site is bounded — same freertos_sockaddr
+     * storage as any pooled slot. Not a per-Sender slot: multi-overflow
+     * integrators share this storage and race on it. Bumping
+     * SOLIDSYSLOG_ADDRESS_POOL_SIZE removes the race. */
+    static struct SolidSyslogFreeRtosAddress fallback;
+
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&FreeRtosAddress_Allocator);
-    struct SolidSyslogAddress* handle = (struct SolidSyslogAddress*) &FreeRtosAddress_Fallback;
-    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosAddress_Allocator, index))
+    struct SolidSyslogAddress* handle = (struct SolidSyslogAddress*) &fallback;
+    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosAddress_Allocator, index) == true)
     {
         handle = FreeRtosAddress_HandleFromIndex(index);
         FreeRtosAddress_Initialise(handle);
@@ -48,7 +48,8 @@ struct SolidSyslogAddress* SolidSyslogFreeRtosAddress_Create(void)
 
 static inline struct SolidSyslogAddress* FreeRtosAddress_HandleFromIndex(size_t index)
 {
-    return (struct SolidSyslogAddress*) &FreeRtosAddress_Pool[index];
+    static struct SolidSyslogFreeRtosAddress pool[SOLIDSYSLOG_ADDRESS_POOL_SIZE];
+    return (struct SolidSyslogAddress*) &pool[index];
 }
 
 void SolidSyslogFreeRtosAddress_Destroy(struct SolidSyslogAddress* base)

Platform/FreeRtos/Source/SolidSyslogFreeRtosDatagram.c

@@ -18,13 +18,6 @@
 #include "SolidSyslogNullDatagram.h"
 #include "SolidSyslogUdpPayload.h"
 
-/* Time the calling task yields after issuing an ARP probe so the IP task can
- * receive the reply and populate the cache before we attempt FreeRTOS_sendto.
- * 50 ms is generous against typical sub-millisecond LAN ARP RTT but short
- * enough that the first send latency stays tolerable. If the reply hasn't
- * arrived in time the sendto is allowed to fail or be dropped — UDP semantics. */
-static const TickType_t ARP_RESOLUTION_WAIT_TICKS = pdMS_TO_TICKS(50);
-
 static bool FreeRtosDatagram_Open(struct SolidSyslogDatagram* base);
 static enum SolidSyslogDatagramSendResult FreeRtosDatagram_SendTo(
     struct SolidSyslogDatagram* base,
@@ -117,6 +110,14 @@ static enum SolidSyslogDatagramSendResult FreeRtosDatagram_SendTo(
  * retry belongs in the store-and-forward layer above, not here. */
 static inline void FreeRtosDatagram_PrimeArpIfMissing(uint32_t ip)
 {
+    /* Time the calling task yields after issuing an ARP probe so the IP
+     * task can receive the reply and populate the cache before we
+     * attempt FreeRTOS_sendto. 50 ms is generous against typical
+     * sub-millisecond LAN ARP RTT but short enough that the first send
+     * latency stays tolerable. If the reply hasn't arrived in time the
+     * sendto is allowed to fail or be dropped — UDP semantics. */
+    static const TickType_t ARP_RESOLUTION_WAIT_TICKS = pdMS_TO_TICKS(50);
+
     if (xIsIPInARPCache(ip) == pdFALSE)
     {
         FreeRTOS_OutputARPRequest(ip);

Platform/FreeRtos/Source/SolidSyslogFreeRtosDatagramStatic.c

@@ -27,7 +27,7 @@ struct SolidSyslogDatagram* SolidSyslogFreeRtosDatagram_Create(void)
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&FreeRtosDatagram_Allocator);
     struct SolidSyslogDatagram* handle = SolidSyslogNullDatagram_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosDatagram_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosDatagram_Allocator, index) == true)
     {
         FreeRtosDatagram_Initialise(&FreeRtosDatagram_Pool[index].Base);
         handle = &FreeRtosDatagram_Pool[index].Base;

Platform/FreeRtos/Source/SolidSyslogFreeRtosMutexStatic.c

@@ -27,7 +27,7 @@ struct SolidSyslogMutex* SolidSyslogFreeRtosMutex_Create(void)
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&FreeRtosMutex_Allocator);
     struct SolidSyslogMutex* handle = SolidSyslogNullMutex_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosMutex_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosMutex_Allocator, index) == true)
     {
         FreeRtosMutex_Initialise(&FreeRtosMutex_Pool[index].Base);
         handle = &FreeRtosMutex_Pool[index].Base;

Platform/FreeRtos/Source/SolidSyslogFreeRtosResolverStatic.c

@@ -27,7 +27,7 @@ struct SolidSyslogResolver* SolidSyslogFreeRtosResolver_Create(void)
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&FreeRtosResolver_Allocator);
     struct SolidSyslogResolver* handle = SolidSyslogNullResolver_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosResolver_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosResolver_Allocator, index) == true)
     {
         FreeRtosResolver_Initialise(&FreeRtosResolver_Pool[index].Base);
         handle = &FreeRtosResolver_Pool[index].Base;

Platform/FreeRtos/Source/SolidSyslogFreeRtosTcpStream.c

@@ -19,24 +19,6 @@
 #include "SolidSyslogStream.h"
 #include "SolidSyslogStreamDefinition.h"
 
-/* 200 ms is short enough that the Service task keeps draining predictably
- * during an outage, long enough for a healthy peer to ACK over slirp/LAN.
- * Both SO_SNDTIMEO and SO_RCVTIMEO are set before FreeRTOS_connect —
- * upstream gates connect on SO_RCVTIMEO, but we set both as belt-and-braces
- * against an upstream change. After connect both timeouts go back to 0 so
- * subsequent Send/Read follow the non-blocking single-call contract from
- * SolidSyslogStream. */
-static const TickType_t CONNECT_TIMEOUT_TICKS = pdMS_TO_TICKS(200);
-static const TickType_t NO_TIMEOUT_TICKS = 0;
-
-/* Yield window for the IP task to receive an ARP reply and populate the
- * cache before we attempt FreeRTOS_connect. Mirrors the established
- * SolidSyslogFreeRtosDatagram pattern (see [[freertos-arp-first-packet]]) —
- * without this, a cold-start TCP connect fires SYN before ARP resolves, the
- * SYN is dropped at the IP layer, and the bounded 200 ms RCV-timeout
- * connect expires before the retransmit ARP-and-resend cycle completes. */
-static const TickType_t ARP_RESOLUTION_WAIT_TICKS = pdMS_TO_TICKS(50);
-
 /* SolidSyslogStream_Read returns < 0 to signal EOF/error (socket closed
  * internally); -1 is the in-tree convention shared with Posix/Winsock. */
 static const SolidSyslogSsize READ_FAILED = -1;
@@ -170,6 +152,16 @@ static bool FreeRtosTcpStream_TryConnect(
     const struct SolidSyslogAddress* addr
 )
 {
+    /* 200 ms is short enough that the Service task keeps draining
+     * predictably during an outage, long enough for a healthy peer to
+     * ACK over slirp/LAN. Both SO_SNDTIMEO and SO_RCVTIMEO are set
+     * before FreeRTOS_connect — upstream gates connect on SO_RCVTIMEO,
+     * but we set both as belt-and-braces against an upstream change.
+     * After connect both timeouts go back to 0 so subsequent Send/Read
+     * follow the non-blocking single-call contract from
+     * SolidSyslogStream. */
+    static const TickType_t CONNECT_TIMEOUT_TICKS = pdMS_TO_TICKS(200);
+
     const struct freertos_sockaddr* dest = SolidSyslogFreeRtosAddress_AsConstFreertosSockaddr(addr);
     FreeRtosTcpStream_PrimeArpIfMissing(dest->sin_address.ulIP_IPv4);
     FreeRtosTcpStream_SetSendTimeout(self->Socket, CONNECT_TIMEOUT_TICKS);
@@ -184,6 +176,15 @@ static bool FreeRtosTcpStream_TryConnect(
  * cycle completes. Symmetric with SolidSyslogFreeRtosDatagram::SendTo. */
 static inline void FreeRtosTcpStream_PrimeArpIfMissing(uint32_t ip)
 {
+    /* Yield window for the IP task to receive an ARP reply and populate
+     * the cache before we attempt FreeRTOS_connect. Mirrors the
+     * established SolidSyslogFreeRtosDatagram pattern (see
+     * [[freertos-arp-first-packet]]) — without this, a cold-start TCP
+     * connect fires SYN before ARP resolves, the SYN is dropped at the
+     * IP layer, and the bounded 200 ms RCV-timeout connect expires
+     * before the retransmit ARP-and-resend cycle completes. */
+    static const TickType_t ARP_RESOLUTION_WAIT_TICKS = pdMS_TO_TICKS(50);
+
     if (xIsIPInARPCache(ip) == pdFALSE)
     {
         FreeRTOS_OutputARPRequest(ip);
@@ -193,6 +194,8 @@ static inline void FreeRtosTcpStream_PrimeArpIfMissing(uint32_t ip)
 
 static void FreeRtosTcpStream_ClearTimeouts(Socket_t socket)
 {
+    static const TickType_t NO_TIMEOUT_TICKS = 0;
+
     FreeRtosTcpStream_SetSendTimeout(socket, NO_TIMEOUT_TICKS);
     FreeRtosTcpStream_SetRecvTimeout(socket, NO_TIMEOUT_TICKS);
 }

Platform/FreeRtos/Source/SolidSyslogFreeRtosTcpStreamStatic.c

@@ -27,7 +27,7 @@ struct SolidSyslogStream* SolidSyslogFreeRtosTcpStream_Create(void)
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&FreeRtosTcpStream_Allocator);
     struct SolidSyslogStream* handle = SolidSyslogNullStream_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosTcpStream_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&FreeRtosTcpStream_Allocator, index) == true)
     {
         FreeRtosTcpStream_Initialise(&FreeRtosTcpStream_Pool[index].Base);
         handle = &FreeRtosTcpStream_Pool[index].Base;

Platform/MbedTls/Source/SolidSyslogMbedTlsStreamStatic.c

@@ -27,7 +27,7 @@ struct SolidSyslogStream* SolidSyslogMbedTlsStream_Create(const struct SolidSysl
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&MbedTlsStream_Allocator);
     struct SolidSyslogStream* handle = SolidSyslogNullStream_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&MbedTlsStream_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&MbedTlsStream_Allocator, index) == true)
     {
         MbedTlsStream_Initialise(&MbedTlsStream_Pool[index].Base, config);
         handle = &MbedTlsStream_Pool[index].Base;

Platform/OpenSsl/Source/SolidSyslogTlsStreamStatic.c

@@ -24,7 +24,7 @@ struct SolidSyslogStream* SolidSyslogTlsStream_Create(const struct SolidSyslogTl
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&TlsStream_Allocator);
     struct SolidSyslogStream* handle = SolidSyslogNullStream_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&TlsStream_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&TlsStream_Allocator, index) == true)
     {
         TlsStream_Initialise(&TlsStream_Pool[index].Base, config);
         handle = &TlsStream_Pool[index].Base;

Platform/Posix/Source/SolidSyslogGetAddrInfoResolverStatic.c

@@ -27,7 +27,7 @@ struct SolidSyslogResolver* SolidSyslogGetAddrInfoResolver_Create(void)
 {
     size_t index = SolidSyslogPoolAllocator_AcquireFirstFree(&GetAddrInfoResolver_Allocator);
     struct SolidSyslogResolver* handle = SolidSyslogNullResolver_Get();
-    if (SolidSyslogPoolAllocator_IndexIsValid(&GetAddrInfoResolver_Allocator, index))
+    if (SolidSyslogPoolAllocator_IndexIsValid(&GetAddrInfoResolver_Allocator, index) == true)
     {
         GetAddrInfoResolver_Initialise(&GetAddrInfoResolver_Pool[index].Base);
         handle = &GetAddrInfoResolver_Pool[index].Base;