diff --git a/Bdd/Targets/Common/BddTargetStderrErrorHandler.c b/Bdd/Targets/Common/BddTargetStderrErrorHandler.c index e5c61092..07334eb8 100644 --- a/Bdd/Targets/Common/BddTargetStderrErrorHandler.c +++ b/Bdd/Targets/Common/BddTargetStderrErrorHandler.c @@ -7,27 +7,30 @@ #include "SolidSyslogError.h" #include "SolidSyslogPrival.h" -static void StderrErrorHandlerEx( - void* context, - enum SolidSyslogSeverity severity, - const struct SolidSyslogErrorSource* source, - uint8_t code -) +static void StderrErrorHandlerEx(void* context, const struct SolidSyslogErrorEvent* event) { (void) context; const char* sourceName = ""; const char* message = ""; + const struct SolidSyslogErrorSource* source = event->Source; if (source != NULL) { sourceName = source->Name; if (source->AsString != NULL) { - message = source->AsString(code); + message = source->AsString((uint8_t) event->Detail); } } - if (severity <= SOLIDSYSLOG_SEVERITY_ERROR) + if (event->Severity <= SOLIDSYSLOG_SEVERITY_ERROR) { - (void) fprintf(stderr, "BDD-TARGET: FATAL: [%s/%u] %s\n", sourceName, (unsigned) code, message); + (void) fprintf( + stderr, + "BDD-TARGET: FATAL: [%s cat=%u detail=%ld] %s\n", + sourceName, + (unsigned) event->Category, + (long) event->Detail, + message + ); (void) fflush(stderr); _Exit(3); } @@ -35,10 +38,11 @@ static void StderrErrorHandlerEx( { (void) fprintf( stderr, - "[solidsyslog] severity=%d [%s/%u] %s\n", - (int) severity, + "[solidsyslog] severity=%d [%s cat=%u detail=%ld] %s\n", + (int) event->Severity, sourceName, - (unsigned) code, + (unsigned) event->Category, + (long) event->Detail, message ); } diff --git a/Bdd/Targets/FreeRtos/main.c b/Bdd/Targets/FreeRtos/main.c index dfd1d0cd..f1e9929f 100644 --- a/Bdd/Targets/FreeRtos/main.c +++ b/Bdd/Targets/FreeRtos/main.c @@ -485,25 +485,28 @@ static void GetAppName(struct SolidSyslogFormatter* formatter) * tzKnown=0, isSynced=0. SolidSyslogConfig.Clock=NULL drops through to the * library's NilClock; the resulting all-zero SolidSyslogTimestamp fails * TimestampIsValid in Core/Source/SolidSyslog.c and emits "-" on the wire. */ -static void ErrorHandlerEx( - void* context, - enum SolidSyslogSeverity severity, - const struct SolidSyslogErrorSource* source, - uint8_t code -) +static void ErrorHandlerEx(void* context, const struct SolidSyslogErrorEvent* event) { (void) context; const char* sourceName = ""; const char* message = ""; + const struct SolidSyslogErrorSource* source = event->Source; if (source != NULL) { sourceName = source->Name; if (source->AsString != NULL) { - message = source->AsString(code); + message = source->AsString((uint8_t) event->Detail); } } - (void) printf("[solidsyslog] severity=%d [%s/%u] %s\n", (int) severity, sourceName, (unsigned) code, message); + (void) printf( + "[solidsyslog] severity=%d [%s cat=%u detail=%ld] %s\n", + (int) event->Severity, + sourceName, + (unsigned) event->Category, + (long) event->Detail, + message + ); } static void GetTimeQuality(struct SolidSyslogTimeQuality* timeQuality) diff --git a/Bdd/Targets/FreeRtosLwip/main.c b/Bdd/Targets/FreeRtosLwip/main.c index eb963e2d..d5bb0a66 100644 --- a/Bdd/Targets/FreeRtosLwip/main.c +++ b/Bdd/Targets/FreeRtosLwip/main.c @@ -372,25 +372,28 @@ static uint32_t GetEndpointVersion(void) return endpointVersion; } -static void ErrorHandlerEx( - void* context, - enum SolidSyslogSeverity severity, - const struct SolidSyslogErrorSource* source, - uint8_t code -) +static void ErrorHandlerEx(void* context, const struct SolidSyslogErrorEvent* event) { (void) context; const char* sourceName = ""; const char* message = ""; + const struct SolidSyslogErrorSource* source = event->Source; if (source != NULL) { sourceName = source->Name; if (source->AsString != NULL) { - message = source->AsString(code); + message = source->AsString((uint8_t) event->Detail); } } - (void) printf("[solidsyslog] severity=%d [%s/%u] %s\n", (int) severity, sourceName, (unsigned) code, message); + (void) printf( + "[solidsyslog] severity=%d [%s cat=%u detail=%ld] %s\n", + (int) event->Severity, + sourceName, + (unsigned) event->Category, + (long) event->Detail, + message + ); } static bool OnSet(const char* name, const char* value) diff --git a/CLAUDE.md b/CLAUDE.md index 678354d7..a705a30e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -318,7 +318,8 @@ live under `Core/Interface/`; platform-specific helpers (the `SolidSyslogPosix*` | `SolidSyslog.h` | Application code that logs events | `SolidSyslogMessage`, `SolidSyslog_Log(handle, message)`, `SolidSyslog_Service(handle)`. `struct SolidSyslog` opaque. | | `SolidSyslogConfig.h` | System setup code | `SolidSyslogConfig`, `SolidSyslog_Create(config) → handle`, `SolidSyslog_Destroy(handle)`. Instance struct lives in a library-internal static pool (E11; tunable `SOLIDSYSLOG_POOL_SIZE`, default `1U`). Pool-exhaustion fallback is a TU-private `NullInstance` wired to `SolidSyslogNull{Buffer,Sender,Store}_Get()` siblings — `_Log`/`_Service` against it dispatch through Null vtables and silently drop. | | `SolidSyslogErrors.h` | Any code installing an error handler that wants to react to SolidSyslog-singleton events (pointer-identity match on `SolidSyslogErrorSource`, switch on `enum SolidSyslogErrors`) | `enum SolidSyslogErrors` (`SOLIDSYSLOG_ERROR_*` codes + `SOLIDSYSLOG_ERROR_MAX` bookend), `extern const struct SolidSyslogErrorSource SolidSyslogErrorSource`. Integrators ignore if not handling errors per source. | -| `SolidSyslogError.h` | Any code installing a handler to react to library-internal errors (NULL guards, send failures); also the library-internal call site for emitting them | `SolidSyslogErrorHandler` typedef, `SolidSyslog_SetErrorHandler(handler, context)`, `SolidSyslog_Error(severity, message)`. Default handler is a silent no-op; setting `handler = NULL` restores the default. Single global slot — intended for setup-time configuration, not synchronised with concurrent `Error` calls. | +| `SolidSyslogError.h` | Any code installing a handler to react to library-internal errors (NULL guards, send failures); also the library-internal call site for emitting them | `struct SolidSyslogErrorEvent` (`Severity`, `Source`, `uint16_t Category`, `int32_t Detail`), `SolidSyslogErrorHandler` typedef (`void(void* context, const struct SolidSyslogErrorEvent* event)`), `SolidSyslog_SetErrorHandler(handler, context)`, `SolidSyslog_Error(severity, source, category, detail)`. The handler reads three orthogonal axes off the event: `Source` (extensible identity, pointer-identity match), `Category` (portable reaction axis — see `SolidSyslogErrorCategory.h`), `Detail` (per-class `enum SolidSyslogErrors` value today, native `errno`/`X509_V_ERR_*` later). Default handler is a silent no-op; setting `handler = NULL` restores the default. Single global slot — intended for setup-time configuration, not synchronised with concurrent `Error` calls. | +| `SolidSyslogErrorCategory.h` | Any handler switching on the portable category axis; any emit site picking a category | Universal lifecycle category macros (`SOLIDSYSLOG_CAT_BAD_CONFIG` / `_BAD_ARGUMENT` / `_POOL_EXHAUSTED` / `_UNKNOWN_DESTROY`, all `uint16_t`) + per-role base ranges (`SOLIDSYSLOG_CAT__BASE`, errno-domain style; a role occupies `[BASE, BASE + 0xFF]`, `0xC000+` reserved for integrator-defined roles). Category constants are `uint16_t` macros carrying their own cast so emit sites stay clean; the wire type is `uint16_t` (not an enum) so integrator classes can supply their own categories without being boxed into a library enum. Role-specific categories live in `SolidSyslogCategories.h` beside each `*Definition.h` (`SolidSyslogResolverCategories.h` → `_RESOLVER_RESOLVE_FAILED`; `SolidSyslogTlsStreamCategories.h` → `_TLSSTREAM_INIT_FAILED` / `_HANDSHAKE_FAILED`; `SolidSyslogSecurityPolicyCategories.h` → `_SECURITYPOLICY_KEY_UNAVAILABLE` / `_SEAL_FAILED` / `_OPEN_FAILED`; `SolidSyslogBufferCategories.h` → `_BUFFER_BACKEND_FAILED`). A category is defined only once a live emit site raises it. | | `SolidSyslogConfigLock.h` | Setup code on systems where library-internal config-time critical sections (E11 pool `_Create`/`_Destroy` slot walks) may race across tasks or cores. Single-task setup needs nothing — defaults are no-ops. | `SolidSyslogConfigLockFunction` typedef (zero-arg `void(void)`), `SolidSyslog_SetConfigLock(lockFn, unlockFn)`, `SolidSyslog_LockConfig()`, `SolidSyslog_UnlockConfig()`. Pair API: both handlers installed together. `NULL` on either side restores that side's no-op default. Single global slot — intended for setup-time configuration, not synchronised with concurrent installs. Integrators wire `taskENTER_CRITICAL`/`taskEXIT_CRITICAL` (FreeRTOS), `pthread_mutex_lock`/`unlock` on a static `pthread_mutex_t` (POSIX), `EnterCriticalSection`/`LeaveCriticalSection` on a static `CRITICAL_SECTION` (Windows), or a spinlock pair. This is the only synchronisation primitive available to the Mutex and AtomicCounter pools for their own pool walks — chicken-and-egg eliminates their own injectables. | | `SolidSyslogStringFunction.h` | Any code needing the string-callback typedef | `SolidSyslogStringFunction` (callback writes into a `SolidSyslogFormatter*`) — used by `SolidSyslogConfig` (hostname/appName/processId), `SolidSyslogMetaSdConfig` (language), `SolidSyslogOriginSdConfig` | | `SolidSyslogFormatter.h` | Any code that formats into a bounded buffer | `SolidSyslogFormatter`, `SolidSyslogFormatterStorage`, `SOLIDSYSLOG_FORMATTER_STORAGE_SIZE`, `_Create`, `_FromStorage`, `_AsciiCharacter`, `_Bom`, `_BoundedString`, `_EscapedString`, `_PrintUsAsciiString`, `_Uint32`, `_TwoDigit`, `_FourDigit`, `_SixDigit`, `_AsFormattedBuffer`, `_Length` | diff --git a/Core/Interface/SolidSyslogBufferCategories.h b/Core/Interface/SolidSyslogBufferCategories.h new file mode 100644 index 00000000..a0b80208 --- /dev/null +++ b/Core/Interface/SolidSyslogBufferCategories.h @@ -0,0 +1,16 @@ +#ifndef SOLIDSYSLOGBUFFERCATEGORIES_H +#define SOLIDSYSLOGBUFFERCATEGORIES_H + +#include + +#include "SolidSyslogErrorCategory.h" + +/* + * Portable Buffer-role error categories. Any Buffer implementation reuses + * these; a portable handler switch on event->Category reacts to a buffer + * backend failure identically regardless of the underlying mechanism + * (POSIX message queue, ring, ...). + */ +#define SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED ((uint16_t) (SOLIDSYSLOG_CAT_BUFFER_BASE + 1U)) + +#endif /* SOLIDSYSLOGBUFFERCATEGORIES_H */ diff --git a/Core/Interface/SolidSyslogError.h b/Core/Interface/SolidSyslogError.h index 203d690b..bb284d84 100644 --- a/Core/Interface/SolidSyslogError.h +++ b/Core/Interface/SolidSyslogError.h @@ -14,18 +14,22 @@ EXTERN_C_BEGIN const char* (*AsString)(uint8_t code); }; - typedef void (*SolidSyslogErrorHandler)( - void* context, - enum SolidSyslogSeverity severity, - const struct SolidSyslogErrorSource* source, - uint8_t code - ); + struct SolidSyslogErrorEvent + { + enum SolidSyslogSeverity Severity; + const struct SolidSyslogErrorSource* Source; + uint16_t Category; + int32_t Detail; + }; + + typedef void (*SolidSyslogErrorHandler)(void* context, const struct SolidSyslogErrorEvent* event); void SolidSyslog_SetErrorHandler(SolidSyslogErrorHandler handler, void* context); void SolidSyslog_Error( enum SolidSyslogSeverity severity, const struct SolidSyslogErrorSource* source, - uint8_t code + uint16_t category, + int32_t detail ); EXTERN_C_END diff --git a/Core/Interface/SolidSyslogErrorCategory.h b/Core/Interface/SolidSyslogErrorCategory.h new file mode 100644 index 00000000..74677d5b --- /dev/null +++ b/Core/Interface/SolidSyslogErrorCategory.h @@ -0,0 +1,38 @@ +#ifndef SOLIDSYSLOGERRORCATEGORY_H +#define SOLIDSYSLOGERRORCATEGORY_H + +#include + +/* + * Portable error-category axis. Categories are library-owned constants + * organised errno-domain style: a low universal-lifecycle range, then one + * base per role family (declared beside that role's *Definition.h, off the + * bases below as BASE + n), then a reserved integrator range. 0xC000 and + * above is reserved for integrator-defined roles so custom backends never + * collide. + * + * The category constants carry their own (uint16_t) cast so emit sites stay + * clean — SolidSyslog_Error's category parameter is uint16_t (not an enum + * type), which is what lets integrator classes supply their own categories + * in the reserved range without being boxed into a library enum. + */ + +/* Universal lifecycle categories, available to every source. */ +#define SOLIDSYSLOG_CAT_BAD_CONFIG ((uint16_t) 0x0001U) +#define SOLIDSYSLOG_CAT_BAD_ARGUMENT ((uint16_t) 0x0002U) +#define SOLIDSYSLOG_CAT_POOL_EXHAUSTED ((uint16_t) 0x0003U) +#define SOLIDSYSLOG_CAT_UNKNOWN_DESTROY ((uint16_t) 0x0004U) + +/* + * Per-role base ranges. A role occupies [BASE, BASE + 0xFF]. A base is listed + * here only once a role family carries a role-specific category; roles that + * emit only the universal categories above need none. (0x0100 Sender and + * 0x0300 Stream are intentionally unallocated — those roles emit only + * universal categories today.) + */ +#define SOLIDSYSLOG_CAT_RESOLVER_BASE ((uint16_t) 0x0200U) +#define SOLIDSYSLOG_CAT_TLSSTREAM_BASE ((uint16_t) 0x0400U) +#define SOLIDSYSLOG_CAT_SECURITYPOLICY_BASE ((uint16_t) 0x0500U) +#define SOLIDSYSLOG_CAT_BUFFER_BASE ((uint16_t) 0x0600U) + +#endif /* SOLIDSYSLOGERRORCATEGORY_H */ diff --git a/Core/Interface/SolidSyslogResolverCategories.h b/Core/Interface/SolidSyslogResolverCategories.h new file mode 100644 index 00000000..642cb0c5 --- /dev/null +++ b/Core/Interface/SolidSyslogResolverCategories.h @@ -0,0 +1,15 @@ +#ifndef SOLIDSYSLOGRESOLVERCATEGORIES_H +#define SOLIDSYSLOGRESOLVERCATEGORIES_H + +#include + +#include "SolidSyslogErrorCategory.h" + +/* + * Portable Resolver-role error categories. Any Resolver implementation + * reuses these; a portable handler switch on event->Category works + * identically across every resolver backend. + */ +#define SOLIDSYSLOG_CAT_RESOLVER_RESOLVE_FAILED ((uint16_t) (SOLIDSYSLOG_CAT_RESOLVER_BASE + 1U)) + +#endif /* SOLIDSYSLOGRESOLVERCATEGORIES_H */ diff --git a/Core/Interface/SolidSyslogSecurityPolicyCategories.h b/Core/Interface/SolidSyslogSecurityPolicyCategories.h new file mode 100644 index 00000000..6e5d6d60 --- /dev/null +++ b/Core/Interface/SolidSyslogSecurityPolicyCategories.h @@ -0,0 +1,19 @@ +#ifndef SOLIDSYSLOGSECURITYPOLICYCATEGORIES_H +#define SOLIDSYSLOGSECURITYPOLICYCATEGORIES_H + +#include + +#include "SolidSyslogErrorCategory.h" + +/* + * Portable SecurityPolicy-role error categories, shared by every integrity / + * confidentiality policy (HMAC, AES-GCM, OpenSSL, Mbed TLS, ...). Seal (write + * side) and open (read side) are kept distinct because "a stored record can no + * longer be read back" is a materially different operational signal from + * "a record could not be written". + */ +#define SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE ((uint16_t) (SOLIDSYSLOG_CAT_SECURITYPOLICY_BASE + 1U)) +#define SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED ((uint16_t) (SOLIDSYSLOG_CAT_SECURITYPOLICY_BASE + 2U)) +#define SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED ((uint16_t) (SOLIDSYSLOG_CAT_SECURITYPOLICY_BASE + 3U)) + +#endif /* SOLIDSYSLOGSECURITYPOLICYCATEGORIES_H */ diff --git a/Core/Interface/SolidSyslogTlsStreamCategories.h b/Core/Interface/SolidSyslogTlsStreamCategories.h new file mode 100644 index 00000000..944de154 --- /dev/null +++ b/Core/Interface/SolidSyslogTlsStreamCategories.h @@ -0,0 +1,17 @@ +#ifndef SOLIDSYSLOGTLSSTREAMCATEGORIES_H +#define SOLIDSYSLOGTLSSTREAMCATEGORIES_H + +#include + +#include "SolidSyslogErrorCategory.h" + +/* + * Portable TLS-stream error categories, shared by every TLS backend (OpenSSL, + * Mbed TLS, or an integrator's own). A portable handler switch on + * event->Category reacts to a TLS init or handshake failure identically + * regardless of which TLS library produced it. + */ +#define SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED ((uint16_t) (SOLIDSYSLOG_CAT_TLSSTREAM_BASE + 1U)) +#define SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED ((uint16_t) (SOLIDSYSLOG_CAT_TLSSTREAM_BASE + 2U)) + +#endif /* SOLIDSYSLOGTLSSTREAMCATEGORIES_H */ diff --git a/Core/Source/SolidSyslog.c b/Core/Source/SolidSyslog.c index ab474553..b16372c6 100644 --- a/Core/Source/SolidSyslog.c +++ b/Core/Source/SolidSyslog.c @@ -7,6 +7,7 @@ #include "SolidSyslogBuffer.h" #include "SolidSyslogConfig.h" #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogErrors.h" #include "SolidSyslogFormatter.h" #include "SolidSyslogMessageFormatter.h" @@ -85,7 +86,8 @@ static void SolidSyslog_InstallBuffer(struct SolidSyslog* self, struct SolidSysl SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_CREATE_NULL_BUFFER + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SOLIDSYSLOG_ERROR_CREATE_NULL_BUFFER ); } else @@ -101,7 +103,8 @@ static void SolidSyslog_InstallSender(struct SolidSyslog* self, struct SolidSysl SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_CREATE_NULL_SENDER + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SOLIDSYSLOG_ERROR_CREATE_NULL_SENDER ); } else @@ -117,7 +120,8 @@ static void SolidSyslog_InstallStore(struct SolidSyslog* self, struct SolidSyslo SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_CREATE_NULL_STORE + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SOLIDSYSLOG_ERROR_CREATE_NULL_STORE ); } else @@ -172,7 +176,8 @@ static void SolidSyslog_InstallStructuredData( SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_CREATE_INCONSISTENT_SD + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SOLIDSYSLOG_ERROR_CREATE_INCONSISTENT_SD ); } else @@ -189,7 +194,8 @@ void SolidSyslog_Service(struct SolidSyslog* handle) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_SERVICE_NULL_HANDLE + SOLIDSYSLOG_CAT_BAD_ARGUMENT, + (int32_t) SOLIDSYSLOG_ERROR_SERVICE_NULL_HANDLE ); } else if (SolidSyslog_IsServiceEnabled(handle)) @@ -255,7 +261,8 @@ void SolidSyslog_Log(struct SolidSyslog* handle, const struct SolidSyslogMessage SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_LOG_NULL_HANDLE + SOLIDSYSLOG_CAT_BAD_ARGUMENT, + (int32_t) SOLIDSYSLOG_ERROR_LOG_NULL_HANDLE ); } else if (message == NULL) @@ -263,7 +270,8 @@ void SolidSyslog_Log(struct SolidSyslog* handle, const struct SolidSyslogMessage SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_LOG_NULL_MESSAGE + SOLIDSYSLOG_CAT_BAD_ARGUMENT, + (int32_t) SOLIDSYSLOG_ERROR_LOG_NULL_MESSAGE ); } else diff --git a/Core/Source/SolidSyslogBlockStoreStatic.c b/Core/Source/SolidSyslogBlockStoreStatic.c index 7dc15e4a..993293b5 100644 --- a/Core/Source/SolidSyslogBlockStoreStatic.c +++ b/Core/Source/SolidSyslogBlockStoreStatic.c @@ -9,6 +9,7 @@ #include "SolidSyslogBlockStoreErrors.h" #include "SolidSyslogBlockStorePrivate.h" #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullSecurityPolicy.h" #include "SolidSyslogNullStore.h" #include "SolidSyslogPoolAllocator.h" @@ -67,7 +68,8 @@ struct SolidSyslogStore* SolidSyslogBlockStore_Create(const struct SolidSyslogBl SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &BlockStoreErrorSource, - (uint8_t) BLOCKSTORE_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) BLOCKSTORE_ERROR_POOL_EXHAUSTED ); } @@ -138,7 +140,8 @@ void SolidSyslogBlockStore_Destroy(struct SolidSyslogStore* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &BlockStoreErrorSource, - (uint8_t) BLOCKSTORE_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) BLOCKSTORE_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogCircularBufferStatic.c b/Core/Source/SolidSyslogCircularBufferStatic.c index c5ebd5a7..fbb5df20 100644 --- a/Core/Source/SolidSyslogCircularBufferStatic.c +++ b/Core/Source/SolidSyslogCircularBufferStatic.c @@ -7,6 +7,7 @@ #include "SolidSyslogCircularBufferErrors.h" #include "SolidSyslogCircularBufferPrivate.h" #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullBuffer.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -43,7 +44,8 @@ struct SolidSyslogBuffer* SolidSyslogCircularBuffer_Create( SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &CircularBufferErrorSource, - (uint8_t) CIRCULARBUFFER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) CIRCULARBUFFER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -60,7 +62,8 @@ void SolidSyslogCircularBuffer_Destroy(struct SolidSyslogBuffer* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &CircularBufferErrorSource, - (uint8_t) CIRCULARBUFFER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) CIRCULARBUFFER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogError.c b/Core/Source/SolidSyslogError.c index 1c0b36b4..0c444f20 100644 --- a/Core/Source/SolidSyslogError.c +++ b/Core/Source/SolidSyslogError.c @@ -2,17 +2,10 @@ #include -static void Error_NoOpErrorHandler( - void* context, - enum SolidSyslogSeverity severity, - const struct SolidSyslogErrorSource* source, - uint8_t code -) +static void Error_NoOpErrorHandler(void* context, const struct SolidSyslogErrorEvent* event) { (void) context; - (void) severity; - (void) source; - (void) code; + (void) event; } static SolidSyslogErrorHandler currentHandler = Error_NoOpErrorHandler; @@ -31,7 +24,13 @@ void SolidSyslog_SetErrorHandler(SolidSyslogErrorHandler handler, void* context) currentContext = context; } -void SolidSyslog_Error(enum SolidSyslogSeverity severity, const struct SolidSyslogErrorSource* source, uint8_t code) +void SolidSyslog_Error( + enum SolidSyslogSeverity severity, + const struct SolidSyslogErrorSource* source, + uint16_t category, + int32_t detail +) { - currentHandler(currentContext, severity, source, code); + const struct SolidSyslogErrorEvent event = {severity, source, category, detail}; + currentHandler(currentContext, &event); } diff --git a/Core/Source/SolidSyslogFileBlockDeviceStatic.c b/Core/Source/SolidSyslogFileBlockDeviceStatic.c index cfc94e78..de18c887 100644 --- a/Core/Source/SolidSyslogFileBlockDeviceStatic.c +++ b/Core/Source/SolidSyslogFileBlockDeviceStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFileBlockDeviceErrors.h" #include "SolidSyslogFileBlockDevicePrivate.h" #include "SolidSyslogNullBlockDevice.h" @@ -39,7 +40,8 @@ struct SolidSyslogBlockDevice* SolidSyslogFileBlockDevice_Create(struct SolidSys SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &FileBlockDeviceErrorSource, - (uint8_t) FILEBLOCKDEVICE_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) FILEBLOCKDEVICE_ERROR_POOL_EXHAUSTED ); } return result; @@ -56,7 +58,8 @@ void SolidSyslogFileBlockDevice_Destroy(struct SolidSyslogBlockDevice* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &FileBlockDeviceErrorSource, - (uint8_t) FILEBLOCKDEVICE_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) FILEBLOCKDEVICE_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogMetaSdStatic.c b/Core/Source/SolidSyslogMetaSdStatic.c index 8d551918..420f5638 100644 --- a/Core/Source/SolidSyslogMetaSdStatic.c +++ b/Core/Source/SolidSyslogMetaSdStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMetaSdErrors.h" #include "SolidSyslogMetaSdPrivate.h" #include "SolidSyslogNullSd.h" @@ -35,7 +36,12 @@ struct SolidSyslogStructuredData* SolidSyslogMetaSd_Create(const struct SolidSys } else { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &MetaSdErrorSource, (uint8_t) METASD_ERROR_POOL_EXHAUSTED); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &MetaSdErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) METASD_ERROR_POOL_EXHAUSTED + ); } } return result; @@ -46,11 +52,21 @@ static bool MetaSd_IsValidConfig(const struct SolidSyslogMetaSdConfig* config) bool valid = false; if (config == NULL) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, &MetaSdErrorSource, (uint8_t) METASD_ERROR_NULL_CONFIG); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_WARNING, + &MetaSdErrorSource, + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) METASD_ERROR_NULL_CONFIG + ); } else if (config->Counter == NULL) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, &MetaSdErrorSource, (uint8_t) METASD_ERROR_NULL_COUNTER); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_WARNING, + &MetaSdErrorSource, + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) METASD_ERROR_NULL_COUNTER + ); } else { @@ -66,7 +82,12 @@ void SolidSyslogMetaSd_Destroy(struct SolidSyslogStructuredData* base) SolidSyslogPoolAllocator_FreeIfInUse(&MetaSd_Allocator, index, MetaSd_CleanupAtIndex, NULL); if (!released) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, &MetaSdErrorSource, (uint8_t) METASD_ERROR_UNKNOWN_DESTROY); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_WARNING, + &MetaSdErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) METASD_ERROR_UNKNOWN_DESTROY + ); } } diff --git a/Core/Source/SolidSyslogOriginSdStatic.c b/Core/Source/SolidSyslogOriginSdStatic.c index b86a00a6..054cb5bc 100644 --- a/Core/Source/SolidSyslogOriginSdStatic.c +++ b/Core/Source/SolidSyslogOriginSdStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullSd.h" #include "SolidSyslogOriginSdErrors.h" #include "SolidSyslogOriginSdPrivate.h" @@ -32,7 +33,12 @@ struct SolidSyslogStructuredData* SolidSyslogOriginSd_Create(const struct SolidS } else { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &OriginSdErrorSource, (uint8_t) ORIGINSD_ERROR_POOL_EXHAUSTED); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &OriginSdErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) ORIGINSD_ERROR_POOL_EXHAUSTED + ); } return handle; } @@ -44,7 +50,12 @@ void SolidSyslogOriginSd_Destroy(struct SolidSyslogStructuredData* base) SolidSyslogPoolAllocator_FreeIfInUse(&OriginSd_Allocator, index, OriginSd_CleanupAtIndex, NULL); if (!released) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, &OriginSdErrorSource, (uint8_t) ORIGINSD_ERROR_UNKNOWN_DESTROY); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_WARNING, + &OriginSdErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) ORIGINSD_ERROR_UNKNOWN_DESTROY + ); } } diff --git a/Core/Source/SolidSyslogPassthroughBufferStatic.c b/Core/Source/SolidSyslogPassthroughBufferStatic.c index 0c9e5291..59d32d65 100644 --- a/Core/Source/SolidSyslogPassthroughBufferStatic.c +++ b/Core/Source/SolidSyslogPassthroughBufferStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullBuffer.h" #include "SolidSyslogPassthroughBufferErrors.h" #include "SolidSyslogPassthroughBufferPrivate.h" @@ -33,7 +34,8 @@ struct SolidSyslogBuffer* SolidSyslogPassthroughBuffer_Create(struct SolidSyslog SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PassthroughBufferErrorSource, - (uint8_t) PASSTHROUGHBUFFER_ERROR_NULL_SENDER + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) PASSTHROUGHBUFFER_ERROR_NULL_SENDER ); } else @@ -49,7 +51,8 @@ struct SolidSyslogBuffer* SolidSyslogPassthroughBuffer_Create(struct SolidSyslog SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PassthroughBufferErrorSource, - (uint8_t) PASSTHROUGHBUFFER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) PASSTHROUGHBUFFER_ERROR_POOL_EXHAUSTED ); } } @@ -71,7 +74,8 @@ void SolidSyslogPassthroughBuffer_Destroy(struct SolidSyslogBuffer* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PassthroughBufferErrorSource, - (uint8_t) PASSTHROUGHBUFFER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) PASSTHROUGHBUFFER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogStatic.c b/Core/Source/SolidSyslogStatic.c index 7f955884..9b248b19 100644 --- a/Core/Source/SolidSyslogStatic.c +++ b/Core/Source/SolidSyslogStatic.c @@ -5,12 +5,13 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogErrors.h" -#include "SolidSyslogPrival.h" #include "SolidSyslogNullBuffer.h" #include "SolidSyslogNullSender.h" #include "SolidSyslogNullStore.h" #include "SolidSyslogPoolAllocator.h" +#include "SolidSyslogPrival.h" #include "SolidSyslogPrivate.h" #include "SolidSyslogTunables.h" @@ -39,7 +40,8 @@ struct SolidSyslog* SolidSyslog_Create(const struct SolidSyslogConfig* config) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_CREATE_NULL_CONFIG + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SOLIDSYSLOG_ERROR_CREATE_NULL_CONFIG ); } else @@ -55,7 +57,8 @@ struct SolidSyslog* SolidSyslog_Create(const struct SolidSyslogConfig* config) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) SOLIDSYSLOG_ERROR_POOL_EXHAUSTED ); } } @@ -91,7 +94,8 @@ void SolidSyslog_Destroy(struct SolidSyslog* handle) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &SolidSyslogErrorSource, - (uint8_t) SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogStreamSenderStatic.c b/Core/Source/SolidSyslogStreamSenderStatic.c index 1afede8e..882c5667 100644 --- a/Core/Source/SolidSyslogStreamSenderStatic.c +++ b/Core/Source/SolidSyslogStreamSenderStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullSender.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -41,7 +42,8 @@ struct SolidSyslogSender* SolidSyslogStreamSender_Create(const struct SolidSyslo SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &StreamSenderErrorSource, - (uint8_t) STREAMSENDER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) STREAMSENDER_ERROR_POOL_EXHAUSTED ); } } @@ -56,7 +58,8 @@ static bool StreamSender_IsValidConfig(const struct SolidSyslogStreamSenderConfi SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &StreamSenderErrorSource, - (uint8_t) STREAMSENDER_ERROR_NULL_CONFIG + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) STREAMSENDER_ERROR_NULL_CONFIG ); } else if (config->Resolver == NULL) @@ -64,7 +67,8 @@ static bool StreamSender_IsValidConfig(const struct SolidSyslogStreamSenderConfi SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &StreamSenderErrorSource, - (uint8_t) STREAMSENDER_ERROR_NULL_RESOLVER + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) STREAMSENDER_ERROR_NULL_RESOLVER ); } else if (config->Stream == NULL) @@ -72,7 +76,8 @@ static bool StreamSender_IsValidConfig(const struct SolidSyslogStreamSenderConfi SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &StreamSenderErrorSource, - (uint8_t) STREAMSENDER_ERROR_NULL_STREAM + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) STREAMSENDER_ERROR_NULL_STREAM ); } else if (config->Address == NULL) @@ -80,7 +85,8 @@ static bool StreamSender_IsValidConfig(const struct SolidSyslogStreamSenderConfi SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &StreamSenderErrorSource, - (uint8_t) STREAMSENDER_ERROR_NULL_ADDRESS + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) STREAMSENDER_ERROR_NULL_ADDRESS ); } else @@ -101,7 +107,8 @@ void SolidSyslogStreamSender_Destroy(struct SolidSyslogSender* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &StreamSenderErrorSource, - (uint8_t) STREAMSENDER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) STREAMSENDER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogSwitchingSenderStatic.c b/Core/Source/SolidSyslogSwitchingSenderStatic.c index dd1442e2..b01cd7a2 100644 --- a/Core/Source/SolidSyslogSwitchingSenderStatic.c +++ b/Core/Source/SolidSyslogSwitchingSenderStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullSender.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -41,7 +42,8 @@ struct SolidSyslogSender* SolidSyslogSwitchingSender_Create(const struct SolidSy SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SwitchingSenderErrorSource, - (uint8_t) SWITCHINGSENDER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) SWITCHINGSENDER_ERROR_POOL_EXHAUSTED ); } } @@ -56,7 +58,8 @@ static bool SwitchingSender_IsValidConfig(const struct SolidSyslogSwitchingSende SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SwitchingSenderErrorSource, - (uint8_t) SWITCHINGSENDER_ERROR_NULL_CONFIG + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SWITCHINGSENDER_ERROR_NULL_CONFIG ); } else if (config->Senders == NULL) @@ -64,7 +67,8 @@ static bool SwitchingSender_IsValidConfig(const struct SolidSyslogSwitchingSende SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SwitchingSenderErrorSource, - (uint8_t) SWITCHINGSENDER_ERROR_NULL_SENDERS + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SWITCHINGSENDER_ERROR_NULL_SENDERS ); } else if (config->Selector == NULL) @@ -72,7 +76,8 @@ static bool SwitchingSender_IsValidConfig(const struct SolidSyslogSwitchingSende SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &SwitchingSenderErrorSource, - (uint8_t) SWITCHINGSENDER_ERROR_NULL_SELECTOR + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) SWITCHINGSENDER_ERROR_NULL_SELECTOR ); } else @@ -93,7 +98,8 @@ void SolidSyslogSwitchingSender_Destroy(struct SolidSyslogSender* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &SwitchingSenderErrorSource, - (uint8_t) SWITCHINGSENDER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) SWITCHINGSENDER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogTimeQualitySdStatic.c b/Core/Source/SolidSyslogTimeQualitySdStatic.c index a7647366..a48616ae 100644 --- a/Core/Source/SolidSyslogTimeQualitySdStatic.c +++ b/Core/Source/SolidSyslogTimeQualitySdStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullSd.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -33,7 +34,8 @@ struct SolidSyslogStructuredData* SolidSyslogTimeQualitySd_Create(SolidSyslogTim SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TimeQualitySdErrorSource, - (uint8_t) TIMEQUALITYSD_ERROR_NULL_CALLBACK + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) TIMEQUALITYSD_ERROR_NULL_CALLBACK ); } else @@ -49,7 +51,8 @@ struct SolidSyslogStructuredData* SolidSyslogTimeQualitySd_Create(SolidSyslogTim SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TimeQualitySdErrorSource, - (uint8_t) TIMEQUALITYSD_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) TIMEQUALITYSD_ERROR_POOL_EXHAUSTED ); } } @@ -67,7 +70,8 @@ void SolidSyslogTimeQualitySd_Destroy(struct SolidSyslogStructuredData* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &TimeQualitySdErrorSource, - (uint8_t) TIMEQUALITYSD_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) TIMEQUALITYSD_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Core/Source/SolidSyslogUdpSender.c b/Core/Source/SolidSyslogUdpSender.c index aa769a58..6b21613b 100644 --- a/Core/Source/SolidSyslogUdpSender.c +++ b/Core/Source/SolidSyslogUdpSender.c @@ -8,6 +8,7 @@ #include "SolidSyslogFormatter.h" #include "SolidSyslogNullSender.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogResolver.h" #include "SolidSyslogSenderDefinition.h" #include "SolidSyslogTransport.h" @@ -75,7 +76,8 @@ static bool UdpSender_Send(struct SolidSyslogSender* base, const void* buffer, s SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &UdpSenderErrorSource, - (uint8_t) UDPSENDER_ERROR_SEND_NULL_BUFFER + SOLIDSYSLOG_CAT_BAD_ARGUMENT, + (int32_t) UDPSENDER_ERROR_SEND_NULL_BUFFER ); } else diff --git a/Core/Source/SolidSyslogUdpSenderStatic.c b/Core/Source/SolidSyslogUdpSenderStatic.c index f937b7fe..cb2d1d8a 100644 --- a/Core/Source/SolidSyslogUdpSenderStatic.c +++ b/Core/Source/SolidSyslogUdpSenderStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullSender.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -38,7 +39,8 @@ struct SolidSyslogSender* SolidSyslogUdpSender_Create(const struct SolidSyslogUd SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &UdpSenderErrorSource, - (uint8_t) UDPSENDER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) UDPSENDER_ERROR_POOL_EXHAUSTED ); } } @@ -50,23 +52,48 @@ static bool UdpSender_IsValidConfig(const struct SolidSyslogUdpSenderConfig* con bool valid = false; if (config == NULL) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &UdpSenderErrorSource, (uint8_t) UDPSENDER_ERROR_NULL_CONFIG); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &UdpSenderErrorSource, + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) UDPSENDER_ERROR_NULL_CONFIG + ); } else if (config->Resolver == NULL) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &UdpSenderErrorSource, (uint8_t) UDPSENDER_ERROR_NULL_RESOLVER); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &UdpSenderErrorSource, + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) UDPSENDER_ERROR_NULL_RESOLVER + ); } else if (config->Datagram == NULL) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &UdpSenderErrorSource, (uint8_t) UDPSENDER_ERROR_NULL_DATAGRAM); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &UdpSenderErrorSource, + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) UDPSENDER_ERROR_NULL_DATAGRAM + ); } else if (config->Address == NULL) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &UdpSenderErrorSource, (uint8_t) UDPSENDER_ERROR_NULL_ADDRESS); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &UdpSenderErrorSource, + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) UDPSENDER_ERROR_NULL_ADDRESS + ); } else if (config->Endpoint == NULL) { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &UdpSenderErrorSource, (uint8_t) UDPSENDER_ERROR_NULL_ENDPOINT); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &UdpSenderErrorSource, + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) UDPSENDER_ERROR_NULL_ENDPOINT + ); } else { @@ -85,7 +112,8 @@ void SolidSyslogUdpSender_Destroy(struct SolidSyslogSender* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &UdpSenderErrorSource, - (uint8_t) UDPSENDER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) UDPSENDER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/DEVLOG.md b/DEVLOG.md index 9c2cc642..768c9164 100644 --- a/DEVLOG.md +++ b/DEVLOG.md @@ -13733,3 +13733,59 @@ MISRA rule — different category, doesn't set precedent. ### Open questions - None outstanding. + +## 2026-06-02 — S12.25 portable category axis + event-struct error boundary + +### Decisions + +- **Event struct over positional handler params.** `SolidSyslog_Error` is now + `(severity, source, uint16_t category, int32_t detail)` and the handler is + `void(void* context, const struct SolidSyslogErrorEvent* event)`. Collapsing the + handler to an event pointer sidesteps `bugprone-easily-swappable-parameters` and + makes future axes (timestamp, sequence) additive rather than another signature break. + `Detail` is `int32_t` so a future native code (`errno`, `X509_V_ERR_*`) drops in + without losing sign; today every detail is still the per-class `enum` value. +- **Category axis = `uint16_t` MACROS, not enums.** Spiked both. Anonymous-enum + categories forced explicit-literal values (to dodge a required-rule 10.4 on + `BASE + n`) and dragged in D.009 `2.4`/`5.7` suppressions on every category header. + Macros restored the errno-domain `BASE + n` design, embed their own `(uint16_t)` + cast so emit sites are cast-free, and — because every category has a live emit site + (decision below) — added **zero** new MISRA suppressions/deviations. The wire type + stays `uint16_t` (not an enum type) so integrator classes supply their own + `>= 0xC000` categories without being boxed into a library enum. +- **Detail stays a per-class enum** with a visible `(int32_t)` cast at the call site. + Category is monomorphic (always a library `uint16_t`) → embed the cast; detail is + polymorphic (enum today, native code later) → keep the cast visible so the widening + is explicit. Macro-ising detail would have re-opened #433 (lose the `_MAX` bookend + + type-honest `AsString` lookup) across 43+43 files for no real gain. +- **Taxonomy, by role, defined only where a live emit site raises it.** Universal: + `BAD_CONFIG`, `BAD_ARGUMENT` (new — runtime NULL args, distinct from setup-time + `BAD_CONFIG`; absorbed the old per-Sender `SEND_NULL_BUFFER` category and let the + Sender category header be dropped), `POOL_EXHAUSTED`, `UNKNOWN_DESTROY`. Role: + Resolver `RESOLVE_FAILED`; TlsStream `INIT_FAILED` / `HANDSHAKE_FAILED`; + SecurityPolicy `KEY_UNAVAILABLE` / `SEAL_FAILED` / `OPEN_FAILED` (seal vs open kept + distinct — "can't read a stored record back" is a different operational signal from + "couldn't write"); Buffer `BACKEND_FAILED`. With macros this is self-enforcing — a + category with no emit site is a cppcheck `2.5` failure. +- **Tests: event-based asserts + portable-category coverage.** New shared + `CHECK_ERROR_EVENT(src, cat, detail)` in `TestUtils.h`; `ErrorHandlerFake` captures + the event (`_LastCategory` / `_LastDetail`, `_LastCode` retired). Every error + assertion across ~44 test files now checks the portable category alongside the + detail (3292 → 3406 checks). The crypto-policy `_Report(severity, code)` wrappers + gained a `category` parameter threaded from each call site. +- **Atomic by necessity.** The signature break cannot stay green split across PRs, so + the whole sweep (124 emit sites, ~44 test files, 4 BDD/FreeRtos handlers) lands in + one PR. Mechanical bulk done with auditable transform scripts; gcc + freertos-host + both green (1392 tests), cppcheck-misra clean, clang-format clean. + +### Deferred + +- Text decoupling / codes-only / i18n / dropping `AsString` — sibling story S12.26 + (the source struct deliberately keeps `AsString` here, so the bundled-text handler + is unchanged in behaviour). +- Structured-context payload / self-emit layer (#318) — sequence against this final + event shape later. + +### Open questions + +- None outstanding. diff --git a/Platform/Atomics/Source/SolidSyslogStdAtomicCounterStatic.c b/Platform/Atomics/Source/SolidSyslogStdAtomicCounterStatic.c index 679e580b..1fd29dd0 100644 --- a/Platform/Atomics/Source/SolidSyslogStdAtomicCounterStatic.c +++ b/Platform/Atomics/Source/SolidSyslogStdAtomicCounterStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullAtomicCounter.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -38,7 +39,8 @@ struct SolidSyslogAtomicCounter* SolidSyslogStdAtomicCounter_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &StdAtomicCounterErrorSource, - (uint8_t) STDATOMICCOUNTER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) STDATOMICCOUNTER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogStdAtomicCounter_Destroy(struct SolidSyslogAtomicCounter* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &StdAtomicCounterErrorSource, - (uint8_t) STDATOMICCOUNTER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) STDATOMICCOUNTER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/FatFs/Source/SolidSyslogFatFsFileStatic.c b/Platform/FatFs/Source/SolidSyslogFatFsFileStatic.c index 706b4d3c..a07c4a8d 100644 --- a/Platform/FatFs/Source/SolidSyslogFatFsFileStatic.c +++ b/Platform/FatFs/Source/SolidSyslogFatFsFileStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFatFsFileErrors.h" #include "SolidSyslogFatFsFilePrivate.h" #include "SolidSyslogNullFile.h" @@ -32,7 +33,12 @@ struct SolidSyslogFile* SolidSyslogFatFsFile_Create(void) } else { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &FatFsFileErrorSource, (uint8_t) FATFSFILE_ERROR_POOL_EXHAUSTED); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &FatFsFileErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) FATFSFILE_ERROR_POOL_EXHAUSTED + ); } return handle; } @@ -47,7 +53,8 @@ void SolidSyslogFatFsFile_Destroy(struct SolidSyslogFile* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &FatFsFileErrorSource, - (uint8_t) FATFSFILE_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) FATFSFILE_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutexStatic.c b/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutexStatic.c index a3968242..2f36bc7b 100644 --- a/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutexStatic.c +++ b/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutexStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFreeRtosMutexErrors.h" #include "SolidSyslogFreeRtosMutexPrivate.h" #include "SolidSyslogNullMutex.h" @@ -35,7 +36,8 @@ struct SolidSyslogMutex* SolidSyslogFreeRtosMutex_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &FreeRtosMutexErrorSource, - (uint8_t) FREERTOSMUTEX_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) FREERTOSMUTEX_ERROR_POOL_EXHAUSTED ); } return handle; @@ -52,7 +54,8 @@ void SolidSyslogFreeRtosMutex_Destroy(struct SolidSyslogMutex* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &FreeRtosMutexErrorSource, - (uint8_t) FREERTOSMUTEX_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) FREERTOSMUTEX_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c b/Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c index 1bcc808c..b1f47d47 100644 --- a/Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c +++ b/Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawAddressErrors.h" #include "SolidSyslogLwipRawAddressPrivate.h" #include "SolidSyslogPoolAllocator.h" @@ -42,7 +43,8 @@ struct SolidSyslogAddress* SolidSyslogLwipRawAddress_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &LwipRawAddressErrorSource, - (uint8_t) LWIPRAWADDRESS_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) LWIPRAWADDRESS_ERROR_POOL_EXHAUSTED ); } return handle; @@ -65,7 +67,8 @@ void SolidSyslogLwipRawAddress_Destroy(struct SolidSyslogAddress* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &LwipRawAddressErrorSource, - (uint8_t) LWIPRAWADDRESS_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) LWIPRAWADDRESS_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/LwipRaw/Source/SolidSyslogLwipRawDatagramStatic.c b/Platform/LwipRaw/Source/SolidSyslogLwipRawDatagramStatic.c index 90d3ae27..78aed27f 100644 --- a/Platform/LwipRaw/Source/SolidSyslogLwipRawDatagramStatic.c +++ b/Platform/LwipRaw/Source/SolidSyslogLwipRawDatagramStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawDatagramErrors.h" #include "SolidSyslogLwipRawDatagramPrivate.h" #include "SolidSyslogNullDatagram.h" @@ -38,7 +39,8 @@ struct SolidSyslogDatagram* SolidSyslogLwipRawDatagram_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &LwipRawDatagramErrorSource, - (uint8_t) LWIPRAWDATAGRAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) LWIPRAWDATAGRAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogLwipRawDatagram_Destroy(struct SolidSyslogDatagram* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &LwipRawDatagramErrorSource, - (uint8_t) LWIPRAWDATAGRAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) LWIPRAWDATAGRAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c b/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c index d406dc60..cd02a7c7 100644 --- a/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c +++ b/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c @@ -3,12 +3,14 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawAddressPrivate.h" #include "SolidSyslogLwipRawDnsResolverErrors.h" #include "SolidSyslogLwipRawDnsResolverPrivate.h" #include "SolidSyslogLwipRawMarshalPrivate.h" #include "SolidSyslogNullResolver.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogResolverCategories.h" #include "SolidSyslogResolverDefinition.h" #include "SolidSyslogTransport.h" #include "SolidSyslogTunables.h" @@ -173,7 +175,8 @@ static bool LwipRawDnsResolver_WaitForCallback(struct SolidSyslogLwipRawDnsResol SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &LwipRawDnsResolverErrorSource, - (uint8_t) LWIPRAWDNSRESOLVER_ERROR_RESOLVE_TIMEOUT + SOLIDSYSLOG_CAT_RESOLVER_RESOLVE_FAILED, + (int32_t) LWIPRAWDNSRESOLVER_ERROR_RESOLVE_TIMEOUT ); } return self->Done; diff --git a/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolverStatic.c b/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolverStatic.c index 1f496455..0710e064 100644 --- a/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolverStatic.c +++ b/Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolverStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawDnsResolverErrors.h" #include "SolidSyslogLwipRawDnsResolverPrivate.h" #include "SolidSyslogNullResolver.h" @@ -43,7 +44,8 @@ struct SolidSyslogResolver* SolidSyslogLwipRawDnsResolver_Create( SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &LwipRawDnsResolverErrorSource, - (uint8_t) LWIPRAWDNSRESOLVER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) LWIPRAWDNSRESOLVER_ERROR_POOL_EXHAUSTED ); } } @@ -65,7 +67,8 @@ void SolidSyslogLwipRawDnsResolver_Destroy(struct SolidSyslogResolver* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &LwipRawDnsResolverErrorSource, - (uint8_t) LWIPRAWDNSRESOLVER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) LWIPRAWDNSRESOLVER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/LwipRaw/Source/SolidSyslogLwipRawResolverStatic.c b/Platform/LwipRaw/Source/SolidSyslogLwipRawResolverStatic.c index ada243e6..55537d72 100644 --- a/Platform/LwipRaw/Source/SolidSyslogLwipRawResolverStatic.c +++ b/Platform/LwipRaw/Source/SolidSyslogLwipRawResolverStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawResolverErrors.h" #include "SolidSyslogLwipRawResolverPrivate.h" #include "SolidSyslogNullResolver.h" @@ -38,7 +39,8 @@ struct SolidSyslogResolver* SolidSyslogLwipRawResolver_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &LwipRawResolverErrorSource, - (uint8_t) LWIPRAWRESOLVER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) LWIPRAWRESOLVER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogLwipRawResolver_Destroy(struct SolidSyslogResolver* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &LwipRawResolverErrorSource, - (uint8_t) LWIPRAWRESOLVER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) LWIPRAWRESOLVER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/LwipRaw/Source/SolidSyslogLwipRawTcpStreamStatic.c b/Platform/LwipRaw/Source/SolidSyslogLwipRawTcpStreamStatic.c index f6dcdc4c..93543d35 100644 --- a/Platform/LwipRaw/Source/SolidSyslogLwipRawTcpStreamStatic.c +++ b/Platform/LwipRaw/Source/SolidSyslogLwipRawTcpStreamStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawTcpStreamErrors.h" #include "SolidSyslogLwipRawTcpStreamPrivate.h" #include "SolidSyslogNullStream.h" @@ -41,7 +42,8 @@ struct SolidSyslogStream* SolidSyslogLwipRawTcpStream_Create(const struct SolidS SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &LwipRawTcpStreamErrorSource, - (uint8_t) LWIPRAWTCPSTREAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) LWIPRAWTCPSTREAM_ERROR_POOL_EXHAUSTED ); } } @@ -59,7 +61,8 @@ void SolidSyslogLwipRawTcpStream_Destroy(struct SolidSyslogStream* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &LwipRawTcpStreamErrorSource, - (uint8_t) LWIPRAWTCPSTREAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) LWIPRAWTCPSTREAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c index 59bb11d0..d2dc089c 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c @@ -8,10 +8,12 @@ #include #include +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMacros.h" #include "SolidSyslogMbedTlsAesGcmPolicyErrors.h" #include "SolidSyslogMbedTlsAesGcmPolicyPrivate.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "SolidSyslogSecurityPolicyDefinition.h" #include "SolidSyslogTunables.h" @@ -101,12 +103,20 @@ static bool MbedTlsAesGcmPolicy_SealRecord( } else { - MbedTlsAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_ENCRYPT_FAILED); + MbedTlsAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + MBEDTLSAESGCMPOLICY_ERROR_ENCRYPT_FAILED + ); } } else { - MbedTlsAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_NONCE_FAILED); + MbedTlsAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + MBEDTLSAESGCMPOLICY_ERROR_NONCE_FAILED + ); } } mbedtls_platform_zeroize(key, sizeof key); @@ -122,7 +132,11 @@ static bool MbedTlsAesGcmPolicy_FetchKey(struct SolidSyslogMbedTlsAesGcmPolicy* (keyLength == (size_t) AES_256_KEY_SIZE); if (!fetched) { - MbedTlsAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + MbedTlsAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } return fetched; } @@ -229,7 +243,11 @@ static bool MbedTlsAesGcmPolicy_GcmDecrypt(const struct SolidSyslogSecurityRecor mbedtls_gcm_free(&ctx); if (errored) { - MbedTlsAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_DECRYPT_FAILED); + MbedTlsAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED, + MBEDTLSAESGCMPOLICY_ERROR_DECRYPT_FAILED + ); } return opened; } diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyMessages.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyMessages.c index cca23f07..3002cd46 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyMessages.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyMessages.c @@ -37,7 +37,11 @@ const struct SolidSyslogErrorSource MbedTlsAesGcmPolicyErrorSource = { MbedTlsAesGcmPolicyError_AsString }; -void MbedTlsAesGcmPolicy_Report(enum SolidSyslogSeverity severity, enum SolidSyslogMbedTlsAesGcmPolicyErrors code) +void MbedTlsAesGcmPolicy_Report( + enum SolidSyslogSeverity severity, + uint16_t category, + enum SolidSyslogMbedTlsAesGcmPolicyErrors code +) { - SolidSyslog_Error(severity, &MbedTlsAesGcmPolicyErrorSource, (uint8_t) code); + SolidSyslog_Error(severity, &MbedTlsAesGcmPolicyErrorSource, category, (int32_t) code); } diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyPrivate.h b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyPrivate.h index 20044c9d..4faba16c 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyPrivate.h +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyPrivate.h @@ -21,6 +21,10 @@ void MbedTlsAesGcmPolicy_Cleanup(struct SolidSyslogSecurityPolicy* base); /* Emits one error from this class's source — hides the source pointer and the * enum-to-uint8 cast from every call site (seal/open in Policy.c, the pool in * Static.c). */ -void MbedTlsAesGcmPolicy_Report(enum SolidSyslogSeverity severity, enum SolidSyslogMbedTlsAesGcmPolicyErrors code); +void MbedTlsAesGcmPolicy_Report( + enum SolidSyslogSeverity severity, + uint16_t category, + enum SolidSyslogMbedTlsAesGcmPolicyErrors code +); #endif /* SOLIDSYSLOGMBEDTLSAESGCMPOLICYPRIVATE_H */ diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyStatic.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyStatic.c index 68e91d31..5e4c3e27 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyStatic.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicyStatic.c @@ -4,6 +4,7 @@ #include #include +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMbedTlsAesGcmPolicyErrors.h" #include "SolidSyslogMbedTlsAesGcmPolicyPrivate.h" #include "SolidSyslogNullSecurityPolicy.h" @@ -38,12 +39,20 @@ struct SolidSyslogSecurityPolicy* SolidSyslogMbedTlsAesGcmPolicy_Create( } else { - MbedTlsAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_POOL_EXHAUSTED); + MbedTlsAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + MBEDTLSAESGCMPOLICY_ERROR_POOL_EXHAUSTED + ); } } else { - MbedTlsAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_BAD_CONFIG); + MbedTlsAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_BAD_CONFIG, + MBEDTLSAESGCMPOLICY_ERROR_BAD_CONFIG + ); } return handle; } @@ -60,7 +69,11 @@ void SolidSyslogMbedTlsAesGcmPolicy_Destroy(struct SolidSyslogSecurityPolicy* ba ); if (!released) { - MbedTlsAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_WARNING, MBEDTLSAESGCMPOLICY_ERROR_UNKNOWN_DESTROY); + MbedTlsAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + MBEDTLSAESGCMPOLICY_ERROR_UNKNOWN_DESTROY + ); } } diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c index a5e5ddf4..4b25b2a7 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c @@ -6,9 +6,11 @@ #include #include +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMbedTlsHmacSha256PolicyErrors.h" #include "SolidSyslogMbedTlsHmacSha256PolicyPrivate.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "SolidSyslogSecurityPolicyDefinition.h" #include "SolidSyslogTunables.h" @@ -32,7 +34,8 @@ static bool MbedTlsHmacSha256Policy_ComputeTag( struct SolidSyslogMbedTlsHmacSha256Policy* policy, const uint8_t* data, uint16_t length, - uint8_t* tagOut + uint8_t* tagOut, + uint16_t failureCategory ); static inline bool MbedTlsHmacSha256Policy_ConstantTimeEquals(const uint8_t* a, const uint8_t* b, size_t length); @@ -77,7 +80,8 @@ static bool MbedTlsHmacSha256Policy_SealRecord( MbedTlsHmacSha256Policy_SelfFromBase(self), record->Content, record->ContentLength, - tag + tag, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED ); } @@ -90,7 +94,8 @@ static bool MbedTlsHmacSha256Policy_ComputeTag( struct SolidSyslogMbedTlsHmacSha256Policy* policy, const uint8_t* data, uint16_t length, - uint8_t* tagOut + uint8_t* tagOut, + uint16_t failureCategory ) { uint8_t key[SOLIDSYSLOG_MAX_HMAC_KEY_SIZE]; @@ -105,12 +110,20 @@ static bool MbedTlsHmacSha256Policy_ComputeTag( } else { - MbedTlsHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_HMAC_FAILED); + MbedTlsHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + failureCategory, + MBEDTLSHMACSHA256POLICY_ERROR_HMAC_FAILED + ); } } else { - MbedTlsHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE); + MbedTlsHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + MBEDTLSHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE + ); } /* Wipe the whole key buffer — the full region GetKey was handed, not just * the bytes written — so no key material lingers on the stack. */ @@ -129,7 +142,8 @@ static bool MbedTlsHmacSha256Policy_OpenRecord( MbedTlsHmacSha256Policy_SelfFromBase(self), record->Content, record->ContentLength, - expected + expected, + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED )) { verified = MbedTlsHmacSha256Policy_ConstantTimeEquals(expected, record->Trailer, HMAC_SHA256_TAG_SIZE); diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyMessages.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyMessages.c index 5e3d3d9b..c9bf4f84 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyMessages.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyMessages.c @@ -35,8 +35,9 @@ const struct SolidSyslogErrorSource MbedTlsHmacSha256PolicyErrorSource = { void MbedTlsHmacSha256Policy_Report( enum SolidSyslogSeverity severity, + uint16_t category, enum SolidSyslogMbedTlsHmacSha256PolicyErrors code ) { - SolidSyslog_Error(severity, &MbedTlsHmacSha256PolicyErrorSource, (uint8_t) code); + SolidSyslog_Error(severity, &MbedTlsHmacSha256PolicyErrorSource, category, (int32_t) code); } diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyPrivate.h b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyPrivate.h index 82bfc989..0db0ef7d 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyPrivate.h +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyPrivate.h @@ -23,6 +23,7 @@ void MbedTlsHmacSha256Policy_Cleanup(struct SolidSyslogSecurityPolicy* base); * Static.c). */ void MbedTlsHmacSha256Policy_Report( enum SolidSyslogSeverity severity, + uint16_t category, enum SolidSyslogMbedTlsHmacSha256PolicyErrors code ); diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyStatic.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyStatic.c index 01be9f98..1de42806 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyStatic.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256PolicyStatic.c @@ -4,6 +4,7 @@ #include #include +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMbedTlsHmacSha256PolicyErrors.h" #include "SolidSyslogMbedTlsHmacSha256PolicyPrivate.h" #include "SolidSyslogNullSecurityPolicy.h" @@ -38,12 +39,20 @@ struct SolidSyslogSecurityPolicy* SolidSyslogMbedTlsHmacSha256Policy_Create( } else { - MbedTlsHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_POOL_EXHAUSTED); + MbedTlsHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + MBEDTLSHMACSHA256POLICY_ERROR_POOL_EXHAUSTED + ); } } else { - MbedTlsHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_BAD_CONFIG); + MbedTlsHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_BAD_CONFIG, + MBEDTLSHMACSHA256POLICY_ERROR_BAD_CONFIG + ); } return handle; } @@ -60,7 +69,11 @@ void SolidSyslogMbedTlsHmacSha256Policy_Destroy(struct SolidSyslogSecurityPolicy ); if (!released) { - MbedTlsHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_WARNING, MBEDTLSHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY); + MbedTlsHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + MBEDTLSHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY + ); } } diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c index fcc308cb..3a3839b2 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c @@ -7,12 +7,14 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMbedTlsStreamErrors.h" #include "SolidSyslogMbedTlsStreamPrivate.h" #include "SolidSyslogNullStream.h" #include "SolidSyslogPrival.h" #include "SolidSyslogStream.h" #include "SolidSyslogStreamDefinition.h" +#include "SolidSyslogTlsStreamCategories.h" #include "SolidSyslogTunables.h" enum @@ -151,7 +153,8 @@ static inline bool MbedTlsStream_ApplySslConfigDefaults(struct SolidSyslogMbedTl SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &MbedTlsStreamErrorSource, - (uint8_t) MBEDTLSSTREAM_ERROR_DEFAULTS_NOT_APPLIED + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + (int32_t) MBEDTLSSTREAM_ERROR_DEFAULTS_NOT_APPLIED ); } return ok; @@ -178,7 +181,8 @@ static inline bool MbedTlsStream_BindContextToConfig(struct SolidSyslogMbedTlsSt SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &MbedTlsStreamErrorSource, - (uint8_t) MBEDTLSSTREAM_ERROR_SESSION_INIT_FAILED + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + (int32_t) MBEDTLSSTREAM_ERROR_SESSION_INIT_FAILED ); } return ok; @@ -195,7 +199,8 @@ static inline bool MbedTlsStream_ConfigureExpectedHostname(struct SolidSyslogMbe SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &MbedTlsStreamErrorSource, - (uint8_t) MBEDTLSSTREAM_ERROR_SERVER_NAME_NOT_SET + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) MBEDTLSSTREAM_ERROR_SERVER_NAME_NOT_SET ); } } @@ -234,7 +239,8 @@ static inline bool MbedTlsStream_PerformHandshake(struct SolidSyslogMbedTlsStrea SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &MbedTlsStreamErrorSource, - (uint8_t) MBEDTLSSTREAM_ERROR_HANDSHAKE_REJECTED + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + (int32_t) MBEDTLSSTREAM_ERROR_HANDSHAKE_REJECTED ); done = true; } @@ -243,7 +249,8 @@ static inline bool MbedTlsStream_PerformHandshake(struct SolidSyslogMbedTlsStrea SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &MbedTlsStreamErrorSource, - (uint8_t) MBEDTLSSTREAM_ERROR_HANDSHAKE_TIMEOUT + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + (int32_t) MBEDTLSSTREAM_ERROR_HANDSHAKE_TIMEOUT ); done = true; } diff --git a/Platform/MbedTls/Source/SolidSyslogMbedTlsStreamStatic.c b/Platform/MbedTls/Source/SolidSyslogMbedTlsStreamStatic.c index 47e41a4e..89625b27 100644 --- a/Platform/MbedTls/Source/SolidSyslogMbedTlsStreamStatic.c +++ b/Platform/MbedTls/Source/SolidSyslogMbedTlsStreamStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMbedTlsStreamErrors.h" #include "SolidSyslogMbedTlsStreamPrivate.h" #include "SolidSyslogNullStream.h" @@ -38,7 +39,8 @@ struct SolidSyslogStream* SolidSyslogMbedTlsStream_Create(const struct SolidSysl SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &MbedTlsStreamErrorSource, - (uint8_t) MBEDTLSSTREAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) MBEDTLSSTREAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogMbedTlsStream_Destroy(struct SolidSyslogStream* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &MbedTlsStreamErrorSource, - (uint8_t) MBEDTLSSTREAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) MBEDTLSSTREAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c index 98d09dd3..909ffe81 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c @@ -8,9 +8,11 @@ #include #include +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogOpenSslAesGcmPolicyErrors.h" #include "SolidSyslogOpenSslAesGcmPolicyPrivate.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "SolidSyslogSecurityPolicyDefinition.h" enum @@ -115,12 +117,20 @@ static bool OpenSslAesGcmPolicy_SealRecord( } else { - OpenSslAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_ENCRYPT_FAILED); + OpenSslAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + OPENSSLAESGCMPOLICY_ERROR_ENCRYPT_FAILED + ); } } else { - OpenSslAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_NONCE_FAILED); + OpenSslAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + OPENSSLAESGCMPOLICY_ERROR_NONCE_FAILED + ); } } OPENSSL_cleanse(key, sizeof key); @@ -136,7 +146,11 @@ static bool OpenSslAesGcmPolicy_FetchKey(struct SolidSyslogOpenSslAesGcmPolicy* (keyLength == (size_t) AES_256_KEY_SIZE); if (!fetched) { - OpenSslAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + OpenSslAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } return fetched; } @@ -235,7 +249,11 @@ static bool OpenSslAesGcmPolicy_GcmDecrypt( } if (errored) { - OpenSslAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_DECRYPT_FAILED); + OpenSslAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED, + OPENSSLAESGCMPOLICY_ERROR_DECRYPT_FAILED + ); } return opened; } diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyMessages.c b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyMessages.c index c61666ac..64a6f159 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyMessages.c +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyMessages.c @@ -37,7 +37,11 @@ const struct SolidSyslogErrorSource OpenSslAesGcmPolicyErrorSource = { OpenSslAesGcmPolicyError_AsString }; -void OpenSslAesGcmPolicy_Report(enum SolidSyslogSeverity severity, enum SolidSyslogOpenSslAesGcmPolicyErrors code) +void OpenSslAesGcmPolicy_Report( + enum SolidSyslogSeverity severity, + uint16_t category, + enum SolidSyslogOpenSslAesGcmPolicyErrors code +) { - SolidSyslog_Error(severity, &OpenSslAesGcmPolicyErrorSource, (uint8_t) code); + SolidSyslog_Error(severity, &OpenSslAesGcmPolicyErrorSource, category, (int32_t) code); } diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyPrivate.h b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyPrivate.h index 57ac7216..507d7c29 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyPrivate.h +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyPrivate.h @@ -21,6 +21,10 @@ void OpenSslAesGcmPolicy_Cleanup(struct SolidSyslogSecurityPolicy* base); /* Emits one error from this class's source — hides the source pointer and the * enum-to-uint8 cast from every call site (seal/open in Policy.c, the pool in * Static.c). */ -void OpenSslAesGcmPolicy_Report(enum SolidSyslogSeverity severity, enum SolidSyslogOpenSslAesGcmPolicyErrors code); +void OpenSslAesGcmPolicy_Report( + enum SolidSyslogSeverity severity, + uint16_t category, + enum SolidSyslogOpenSslAesGcmPolicyErrors code +); #endif /* SOLIDSYSLOGOPENSSLAESGCMPOLICYPRIVATE_H */ diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyStatic.c b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyStatic.c index 4caed9d0..1687bca5 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyStatic.c +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicyStatic.c @@ -4,9 +4,10 @@ #include #include +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogNullSecurityPolicy.h" #include "SolidSyslogOpenSslAesGcmPolicyErrors.h" #include "SolidSyslogOpenSslAesGcmPolicyPrivate.h" -#include "SolidSyslogNullSecurityPolicy.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" #include "SolidSyslogSecurityPolicyDefinition.h" @@ -38,12 +39,20 @@ struct SolidSyslogSecurityPolicy* SolidSyslogOpenSslAesGcmPolicy_Create( } else { - OpenSslAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_POOL_EXHAUSTED); + OpenSslAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + OPENSSLAESGCMPOLICY_ERROR_POOL_EXHAUSTED + ); } } else { - OpenSslAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_BAD_CONFIG); + OpenSslAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_BAD_CONFIG, + OPENSSLAESGCMPOLICY_ERROR_BAD_CONFIG + ); } return handle; } @@ -60,7 +69,11 @@ void SolidSyslogOpenSslAesGcmPolicy_Destroy(struct SolidSyslogSecurityPolicy* ba ); if (!released) { - OpenSslAesGcmPolicy_Report(SOLIDSYSLOG_SEVERITY_WARNING, OPENSSLAESGCMPOLICY_ERROR_UNKNOWN_DESTROY); + OpenSslAesGcmPolicy_Report( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + OPENSSLAESGCMPOLICY_ERROR_UNKNOWN_DESTROY + ); } } diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c index 1e20dc84..e5120027 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c @@ -7,9 +7,11 @@ #include #include +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogOpenSslHmacSha256PolicyErrors.h" #include "SolidSyslogOpenSslHmacSha256PolicyPrivate.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "SolidSyslogSecurityPolicyDefinition.h" #include "SolidSyslogTunables.h" @@ -33,7 +35,8 @@ static bool OpenSslHmacSha256Policy_ComputeTag( struct SolidSyslogOpenSslHmacSha256Policy* policy, const uint8_t* data, uint16_t length, - uint8_t* tagOut + uint8_t* tagOut, + uint16_t failureCategory ); static inline bool OpenSslHmacSha256Policy_ConstantTimeEquals(const uint8_t* a, const uint8_t* b, size_t length); @@ -78,7 +81,8 @@ static bool OpenSslHmacSha256Policy_SealRecord( OpenSslHmacSha256Policy_SelfFromBase(self), record->Content, record->ContentLength, - tag + tag, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED ); } @@ -91,7 +95,8 @@ static bool OpenSslHmacSha256Policy_ComputeTag( struct SolidSyslogOpenSslHmacSha256Policy* policy, const uint8_t* data, uint16_t length, - uint8_t* tagOut + uint8_t* tagOut, + uint16_t failureCategory ) { uint8_t key[SOLIDSYSLOG_MAX_HMAC_KEY_SIZE]; @@ -105,12 +110,20 @@ static bool OpenSslHmacSha256Policy_ComputeTag( } else { - OpenSslHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_HMAC_FAILED); + OpenSslHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + failureCategory, + OPENSSLHMACSHA256POLICY_ERROR_HMAC_FAILED + ); } } else { - OpenSslHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE); + OpenSslHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + OPENSSLHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE + ); } /* Wipe the whole key buffer — the full region GetKey was handed, not just * the bytes written — so no key material lingers on the stack. */ @@ -129,7 +142,8 @@ static bool OpenSslHmacSha256Policy_OpenRecord( OpenSslHmacSha256Policy_SelfFromBase(self), record->Content, record->ContentLength, - expected + expected, + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED )) { verified = OpenSslHmacSha256Policy_ConstantTimeEquals(expected, record->Trailer, HMAC_SHA256_TAG_SIZE); diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyMessages.c b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyMessages.c index f0ed065f..70ad8ce3 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyMessages.c +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyMessages.c @@ -35,8 +35,9 @@ const struct SolidSyslogErrorSource OpenSslHmacSha256PolicyErrorSource = { void OpenSslHmacSha256Policy_Report( enum SolidSyslogSeverity severity, + uint16_t category, enum SolidSyslogOpenSslHmacSha256PolicyErrors code ) { - SolidSyslog_Error(severity, &OpenSslHmacSha256PolicyErrorSource, (uint8_t) code); + SolidSyslog_Error(severity, &OpenSslHmacSha256PolicyErrorSource, category, (int32_t) code); } diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyPrivate.h b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyPrivate.h index b18771ff..a500eb38 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyPrivate.h +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyPrivate.h @@ -23,6 +23,7 @@ void OpenSslHmacSha256Policy_Cleanup(struct SolidSyslogSecurityPolicy* base); * Static.c). */ void OpenSslHmacSha256Policy_Report( enum SolidSyslogSeverity severity, + uint16_t category, enum SolidSyslogOpenSslHmacSha256PolicyErrors code ); diff --git a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyStatic.c b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyStatic.c index 810120b5..812c9590 100644 --- a/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyStatic.c +++ b/Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256PolicyStatic.c @@ -4,9 +4,10 @@ #include #include +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogNullSecurityPolicy.h" #include "SolidSyslogOpenSslHmacSha256PolicyErrors.h" #include "SolidSyslogOpenSslHmacSha256PolicyPrivate.h" -#include "SolidSyslogNullSecurityPolicy.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" #include "SolidSyslogSecurityPolicyDefinition.h" @@ -38,12 +39,20 @@ struct SolidSyslogSecurityPolicy* SolidSyslogOpenSslHmacSha256Policy_Create( } else { - OpenSslHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_POOL_EXHAUSTED); + OpenSslHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + OPENSSLHMACSHA256POLICY_ERROR_POOL_EXHAUSTED + ); } } else { - OpenSslHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_BAD_CONFIG); + OpenSslHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_BAD_CONFIG, + OPENSSLHMACSHA256POLICY_ERROR_BAD_CONFIG + ); } return handle; } @@ -60,7 +69,11 @@ void SolidSyslogOpenSslHmacSha256Policy_Destroy(struct SolidSyslogSecurityPolicy ); if (!released) { - OpenSslHmacSha256Policy_Report(SOLIDSYSLOG_SEVERITY_WARNING, OPENSSLHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY); + OpenSslHmacSha256Policy_Report( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + OPENSSLHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY + ); } } diff --git a/Platform/OpenSsl/Source/SolidSyslogTlsStream.c b/Platform/OpenSsl/Source/SolidSyslogTlsStream.c index 991148b0..145efa78 100644 --- a/Platform/OpenSsl/Source/SolidSyslogTlsStream.c +++ b/Platform/OpenSsl/Source/SolidSyslogTlsStream.c @@ -9,10 +9,12 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullStream.h" #include "SolidSyslogPrival.h" #include "SolidSyslogStream.h" #include "SolidSyslogStreamDefinition.h" +#include "SolidSyslogTlsStreamCategories.h" #include "SolidSyslogTlsStreamErrors.h" #include "SolidSyslogTlsStreamPrivate.h" #include "SolidSyslogTunables.h" @@ -169,7 +171,8 @@ static inline bool TlsStream_InitSslContext(struct SolidSyslogTlsStream* self) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TlsStreamErrorSource, - (uint8_t) TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + (int32_t) TLSSTREAM_ERROR_CONTEXT_INIT_FAILED ); } return ok; @@ -249,7 +252,8 @@ static inline bool TlsStream_InitSslSession(struct SolidSyslogTlsStream* self) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TlsStreamErrorSource, - (uint8_t) TLSSTREAM_ERROR_SESSION_INIT_FAILED + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + (int32_t) TLSSTREAM_ERROR_SESSION_INIT_FAILED ); } return ok; @@ -269,7 +273,8 @@ static inline bool TlsStream_AttachTransportBio(struct SolidSyslogTlsStream* sel SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TlsStreamErrorSource, - (uint8_t) TLSSTREAM_ERROR_SESSION_INIT_FAILED + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + (int32_t) TLSSTREAM_ERROR_SESSION_INIT_FAILED ); } return ok; @@ -392,7 +397,8 @@ static inline bool TlsStream_ConfigureExpectedHostname(struct SolidSyslogTlsStre SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TlsStreamErrorSource, - (uint8_t) TLSSTREAM_ERROR_SERVER_NAME_NOT_SET + SOLIDSYSLOG_CAT_BAD_CONFIG, + (int32_t) TLSSTREAM_ERROR_SERVER_NAME_NOT_SET ); } } @@ -460,7 +466,8 @@ static inline bool TlsStream_PerformHandshake(struct SolidSyslogTlsStream* self) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TlsStreamErrorSource, - (uint8_t) TLSSTREAM_ERROR_HANDSHAKE_REJECTED + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + (int32_t) TLSSTREAM_ERROR_HANDSHAKE_REJECTED ); done = true; } @@ -469,7 +476,8 @@ static inline bool TlsStream_PerformHandshake(struct SolidSyslogTlsStream* self) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &TlsStreamErrorSource, - (uint8_t) TLSSTREAM_ERROR_HANDSHAKE_TIMEOUT + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + (int32_t) TLSSTREAM_ERROR_HANDSHAKE_TIMEOUT ); done = true; } diff --git a/Platform/OpenSsl/Source/SolidSyslogTlsStreamStatic.c b/Platform/OpenSsl/Source/SolidSyslogTlsStreamStatic.c index d5084cdf..30ffe3cf 100644 --- a/Platform/OpenSsl/Source/SolidSyslogTlsStreamStatic.c +++ b/Platform/OpenSsl/Source/SolidSyslogTlsStreamStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullStream.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -32,7 +33,12 @@ struct SolidSyslogStream* SolidSyslogTlsStream_Create(const struct SolidSyslogTl } else { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &TlsStreamErrorSource, (uint8_t) TLSSTREAM_ERROR_POOL_EXHAUSTED); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &TlsStreamErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) TLSSTREAM_ERROR_POOL_EXHAUSTED + ); } return handle; } @@ -47,7 +53,8 @@ void SolidSyslogTlsStream_Destroy(struct SolidSyslogStream* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &TlsStreamErrorSource, - (uint8_t) TLSSTREAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) TLSSTREAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c b/Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c index 7041dff4..707e4f2b 100644 --- a/Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c +++ b/Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPlusTcpAddressErrors.h" #include "SolidSyslogPlusTcpAddressPrivate.h" #include "SolidSyslogPoolAllocator.h" @@ -42,7 +43,8 @@ struct SolidSyslogAddress* SolidSyslogPlusTcpAddress_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PlusTcpAddressErrorSource, - (uint8_t) PLUSTCPADDRESS_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) PLUSTCPADDRESS_ERROR_POOL_EXHAUSTED ); } return handle; @@ -65,7 +67,8 @@ void SolidSyslogPlusTcpAddress_Destroy(struct SolidSyslogAddress* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PlusTcpAddressErrorSource, - (uint8_t) PLUSTCPADDRESS_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) PLUSTCPADDRESS_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/PlusTcp/Source/SolidSyslogPlusTcpDatagramStatic.c b/Platform/PlusTcp/Source/SolidSyslogPlusTcpDatagramStatic.c index 76c659d3..5842c002 100644 --- a/Platform/PlusTcp/Source/SolidSyslogPlusTcpDatagramStatic.c +++ b/Platform/PlusTcp/Source/SolidSyslogPlusTcpDatagramStatic.c @@ -5,9 +5,10 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogNullDatagram.h" #include "SolidSyslogPlusTcpDatagramErrors.h" #include "SolidSyslogPlusTcpDatagramPrivate.h" -#include "SolidSyslogNullDatagram.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" @@ -38,7 +39,8 @@ struct SolidSyslogDatagram* SolidSyslogPlusTcpDatagram_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PlusTcpDatagramErrorSource, - (uint8_t) PLUSTCPDATAGRAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) PLUSTCPDATAGRAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogPlusTcpDatagram_Destroy(struct SolidSyslogDatagram* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PlusTcpDatagramErrorSource, - (uint8_t) PLUSTCPDATAGRAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) PLUSTCPDATAGRAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/PlusTcp/Source/SolidSyslogPlusTcpResolverStatic.c b/Platform/PlusTcp/Source/SolidSyslogPlusTcpResolverStatic.c index 4292c021..b8cb6cb7 100644 --- a/Platform/PlusTcp/Source/SolidSyslogPlusTcpResolverStatic.c +++ b/Platform/PlusTcp/Source/SolidSyslogPlusTcpResolverStatic.c @@ -5,9 +5,10 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogNullResolver.h" #include "SolidSyslogPlusTcpResolverErrors.h" #include "SolidSyslogPlusTcpResolverPrivate.h" -#include "SolidSyslogNullResolver.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" @@ -38,7 +39,8 @@ struct SolidSyslogResolver* SolidSyslogPlusTcpResolver_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PlusTcpResolverErrorSource, - (uint8_t) PLUSTCPRESOLVER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) PLUSTCPRESOLVER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogPlusTcpResolver_Destroy(struct SolidSyslogResolver* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PlusTcpResolverErrorSource, - (uint8_t) PLUSTCPRESOLVER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) PLUSTCPRESOLVER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/PlusTcp/Source/SolidSyslogPlusTcpTcpStreamStatic.c b/Platform/PlusTcp/Source/SolidSyslogPlusTcpTcpStreamStatic.c index 238baaf5..53e6b633 100644 --- a/Platform/PlusTcp/Source/SolidSyslogPlusTcpTcpStreamStatic.c +++ b/Platform/PlusTcp/Source/SolidSyslogPlusTcpTcpStreamStatic.c @@ -5,9 +5,10 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogNullStream.h" #include "SolidSyslogPlusTcpTcpStreamErrors.h" #include "SolidSyslogPlusTcpTcpStreamPrivate.h" -#include "SolidSyslogNullStream.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" @@ -38,7 +39,8 @@ struct SolidSyslogStream* SolidSyslogPlusTcpTcpStream_Create(const struct SolidS SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PlusTcpTcpStreamErrorSource, - (uint8_t) PLUSTCPTCPSTREAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) PLUSTCPTCPSTREAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogPlusTcpTcpStream_Destroy(struct SolidSyslogStream* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PlusTcpTcpStreamErrorSource, - (uint8_t) PLUSTCPTCPSTREAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) PLUSTCPTCPSTREAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Posix/Source/SolidSyslogGetAddrInfoResolverStatic.c b/Platform/Posix/Source/SolidSyslogGetAddrInfoResolverStatic.c index f4285a88..4778f430 100644 --- a/Platform/Posix/Source/SolidSyslogGetAddrInfoResolverStatic.c +++ b/Platform/Posix/Source/SolidSyslogGetAddrInfoResolverStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogGetAddrInfoResolverErrors.h" #include "SolidSyslogGetAddrInfoResolverPrivate.h" #include "SolidSyslogNullResolver.h" @@ -38,7 +39,8 @@ struct SolidSyslogResolver* SolidSyslogGetAddrInfoResolver_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &GetAddrInfoResolverErrorSource, - (uint8_t) GETADDRINFORESOLVER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) GETADDRINFORESOLVER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -59,7 +61,8 @@ void SolidSyslogGetAddrInfoResolver_Destroy(struct SolidSyslogResolver* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &GetAddrInfoResolverErrorSource, - (uint8_t) GETADDRINFORESOLVER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) GETADDRINFORESOLVER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Posix/Source/SolidSyslogPosixAddressStatic.c b/Platform/Posix/Source/SolidSyslogPosixAddressStatic.c index fee7abe9..804ad8cb 100644 --- a/Platform/Posix/Source/SolidSyslogPosixAddressStatic.c +++ b/Platform/Posix/Source/SolidSyslogPosixAddressStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPosixAddressErrors.h" #include "SolidSyslogPosixAddressPrivate.h" @@ -42,7 +43,8 @@ struct SolidSyslogAddress* SolidSyslogPosixAddress_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixAddressErrorSource, - (uint8_t) POSIXADDRESS_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) POSIXADDRESS_ERROR_POOL_EXHAUSTED ); } return handle; @@ -65,7 +67,8 @@ void SolidSyslogPosixAddress_Destroy(struct SolidSyslogAddress* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PosixAddressErrorSource, - (uint8_t) POSIXADDRESS_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) POSIXADDRESS_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Posix/Source/SolidSyslogPosixDatagramStatic.c b/Platform/Posix/Source/SolidSyslogPosixDatagramStatic.c index daf2eec8..bd096ed1 100644 --- a/Platform/Posix/Source/SolidSyslogPosixDatagramStatic.c +++ b/Platform/Posix/Source/SolidSyslogPosixDatagramStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullDatagram.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPosixDatagramErrors.h" @@ -35,7 +36,8 @@ struct SolidSyslogDatagram* SolidSyslogPosixDatagram_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixDatagramErrorSource, - (uint8_t) POSIXDATAGRAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) POSIXDATAGRAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -52,7 +54,8 @@ void SolidSyslogPosixDatagram_Destroy(struct SolidSyslogDatagram* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PosixDatagramErrorSource, - (uint8_t) POSIXDATAGRAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) POSIXDATAGRAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Posix/Source/SolidSyslogPosixFileStatic.c b/Platform/Posix/Source/SolidSyslogPosixFileStatic.c index f7d7453d..0a4a7825 100644 --- a/Platform/Posix/Source/SolidSyslogPosixFileStatic.c +++ b/Platform/Posix/Source/SolidSyslogPosixFileStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullFile.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPosixFileErrors.h" @@ -32,7 +33,12 @@ struct SolidSyslogFile* SolidSyslogPosixFile_Create(void) } else { - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &PosixFileErrorSource, (uint8_t) POSIXFILE_ERROR_POOL_EXHAUSTED); + SolidSyslog_Error( + SOLIDSYSLOG_SEVERITY_ERROR, + &PosixFileErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) POSIXFILE_ERROR_POOL_EXHAUSTED + ); } return handle; } @@ -47,7 +53,8 @@ void SolidSyslogPosixFile_Destroy(struct SolidSyslogFile* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PosixFileErrorSource, - (uint8_t) POSIXFILE_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) POSIXFILE_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c b/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c index 51996e3a..34893bc8 100644 --- a/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c +++ b/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c @@ -8,8 +8,10 @@ #include #include +#include "SolidSyslogBufferCategories.h" #include "SolidSyslogBufferDefinition.h" #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFormatter.h" #include "SolidSyslogNullBuffer.h" #include "SolidSyslogPosixMessageQueueBufferErrors.h" @@ -100,7 +102,8 @@ static bool PosixMessageQueueBuffer_Read(struct SolidSyslogBuffer* base, void* d SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixMessageQueueBufferErrorSource, - (uint8_t) POSIXMESSAGEQUEUEBUFFER_ERROR_RECEIVE_FAILED + SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED, + (int32_t) POSIXMESSAGEQUEUEBUFFER_ERROR_RECEIVE_FAILED ); } @@ -117,7 +120,8 @@ static void PosixMessageQueueBuffer_Write(struct SolidSyslogBuffer* base, const SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixMessageQueueBufferErrorSource, - (uint8_t) POSIXMESSAGEQUEUEBUFFER_ERROR_SEND_FAILED + SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED, + (int32_t) POSIXMESSAGEQUEUEBUFFER_ERROR_SEND_FAILED ); } } diff --git a/Platform/Posix/Source/SolidSyslogPosixMessageQueueBufferStatic.c b/Platform/Posix/Source/SolidSyslogPosixMessageQueueBufferStatic.c index 31b249c9..963d3cc1 100644 --- a/Platform/Posix/Source/SolidSyslogPosixMessageQueueBufferStatic.c +++ b/Platform/Posix/Source/SolidSyslogPosixMessageQueueBufferStatic.c @@ -4,7 +4,9 @@ #include #include +#include "SolidSyslogBufferCategories.h" #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullBuffer.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPosixMessageQueueBufferErrors.h" @@ -58,7 +60,8 @@ struct SolidSyslogBuffer* SolidSyslogPosixMessageQueueBuffer_Create(size_t maxMe SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixMessageQueueBufferErrorSource, - (uint8_t) POSIXMESSAGEQUEUEBUFFER_ERROR_MQ_OPEN_FAILED + SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED, + (int32_t) POSIXMESSAGEQUEUEBUFFER_ERROR_MQ_OPEN_FAILED ); } } @@ -67,7 +70,8 @@ struct SolidSyslogBuffer* SolidSyslogPosixMessageQueueBuffer_Create(size_t maxMe SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixMessageQueueBufferErrorSource, - (uint8_t) POSIXMESSAGEQUEUEBUFFER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) POSIXMESSAGEQUEUEBUFFER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -88,7 +92,8 @@ void SolidSyslogPosixMessageQueueBuffer_Destroy(struct SolidSyslogBuffer* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PosixMessageQueueBufferErrorSource, - (uint8_t) POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Posix/Source/SolidSyslogPosixMutexStatic.c b/Platform/Posix/Source/SolidSyslogPosixMutexStatic.c index b0277d8a..5a799930 100644 --- a/Platform/Posix/Source/SolidSyslogPosixMutexStatic.c +++ b/Platform/Posix/Source/SolidSyslogPosixMutexStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullMutex.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPosixMutexErrors.h" @@ -35,7 +36,8 @@ struct SolidSyslogMutex* SolidSyslogPosixMutex_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixMutexErrorSource, - (uint8_t) POSIXMUTEX_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) POSIXMUTEX_ERROR_POOL_EXHAUSTED ); } return handle; @@ -51,7 +53,8 @@ void SolidSyslogPosixMutex_Destroy(struct SolidSyslogMutex* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PosixMutexErrorSource, - (uint8_t) POSIXMUTEX_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) POSIXMUTEX_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Posix/Source/SolidSyslogPosixTcpStreamStatic.c b/Platform/Posix/Source/SolidSyslogPosixTcpStreamStatic.c index 6ba09642..6ab278e9 100644 --- a/Platform/Posix/Source/SolidSyslogPosixTcpStreamStatic.c +++ b/Platform/Posix/Source/SolidSyslogPosixTcpStreamStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullStream.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPosixTcpStreamErrors.h" @@ -38,7 +39,8 @@ struct SolidSyslogStream* SolidSyslogPosixTcpStream_Create(const struct SolidSys SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &PosixTcpStreamErrorSource, - (uint8_t) POSIXTCPSTREAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) POSIXTCPSTREAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogPosixTcpStream_Destroy(struct SolidSyslogStream* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &PosixTcpStreamErrorSource, - (uint8_t) POSIXTCPSTREAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) POSIXTCPSTREAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Windows/Source/SolidSyslogWindowsAtomicCounterStatic.c b/Platform/Windows/Source/SolidSyslogWindowsAtomicCounterStatic.c index 2a2ae90b..6e5d259c 100644 --- a/Platform/Windows/Source/SolidSyslogWindowsAtomicCounterStatic.c +++ b/Platform/Windows/Source/SolidSyslogWindowsAtomicCounterStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullAtomicCounter.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -38,7 +39,8 @@ struct SolidSyslogAtomicCounter* SolidSyslogWindowsAtomicCounter_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &WindowsAtomicCounterErrorSource, - (uint8_t) WINDOWSATOMICCOUNTER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) WINDOWSATOMICCOUNTER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -59,7 +61,8 @@ void SolidSyslogWindowsAtomicCounter_Destroy(struct SolidSyslogAtomicCounter* ba SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &WindowsAtomicCounterErrorSource, - (uint8_t) WINDOWSATOMICCOUNTER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) WINDOWSATOMICCOUNTER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Windows/Source/SolidSyslogWindowsFileStatic.c b/Platform/Windows/Source/SolidSyslogWindowsFileStatic.c index 659d7354..2df449cd 100644 --- a/Platform/Windows/Source/SolidSyslogWindowsFileStatic.c +++ b/Platform/Windows/Source/SolidSyslogWindowsFileStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullFile.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -35,7 +36,8 @@ struct SolidSyslogFile* SolidSyslogWindowsFile_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &WindowsFileErrorSource, - (uint8_t) WINDOWSFILE_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) WINDOWSFILE_ERROR_POOL_EXHAUSTED ); } return handle; @@ -52,7 +54,8 @@ void SolidSyslogWindowsFile_Destroy(struct SolidSyslogFile* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &WindowsFileErrorSource, - (uint8_t) WINDOWSFILE_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) WINDOWSFILE_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Windows/Source/SolidSyslogWindowsMutexStatic.c b/Platform/Windows/Source/SolidSyslogWindowsMutexStatic.c index 9bd21d51..e3e288d3 100644 --- a/Platform/Windows/Source/SolidSyslogWindowsMutexStatic.c +++ b/Platform/Windows/Source/SolidSyslogWindowsMutexStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullMutex.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -35,7 +36,8 @@ struct SolidSyslogMutex* SolidSyslogWindowsMutex_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &WindowsMutexErrorSource, - (uint8_t) WINDOWSMUTEX_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) WINDOWSMUTEX_ERROR_POOL_EXHAUSTED ); } return handle; @@ -52,7 +54,8 @@ void SolidSyslogWindowsMutex_Destroy(struct SolidSyslogMutex* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &WindowsMutexErrorSource, - (uint8_t) WINDOWSMUTEX_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) WINDOWSMUTEX_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c b/Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c index 401388d3..0f8e958a 100644 --- a/Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c +++ b/Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" @@ -42,7 +43,8 @@ struct SolidSyslogAddress* SolidSyslogWinsockAddress_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &WinsockAddressErrorSource, - (uint8_t) WINSOCKADDRESS_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) WINSOCKADDRESS_ERROR_POOL_EXHAUSTED ); } return handle; @@ -65,7 +67,8 @@ void SolidSyslogWinsockAddress_Destroy(struct SolidSyslogAddress* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &WinsockAddressErrorSource, - (uint8_t) WINSOCKADDRESS_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) WINSOCKADDRESS_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Windows/Source/SolidSyslogWinsockDatagramStatic.c b/Platform/Windows/Source/SolidSyslogWinsockDatagramStatic.c index 9b5a65e6..ad1ae23d 100644 --- a/Platform/Windows/Source/SolidSyslogWinsockDatagramStatic.c +++ b/Platform/Windows/Source/SolidSyslogWinsockDatagramStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullDatagram.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -38,7 +39,8 @@ struct SolidSyslogDatagram* SolidSyslogWinsockDatagram_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &WinsockDatagramErrorSource, - (uint8_t) WINSOCKDATAGRAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) WINSOCKDATAGRAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogWinsockDatagram_Destroy(struct SolidSyslogDatagram* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &WinsockDatagramErrorSource, - (uint8_t) WINSOCKDATAGRAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) WINSOCKDATAGRAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Windows/Source/SolidSyslogWinsockResolverStatic.c b/Platform/Windows/Source/SolidSyslogWinsockResolverStatic.c index 5c83ebef..b449abcb 100644 --- a/Platform/Windows/Source/SolidSyslogWinsockResolverStatic.c +++ b/Platform/Windows/Source/SolidSyslogWinsockResolverStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullResolver.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -38,7 +39,8 @@ struct SolidSyslogResolver* SolidSyslogWinsockResolver_Create(void) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &WinsockResolverErrorSource, - (uint8_t) WINSOCKRESOLVER_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) WINSOCKRESOLVER_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogWinsockResolver_Destroy(struct SolidSyslogResolver* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &WinsockResolverErrorSource, - (uint8_t) WINSOCKRESOLVER_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) WINSOCKRESOLVER_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Platform/Windows/Source/SolidSyslogWinsockTcpStreamStatic.c b/Platform/Windows/Source/SolidSyslogWinsockTcpStreamStatic.c index c239149d..5add0396 100644 --- a/Platform/Windows/Source/SolidSyslogWinsockTcpStreamStatic.c +++ b/Platform/Windows/Source/SolidSyslogWinsockTcpStreamStatic.c @@ -5,6 +5,7 @@ #include #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullStream.h" #include "SolidSyslogPoolAllocator.h" #include "SolidSyslogPrival.h" @@ -38,7 +39,8 @@ struct SolidSyslogStream* SolidSyslogWinsockTcpStream_Create(const struct SolidS SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_ERROR, &WinsockTcpStreamErrorSource, - (uint8_t) WINSOCKTCPSTREAM_ERROR_POOL_EXHAUSTED + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + (int32_t) WINSOCKTCPSTREAM_ERROR_POOL_EXHAUSTED ); } return handle; @@ -55,7 +57,8 @@ void SolidSyslogWinsockTcpStream_Destroy(struct SolidSyslogStream* base) SolidSyslog_Error( SOLIDSYSLOG_SEVERITY_WARNING, &WinsockTcpStreamErrorSource, - (uint8_t) WINSOCKTCPSTREAM_ERROR_UNKNOWN_DESTROY + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + (int32_t) WINSOCKTCPSTREAM_ERROR_UNKNOWN_DESTROY ); } } diff --git a/Tests/FatFs/SolidSyslogFatFsFilePoolTest.cpp b/Tests/FatFs/SolidSyslogFatFsFilePoolTest.cpp index b17d5265..c5397bfe 100644 --- a/Tests/FatFs/SolidSyslogFatFsFilePoolTest.cpp +++ b/Tests/FatFs/SolidSyslogFatFsFilePoolTest.cpp @@ -6,6 +6,7 @@ extern "C" #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" #include "FatFsFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFatFsFile.h" #include "SolidSyslogFatFsFileErrors.h" #include "SolidSyslogFile.h" @@ -85,7 +86,8 @@ TEST(SolidSyslogFatFsFilePool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&FatFsFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(FATFSFILE_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(FATFSFILE_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogFatFsFilePool, FallbackOpenReturnsFalse) @@ -150,7 +152,8 @@ TEST(SolidSyslogFatFsFilePool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&FatFsFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(FATFSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(FATFSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogFatFsFilePool, DestroyOfStaleHandleReportsWarning) @@ -165,5 +168,6 @@ TEST(SolidSyslogFatFsFilePool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&FatFsFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(FATFSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(FATFSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/FreeRtos/SolidSyslogFreeRtosMutexTest.cpp b/Tests/FreeRtos/SolidSyslogFreeRtosMutexTest.cpp index e3757292..06789790 100644 --- a/Tests/FreeRtos/SolidSyslogFreeRtosMutexTest.cpp +++ b/Tests/FreeRtos/SolidSyslogFreeRtosMutexTest.cpp @@ -5,14 +5,15 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "FreeRTOS.h" #include "FreeRtosSemaphoreFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFreeRtosMutex.h" #include "SolidSyslogFreeRtosMutexErrors.h" #include "SolidSyslogMutex.h" #include "SolidSyslogMutexDefinition.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" -#include "FreeRTOS.h" // Asserts handle is non-null and not one of the slots in pool. #define CHECK_IS_FALLBACK(handle, pool) \ @@ -135,7 +136,8 @@ TEST(SolidSyslogFreeRtosMutexPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&FreeRtosMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(FREERTOSMUTEX_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(FREERTOSMUTEX_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogFreeRtosMutexPool, FallbackLockUnlockAreNoOps) @@ -211,7 +213,8 @@ TEST(SolidSyslogFreeRtosMutexPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&FreeRtosMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(FREERTOSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(FREERTOSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogFreeRtosMutexPool, DestroyOfStaleHandleReportsWarning) @@ -227,5 +230,6 @@ TEST(SolidSyslogFreeRtosMutexPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&FreeRtosMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(FREERTOSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(FREERTOSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/FreeRtos/SolidSyslogPlusTcpAddressTest.cpp b/Tests/FreeRtos/SolidSyslogPlusTcpAddressTest.cpp index 37b6bbd7..e8a31dbe 100644 --- a/Tests/FreeRtos/SolidSyslogPlusTcpAddressTest.cpp +++ b/Tests/FreeRtos/SolidSyslogPlusTcpAddressTest.cpp @@ -5,14 +5,15 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "FreeRTOS.h" +#include "FreeRTOS_IP.h" +#include "FreeRTOS_Sockets.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPlusTcpAddress.h" #include "SolidSyslogPlusTcpAddressErrors.h" #include "SolidSyslogPlusTcpAddressPrivate.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" -#include "FreeRTOS.h" -#include "FreeRTOS_IP.h" -#include "FreeRTOS_Sockets.h" // Asserts handle is non-null and not one of the slots in pool. #define CHECK_IS_FALLBACK(handle, pool) \ @@ -134,7 +135,8 @@ TEST(SolidSyslogPlusTcpAddressPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPADDRESS_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPADDRESS_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpAddressPool, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -196,7 +198,8 @@ TEST(SolidSyslogPlusTcpAddressPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpAddressPool, DestroyOfStaleHandleReportsWarning) @@ -212,5 +215,6 @@ TEST(SolidSyslogPlusTcpAddressPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/FreeRtos/SolidSyslogPlusTcpDatagramTest.cpp b/Tests/FreeRtos/SolidSyslogPlusTcpDatagramTest.cpp index 8c7dbfac..c48994f0 100644 --- a/Tests/FreeRtos/SolidSyslogPlusTcpDatagramTest.cpp +++ b/Tests/FreeRtos/SolidSyslogPlusTcpDatagramTest.cpp @@ -8,8 +8,15 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "FreeRTOS.h" +#include "FreeRTOS_IP.h" +#include "FreeRTOS_Sockets.h" +#include "FreeRtosArpFake.h" +#include "FreeRtosSocketsFake.h" +#include "FreeRtosTaskFake.h" #include "SolidSyslogDatagram.h" #include "SolidSyslogDatagramDefinition.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPlusTcpAddress.h" #include "SolidSyslogPlusTcpAddressPrivate.h" #include "SolidSyslogPlusTcpDatagram.h" @@ -17,12 +24,6 @@ using namespace CososoTesting; #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" #include "SolidSyslogUdpPayload.h" -#include "FreeRtosArpFake.h" -#include "FreeRtosSocketsFake.h" -#include "FreeRtosTaskFake.h" -#include "FreeRTOS.h" -#include "FreeRTOS_IP.h" -#include "FreeRTOS_Sockets.h" // Asserts handle is non-null and not one of the slots in pool. #define CHECK_IS_FALLBACK(handle, pool) \ @@ -334,7 +335,8 @@ TEST(SolidSyslogPlusTcpDatagramPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPDATAGRAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPDATAGRAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpDatagramPool, FallbackVtableMethodsAreNoOps) @@ -417,7 +419,8 @@ TEST(SolidSyslogPlusTcpDatagramPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpDatagramPool, DestroyOfStaleHandleReportsWarning) @@ -433,5 +436,6 @@ TEST(SolidSyslogPlusTcpDatagramPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/FreeRtos/SolidSyslogPlusTcpResolverTest.cpp b/Tests/FreeRtos/SolidSyslogPlusTcpResolverTest.cpp index a3d5ffe0..0455d5c9 100644 --- a/Tests/FreeRtos/SolidSyslogPlusTcpResolverTest.cpp +++ b/Tests/FreeRtos/SolidSyslogPlusTcpResolverTest.cpp @@ -21,6 +21,7 @@ using namespace CososoTesting; #include "FreeRTOS.h" #include "FreeRTOS_IP.h" #include "FreeRTOS_Sockets.h" +#include "SolidSyslogErrorCategory.h" // Asserts handle is non-null and not one of the slots in pool. #define CHECK_IS_FALLBACK(handle, pool) \ @@ -190,7 +191,8 @@ TEST(SolidSyslogPlusTcpResolverPoolTest, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPRESOLVER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPRESOLVER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpResolverPoolTest, FallbackResolveReturnsFalse) @@ -258,7 +260,8 @@ TEST(SolidSyslogPlusTcpResolverPoolTest, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpResolverPoolTest, DestroyOfStaleHandleReportsWarning) @@ -273,5 +276,6 @@ TEST(SolidSyslogPlusTcpResolverPoolTest, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/FreeRtos/SolidSyslogPlusTcpTcpStreamTest.cpp b/Tests/FreeRtos/SolidSyslogPlusTcpTcpStreamTest.cpp index 617c6f2a..6c70c95b 100644 --- a/Tests/FreeRtos/SolidSyslogPlusTcpTcpStreamTest.cpp +++ b/Tests/FreeRtos/SolidSyslogPlusTcpTcpStreamTest.cpp @@ -8,6 +8,13 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "FreeRTOS.h" +#include "FreeRTOS_IP.h" +#include "FreeRTOS_Sockets.h" +#include "FreeRtosArpFake.h" +#include "FreeRtosSocketsFake.h" +#include "FreeRtosTaskFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPlusTcpAddress.h" #include "SolidSyslogPlusTcpAddressPrivate.h" #include "SolidSyslogPlusTcpTcpStream.h" @@ -16,12 +23,6 @@ using namespace CososoTesting; #include "SolidSyslogStream.h" #include "SolidSyslogStreamDefinition.h" #include "SolidSyslogTunables.h" -#include "FreeRtosArpFake.h" -#include "FreeRtosSocketsFake.h" -#include "FreeRtosTaskFake.h" -#include "FreeRTOS.h" -#include "FreeRTOS_IP.h" -#include "FreeRTOS_Sockets.h" // Asserts handle is non-null and not one of the slots in pool. #define CHECK_IS_FALLBACK(handle, pool) \ @@ -514,7 +515,8 @@ TEST(SolidSyslogPlusTcpTcpStreamPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPTCPSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPTCPSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpTcpStreamPool, FallbackVtableMethodsAreNoOps) @@ -600,7 +602,8 @@ TEST(SolidSyslogPlusTcpTcpStreamPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPlusTcpTcpStreamPool, DestroyOfStaleHandleReportsWarning) @@ -616,5 +619,6 @@ TEST(SolidSyslogPlusTcpTcpStreamPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PlusTcpTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PLUSTCPTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PLUSTCPTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/Lwip/SolidSyslogLwipRawAddressTest.cpp b/Tests/Lwip/SolidSyslogLwipRawAddressTest.cpp index afb6ad8d..a1aed830 100644 --- a/Tests/Lwip/SolidSyslogLwipRawAddressTest.cpp +++ b/Tests/Lwip/SolidSyslogLwipRawAddressTest.cpp @@ -6,6 +6,7 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawAddress.h" #include "SolidSyslogLwipRawAddressErrors.h" #include "SolidSyslogLwipRawAddressPrivate.h" @@ -27,13 +28,14 @@ using namespace CososoTesting; // Asserts the most recent ErrorHandlerFake call matched (severity, source, code). // Use after the act-phase of a test that expects exactly one SolidSyslog_Error call. -#define CHECK_REPORTED(severity, source, code) \ - do \ - { \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ - POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ +#define CHECK_REPORTED(severity, source, expectedCategory, code) \ + do \ + { \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ + POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) // clang-format off @@ -148,7 +150,12 @@ TEST(SolidSyslogLwipRawAddressPool, ExhaustedCreateReportsError) overflow = SolidSyslogLwipRawAddress_Create(); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_ERROR, LwipRawAddressErrorSource, LWIPRAWADDRESS_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_ERROR, + LwipRawAddressErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + LWIPRAWADDRESS_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogLwipRawAddressPool, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -207,7 +214,12 @@ TEST(SolidSyslogLwipRawAddressPool, DestroyOfUnknownHandleReportsWarning) SolidSyslogLwipRawAddress_Destroy((struct SolidSyslogAddress*) &stranger); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawAddressErrorSource, LWIPRAWADDRESS_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawAddressErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWADDRESS_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogLwipRawAddressPool, DestroyOfStaleHandleReportsWarning) @@ -220,5 +232,10 @@ TEST(SolidSyslogLwipRawAddressPool, DestroyOfStaleHandleReportsWarning) SolidSyslogLwipRawAddress_Destroy(pooled[0]); pooled[0] = nullptr; - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawAddressErrorSource, LWIPRAWADDRESS_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawAddressErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWADDRESS_ERROR_UNKNOWN_DESTROY + ); } diff --git a/Tests/Lwip/SolidSyslogLwipRawDatagramTest.cpp b/Tests/Lwip/SolidSyslogLwipRawDatagramTest.cpp index ea34caf4..7cccb4e2 100644 --- a/Tests/Lwip/SolidSyslogLwipRawDatagramTest.cpp +++ b/Tests/Lwip/SolidSyslogLwipRawDatagramTest.cpp @@ -13,6 +13,7 @@ using namespace CososoTesting; #include "LwipUdpFake.h" #include "SolidSyslogDatagram.h" #include "SolidSyslogDatagramDefinition.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawAddress.h" #include "SolidSyslogLwipRawAddressPrivate.h" #include "SolidSyslogLwipRawDatagram.h" @@ -41,13 +42,14 @@ static const uint16_t TEST_PORT = 514; // Asserts the most recent ErrorHandlerFake call matched (severity, source, code). // Use after the act-phase of a test that expects exactly one SolidSyslog_Error call. -#define CHECK_REPORTED(severity, source, code) \ - do \ - { \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ - POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ +#define CHECK_REPORTED(severity, source, expectedCategory, code) \ + do \ + { \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ + POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) /* Shared fixture: every Datagram lifecycle test needs the fake reset, a fresh @@ -386,7 +388,12 @@ TEST(SolidSyslogLwipRawDatagramPool, ExhaustedCreateReportsError) overflow = SolidSyslogLwipRawDatagram_Create(); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_ERROR, LwipRawDatagramErrorSource, LWIPRAWDATAGRAM_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_ERROR, + LwipRawDatagramErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + LWIPRAWDATAGRAM_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogLwipRawDatagramPool, FallbackVtableMethodsAreNoOps) @@ -457,7 +464,12 @@ TEST(SolidSyslogLwipRawDatagramPool, DestroyOfUnknownHandleReportsWarning) SolidSyslogLwipRawDatagram_Destroy(&stranger); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawDatagramErrorSource, LWIPRAWDATAGRAM_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawDatagramErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWDATAGRAM_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogLwipRawDatagramPool, DestroyOfStaleHandleReportsWarning) @@ -469,5 +481,10 @@ TEST(SolidSyslogLwipRawDatagramPool, DestroyOfStaleHandleReportsWarning) SolidSyslogLwipRawDatagram_Destroy(pooled[0]); pooled[0] = nullptr; - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawDatagramErrorSource, LWIPRAWDATAGRAM_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawDatagramErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWDATAGRAM_ERROR_UNKNOWN_DESTROY + ); } diff --git a/Tests/Lwip/SolidSyslogLwipRawDnsResolverTest.cpp b/Tests/Lwip/SolidSyslogLwipRawDnsResolverTest.cpp index 3810dc15..3b66fdd8 100644 --- a/Tests/Lwip/SolidSyslogLwipRawDnsResolverTest.cpp +++ b/Tests/Lwip/SolidSyslogLwipRawDnsResolverTest.cpp @@ -9,12 +9,14 @@ using namespace CososoTesting; #include "ErrorHandlerFake.h" #include "LwipDnsFake.h" #include "LwipFakeMarshalGuard.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawAddress.h" #include "SolidSyslogLwipRawAddressPrivate.h" #include "SolidSyslogLwipRawDnsResolver.h" #include "SolidSyslogLwipRawDnsResolverErrors.h" #include "SolidSyslogPrival.h" #include "SolidSyslogResolver.h" +#include "SolidSyslogResolverCategories.h" #include "SolidSyslogResolverDefinition.h" #include "SolidSyslogTransport.h" #include "SolidSyslogTunables.h" @@ -35,13 +37,14 @@ using namespace CososoTesting; } while (0) // Asserts the most recent ErrorHandlerFake call matched (severity, source, code). -#define CHECK_REPORTED(severity, source, code) \ - do \ - { \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ - POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ +#define CHECK_REPORTED(severity, source, expectedCategory, code) \ + do \ + { \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ + POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) static const char* const TEST_HOST = "syslog-ng"; @@ -315,6 +318,7 @@ TEST(SolidSyslogLwipRawDnsResolver, ResolveReportsWarningOnTimeout) CHECK_REPORTED( SOLIDSYSLOG_SEVERITY_WARNING, LwipRawDnsResolverErrorSource, + SOLIDSYSLOG_CAT_RESOLVER_RESOLVE_FAILED, LWIPRAWDNSRESOLVER_ERROR_RESOLVE_TIMEOUT ); } @@ -457,7 +461,12 @@ TEST(SolidSyslogLwipRawDnsResolverPool, ExhaustedCreateReportsError) overflow = SolidSyslogLwipRawDnsResolver_Create(&config); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_ERROR, LwipRawDnsResolverErrorSource, LWIPRAWDNSRESOLVER_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_ERROR, + LwipRawDnsResolverErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + LWIPRAWDNSRESOLVER_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogLwipRawDnsResolverPool, FallbackResolveReturnsFalse) @@ -525,6 +534,7 @@ TEST(SolidSyslogLwipRawDnsResolverPool, DestroyOfUnknownHandleReportsWarning) CHECK_REPORTED( SOLIDSYSLOG_SEVERITY_WARNING, LwipRawDnsResolverErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, LWIPRAWDNSRESOLVER_ERROR_UNKNOWN_DESTROY ); } @@ -541,6 +551,7 @@ TEST(SolidSyslogLwipRawDnsResolverPool, DestroyOfStaleHandleReportsWarning) CHECK_REPORTED( SOLIDSYSLOG_SEVERITY_WARNING, LwipRawDnsResolverErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, LWIPRAWDNSRESOLVER_ERROR_UNKNOWN_DESTROY ); } diff --git a/Tests/Lwip/SolidSyslogLwipRawResolverTest.cpp b/Tests/Lwip/SolidSyslogLwipRawResolverTest.cpp index 5c04dafd..eff42753 100644 --- a/Tests/Lwip/SolidSyslogLwipRawResolverTest.cpp +++ b/Tests/Lwip/SolidSyslogLwipRawResolverTest.cpp @@ -8,6 +8,7 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawAddress.h" #include "SolidSyslogLwipRawAddressPrivate.h" #include "SolidSyslogLwipRawResolver.h" @@ -33,13 +34,14 @@ using namespace CososoTesting; // Asserts the most recent ErrorHandlerFake call matched (severity, source, code). // Use after the act-phase of a test that expects exactly one SolidSyslog_Error call. -#define CHECK_REPORTED(severity, source, code) \ - do \ - { \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ - POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ +#define CHECK_REPORTED(severity, source, expectedCategory, code) \ + do \ + { \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ + POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) static const char* const TEST_HOST = "127.0.0.1"; @@ -176,7 +178,12 @@ TEST(SolidSyslogLwipRawResolverPool, ExhaustedCreateReportsError) overflow = SolidSyslogLwipRawResolver_Create(); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_ERROR, LwipRawResolverErrorSource, LWIPRAWRESOLVER_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_ERROR, + LwipRawResolverErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + LWIPRAWRESOLVER_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogLwipRawResolverPool, FallbackResolveReturnsFalse) @@ -247,7 +254,12 @@ TEST(SolidSyslogLwipRawResolverPool, DestroyOfUnknownHandleReportsWarning) SolidSyslogLwipRawResolver_Destroy(&stranger); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawResolverErrorSource, LWIPRAWRESOLVER_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawResolverErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWRESOLVER_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogLwipRawResolverPool, DestroyOfStaleHandleReportsWarning) @@ -260,7 +272,12 @@ TEST(SolidSyslogLwipRawResolverPool, DestroyOfStaleHandleReportsWarning) SolidSyslogLwipRawResolver_Destroy(pooled[0]); pooled[0] = nullptr; - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawResolverErrorSource, LWIPRAWRESOLVER_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawResolverErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWRESOLVER_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogLwipRawResolver, UdpTransportResolvesIdenticallyToTcp) diff --git a/Tests/Lwip/SolidSyslogLwipRawTcpStreamTest.cpp b/Tests/Lwip/SolidSyslogLwipRawTcpStreamTest.cpp index b76cb068..c78847f3 100644 --- a/Tests/Lwip/SolidSyslogLwipRawTcpStreamTest.cpp +++ b/Tests/Lwip/SolidSyslogLwipRawTcpStreamTest.cpp @@ -13,6 +13,7 @@ using namespace CososoTesting; #include "LwipFakeMarshalGuard.h" #include "LwipPbufFake.h" #include "LwipTcpFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogLwipRawAddress.h" #include "SolidSyslogLwipRawAddressPrivate.h" #include "SolidSyslogLwipRawTcpStream.h" @@ -45,13 +46,14 @@ static const uint16_t TEST_PORT = 514; } while (0) // Asserts the most recent ErrorHandlerFake call matched (severity, source, code). -#define CHECK_REPORTED(severity, source, code) \ - do \ - { \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ - POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ +#define CHECK_REPORTED(severity, source, expectedCategory, code) \ + do \ + { \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ + POINTERS_EQUAL(&(source), ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) // Asserts the lwIP API call recorded the pcb the wrapper got back from @@ -783,7 +785,12 @@ TEST(SolidSyslogLwipRawTcpStreamPool, ExhaustedCreateReportsError) overflow = SolidSyslogLwipRawTcpStream_Create(&validConfig); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_ERROR, LwipRawTcpStreamErrorSource, LWIPRAWTCPSTREAM_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_ERROR, + LwipRawTcpStreamErrorSource, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + LWIPRAWTCPSTREAM_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogLwipRawTcpStreamPool, FallbackVtableMethodsAreNoOps) @@ -849,7 +856,12 @@ TEST(SolidSyslogLwipRawTcpStreamPool, DestroyOfUnknownHandleReportsWarning) SolidSyslogLwipRawTcpStream_Destroy(&stranger); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawTcpStreamErrorSource, LWIPRAWTCPSTREAM_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawTcpStreamErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWTCPSTREAM_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogLwipRawTcpStreamPool, DestroyOfStaleHandleReportsWarning) @@ -862,5 +874,10 @@ TEST(SolidSyslogLwipRawTcpStreamPool, DestroyOfStaleHandleReportsWarning) SolidSyslogLwipRawTcpStream_Destroy(stale); - CHECK_REPORTED(SOLIDSYSLOG_SEVERITY_WARNING, LwipRawTcpStreamErrorSource, LWIPRAWTCPSTREAM_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED( + SOLIDSYSLOG_SEVERITY_WARNING, + LwipRawTcpStreamErrorSource, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + LWIPRAWTCPSTREAM_ERROR_UNKNOWN_DESTROY + ); } diff --git a/Tests/MbedTls/SolidSyslogMbedTlsAesGcmPolicyTest.cpp b/Tests/MbedTls/SolidSyslogMbedTlsAesGcmPolicyTest.cpp index 60127d37..eccfa91d 100644 --- a/Tests/MbedTls/SolidSyslogMbedTlsAesGcmPolicyTest.cpp +++ b/Tests/MbedTls/SolidSyslogMbedTlsAesGcmPolicyTest.cpp @@ -18,6 +18,8 @@ extern "C" #include "SolidSyslogTunables.h" } +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "TestUtils.h" using namespace CososoTesting; @@ -62,13 +64,14 @@ static bool TestGetKey(void* context, uint8_t* keyOut, size_t capacity, size_t* } // NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) -#define CHECK_REPORTED_ERROR(severity, code) \ +#define CHECK_REPORTED_ERROR(severity, expectedCategory, code) \ do \ { \ CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ POINTERS_EQUAL(&MbedTlsAesGcmPolicyErrorSource, ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) // NOLINTEND(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) @@ -78,22 +81,30 @@ static bool TestGetKey(void* context, uint8_t* keyOut, size_t capacity, size_t* * as a one-line test: seal/open must fail closed and report once. Used only * inside the Seal fixture (they reference its seal()/open() helpers). */ // NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) -#define CHECK_SEAL_REPORTS_ENCRYPT_FAILURE_AT(step) \ - do \ - { \ - ErrorHandlerFake_Install(nullptr); \ - MbedTlsFake_SetGcmStepFails(step); \ - CHECK_FALSE(seal()); \ - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_ENCRYPT_FAILED); \ +#define CHECK_SEAL_REPORTS_ENCRYPT_FAILURE_AT(step) \ + do \ + { \ + ErrorHandlerFake_Install(nullptr); \ + MbedTlsFake_SetGcmStepFails(step); \ + CHECK_FALSE(seal()); \ + CHECK_REPORTED_ERROR( \ + SOLIDSYSLOG_SEVERITY_ERROR, \ + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, \ + MBEDTLSAESGCMPOLICY_ERROR_ENCRYPT_FAILED \ + ); \ } while (0) -#define CHECK_OPEN_REPORTS_DECRYPT_FAILURE_AT(step) \ - do \ - { \ - ErrorHandlerFake_Install(nullptr); \ - MbedTlsFake_SetGcmStepFails(step); \ - CHECK_FALSE(open()); \ - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_DECRYPT_FAILED); \ +#define CHECK_OPEN_REPORTS_DECRYPT_FAILURE_AT(step) \ + do \ + { \ + ErrorHandlerFake_Install(nullptr); \ + MbedTlsFake_SetGcmStepFails(step); \ + CHECK_FALSE(open()); \ + CHECK_REPORTED_ERROR( \ + SOLIDSYSLOG_SEVERITY_ERROR, \ + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED, \ + MBEDTLSAESGCMPOLICY_ERROR_DECRYPT_FAILED \ + ); \ } while (0) // NOLINTEND(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) @@ -228,7 +239,11 @@ TEST(SolidSyslogMbedTlsAesGcmPolicy, ExhaustedCreateReportsError) overflow = SolidSyslogMbedTlsAesGcmPolicy_Create(&config); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + MBEDTLSAESGCMPOLICY_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogMbedTlsAesGcmPolicy, NullConfigReturnsNullFallback) @@ -256,7 +271,7 @@ TEST(SolidSyslogMbedTlsAesGcmPolicy, BadConfigReportsError) SolidSyslogMbedTlsAesGcmPolicy_Create(nullptr); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_BAD_CONFIG); + CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_CAT_BAD_CONFIG, MBEDTLSAESGCMPOLICY_ERROR_BAD_CONFIG); } TEST(SolidSyslogMbedTlsAesGcmPolicy, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -288,7 +303,11 @@ TEST(SolidSyslogMbedTlsAesGcmPolicy, DestroyOfUnknownHandleReportsWarning) SolidSyslogMbedTlsAesGcmPolicy_Destroy(&stranger); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, MBEDTLSAESGCMPOLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + MBEDTLSAESGCMPOLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogMbedTlsAesGcmPolicy, DestroyOfStaleHandleReportsWarning) @@ -300,7 +319,11 @@ TEST(SolidSyslogMbedTlsAesGcmPolicy, DestroyOfStaleHandleReportsWarning) SolidSyslogMbedTlsAesGcmPolicy_Destroy(pooled[0]); pooled[0] = nullptr; - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, MBEDTLSAESGCMPOLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + MBEDTLSAESGCMPOLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogMbedTlsAesGcmPolicySeal, SealRecordGeneratesAFreshNonceIntoTheTrailer) @@ -390,7 +413,11 @@ TEST(SolidSyslogMbedTlsAesGcmPolicySeal, SealFailsClosedWhenKeyUnavailable) keyAvailable = false; CHECK_FALSE(seal()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogMbedTlsAesGcmPolicySeal, SealFailsClosedWhenKeyIsWrongLength) @@ -399,7 +426,11 @@ TEST(SolidSyslogMbedTlsAesGcmPolicySeal, SealFailsClosedWhenKeyIsWrongLength) keyLengthToReport = 16; /* AES-256 requires exactly 32 bytes */ CHECK_FALSE(seal()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogMbedTlsAesGcmPolicySeal, OpenFailsClosedWhenKeyUnavailable) @@ -409,7 +440,11 @@ TEST(SolidSyslogMbedTlsAesGcmPolicySeal, OpenFailsClosedWhenKeyUnavailable) keyAvailable = false; CHECK_FALSE(open()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + MBEDTLSAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogMbedTlsAesGcmPolicySeal, SealReportsNonceFailure) @@ -418,7 +453,11 @@ TEST(SolidSyslogMbedTlsAesGcmPolicySeal, SealReportsNonceFailure) MbedTlsFake_SetCtrDrbgRandomFails(true); CHECK_FALSE(seal()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSAESGCMPOLICY_ERROR_NONCE_FAILED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + MBEDTLSAESGCMPOLICY_ERROR_NONCE_FAILED + ); } /* Seal threads setkey then crypt_and_tag; a non-zero from either must fail diff --git a/Tests/MbedTls/SolidSyslogMbedTlsHmacSha256PolicyTest.cpp b/Tests/MbedTls/SolidSyslogMbedTlsHmacSha256PolicyTest.cpp index 0dbcc540..c60fdb8b 100644 --- a/Tests/MbedTls/SolidSyslogMbedTlsHmacSha256PolicyTest.cpp +++ b/Tests/MbedTls/SolidSyslogMbedTlsHmacSha256PolicyTest.cpp @@ -17,6 +17,8 @@ extern "C" #include +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "TestUtils.h" using namespace CososoTesting; @@ -59,13 +61,14 @@ static bool TestGetKey(void* context, uint8_t* keyOut, size_t capacity, size_t* /* Asserts exactly one error of (severity, code) was reported from this policy's source. */ // NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) -#define CHECK_REPORTED_ERROR(severity, code) \ +#define CHECK_REPORTED_ERROR(severity, expectedCategory, code) \ do \ { \ CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ POINTERS_EQUAL(&MbedTlsHmacSha256PolicyErrorSource, ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) // NOLINTEND(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) @@ -195,7 +198,11 @@ TEST(SolidSyslogMbedTlsHmacSha256Policy, ExhaustedCreateReportsError) overflow = SolidSyslogMbedTlsHmacSha256Policy_Create(&config); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + MBEDTLSHMACSHA256POLICY_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogMbedTlsHmacSha256Policy, NullConfigReturnsNullFallback) @@ -216,7 +223,11 @@ TEST(SolidSyslogMbedTlsHmacSha256Policy, BadConfigReportsError) SolidSyslogMbedTlsHmacSha256Policy_Create(nullptr); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_BAD_CONFIG); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_BAD_CONFIG, + MBEDTLSHMACSHA256POLICY_ERROR_BAD_CONFIG + ); } TEST(SolidSyslogMbedTlsHmacSha256Policy, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -248,7 +259,11 @@ TEST(SolidSyslogMbedTlsHmacSha256Policy, DestroyOfUnknownHandleReportsWarning) SolidSyslogMbedTlsHmacSha256Policy_Destroy(&stranger); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, MBEDTLSHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + MBEDTLSHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogMbedTlsHmacSha256Policy, DestroyOfStaleHandleReportsWarning) @@ -260,7 +275,11 @@ TEST(SolidSyslogMbedTlsHmacSha256Policy, DestroyOfStaleHandleReportsWarning) SolidSyslogMbedTlsHmacSha256Policy_Destroy(pooled[0]); pooled[0] = nullptr; - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, MBEDTLSHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + MBEDTLSHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogMbedTlsHmacSha256PolicySeal, SealRecordHmacsTheRecordWithTheFetchedKey) @@ -299,7 +318,11 @@ TEST(SolidSyslogMbedTlsHmacSha256PolicySeal, SealRecordReportsHmacFailure) bool sealed = seal(TEST_RECORD, sizeof TEST_RECORD, tag); CHECK_FALSE(sealed); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_HMAC_FAILED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + MBEDTLSHMACSHA256POLICY_ERROR_HMAC_FAILED + ); } TEST(SolidSyslogMbedTlsHmacSha256PolicySeal, SealRecordReportsKeyUnavailable) @@ -311,7 +334,11 @@ TEST(SolidSyslogMbedTlsHmacSha256PolicySeal, SealRecordReportsKeyUnavailable) bool sealed = seal(TEST_RECORD, sizeof TEST_RECORD, tag); CHECK_FALSE(sealed); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, MBEDTLSHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + MBEDTLSHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogMbedTlsHmacSha256PolicySeal, SealRecordWipesTheKeyBufferAfterUse) @@ -350,3 +377,23 @@ TEST(SolidSyslogMbedTlsHmacSha256PolicySeal, OpenRecordFailsClosedWhenKeyUnavail CHECK_FALSE(verify(TEST_RECORD, sizeof TEST_RECORD, tag)); } + +// An HMAC computation failure during verify is an OPEN failure, not a SEAL +// failure — the same ComputeTag helper serves both paths, so the category must +// be chosen by the caller. +TEST(SolidSyslogMbedTlsHmacSha256PolicySeal, OpenRecordReportsHmacFailureAsOpenFailed) +{ + uint8_t tag[HMAC_SHA256_TAG_SIZE] = {}; + seal(TEST_RECORD, sizeof TEST_RECORD, tag); + ErrorHandlerFake_Install(nullptr); + MbedTlsFake_SetMdHmacReturn(-1); + + bool verified = verify(TEST_RECORD, sizeof TEST_RECORD, tag); + + CHECK_FALSE(verified); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED, + MBEDTLSHMACSHA256POLICY_ERROR_HMAC_FAILED + ); +} diff --git a/Tests/MbedTls/SolidSyslogMbedTlsStreamPoolTest.cpp b/Tests/MbedTls/SolidSyslogMbedTlsStreamPoolTest.cpp index f904423e..ef00183b 100644 --- a/Tests/MbedTls/SolidSyslogMbedTlsStreamPoolTest.cpp +++ b/Tests/MbedTls/SolidSyslogMbedTlsStreamPoolTest.cpp @@ -14,6 +14,7 @@ extern "C" #include "StreamFake.h" } +#include "SolidSyslogErrorCategory.h" #include "TestUtils.h" using namespace CososoTesting; @@ -104,7 +105,8 @@ TEST(SolidSyslogMbedTlsStreamPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&MbedTlsStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(MBEDTLSSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(MBEDTLSSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogMbedTlsStreamPool, FallbackSendReturnsTrueToDropOnTheFloor) @@ -169,7 +171,8 @@ TEST(SolidSyslogMbedTlsStreamPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&MbedTlsStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(MBEDTLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(MBEDTLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogMbedTlsStreamPool, DestroyOfStaleHandleReportsWarning) @@ -184,5 +187,6 @@ TEST(SolidSyslogMbedTlsStreamPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&MbedTlsStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(MBEDTLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(MBEDTLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/MbedTls/SolidSyslogMbedTlsStreamTest.cpp b/Tests/MbedTls/SolidSyslogMbedTlsStreamTest.cpp index 8ce71acb..fdbb5e90 100644 --- a/Tests/MbedTls/SolidSyslogMbedTlsStreamTest.cpp +++ b/Tests/MbedTls/SolidSyslogMbedTlsStreamTest.cpp @@ -19,20 +19,23 @@ extern "C" #include "StreamFake.h" } +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogTlsStreamCategories.h" #include "TestUtils.h" using namespace CososoTesting; -#define CHECK_OPEN_UNWOUND_WITH_ERROR(transport, expectedCode) \ - do \ - { \ - LONGS_EQUAL(1, StreamFake_CloseCallCount(transport)); \ - LONGS_EQUAL(1, MbedTlsFake_SslFreeCallCount()); \ - LONGS_EQUAL(1, MbedTlsFake_SslConfigFreeCallCount()); \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - POINTERS_EQUAL(&MbedTlsStreamErrorSource, ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((expectedCode), ErrorHandlerFake_LastCode()); \ - LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); \ +#define CHECK_OPEN_UNWOUND_WITH_ERROR(transport, expectedCategory, expectedCode) \ + do \ + { \ + LONGS_EQUAL(1, StreamFake_CloseCallCount(transport)); \ + LONGS_EQUAL(1, MbedTlsFake_SslFreeCallCount()); \ + LONGS_EQUAL(1, MbedTlsFake_SslConfigFreeCallCount()); \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + POINTERS_EQUAL(&MbedTlsStreamErrorSource, ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((expectedCode), ErrorHandlerFake_LastDetail()); \ + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); \ } while (0) static int NoOpSleepCallCount; @@ -276,7 +279,11 @@ TEST(SolidSyslogMbedTlsStream, OpenClosesTransportAndFreesSslStateWhenHandshakeB ArrangePersistentHandshakeError(MBEDTLS_ERR_SSL_WANT_READ); CHECK_FALSE(SolidSyslogStream_Open(handle, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, MBEDTLSSTREAM_ERROR_HANDSHAKE_TIMEOUT); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + MBEDTLSSTREAM_ERROR_HANDSHAKE_TIMEOUT + ); } TEST(SolidSyslogMbedTlsStream, OpenInvokesConfiguredHandshakeTimeoutGetter) @@ -339,7 +346,11 @@ TEST(SolidSyslogMbedTlsStream, OpenClosesTransportAndFreesSslStateWhenHandshakeF CHECK_FALSE(SolidSyslogStream_Open(handle, addr)); CALLED_FAKE(MbedTlsFake_SslHandshake, ONCE); CALLED_FUNCTION(NoOpSleep, NEVER); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, MBEDTLSSTREAM_ERROR_HANDSHAKE_REJECTED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + MBEDTLSSTREAM_ERROR_HANDSHAKE_REJECTED + ); } /* ------------------------------------------------------------------------- @@ -355,7 +366,11 @@ TEST(SolidSyslogMbedTlsStream, OpenClosesTransportAndFreesSslStateWhenSslConfigD MbedTlsFake_SetSslConfigDefaultsReturn(-1); CHECK_FALSE(SolidSyslogStream_Open(handle, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, MBEDTLSSTREAM_ERROR_DEFAULTS_NOT_APPLIED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + MBEDTLSSTREAM_ERROR_DEFAULTS_NOT_APPLIED + ); } TEST(SolidSyslogMbedTlsStream, OpenClosesTransportAndFreesSslStateWhenSslSetupFails) @@ -364,7 +379,11 @@ TEST(SolidSyslogMbedTlsStream, OpenClosesTransportAndFreesSslStateWhenSslSetupFa MbedTlsFake_SetSslSetupReturn(-1); CHECK_FALSE(SolidSyslogStream_Open(handle, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, MBEDTLSSTREAM_ERROR_SESSION_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + MBEDTLSSTREAM_ERROR_SESSION_INIT_FAILED + ); } TEST(SolidSyslogMbedTlsStream, OpenClosesTransportAndFreesSslStateWhenSetHostnameFails) @@ -377,7 +396,7 @@ TEST(SolidSyslogMbedTlsStream, OpenClosesTransportAndFreesSslStateWhenSetHostnam MbedTlsFake_SetSslSetHostnameReturn(-1); CHECK_FALSE(SolidSyslogStream_Open(handle, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, MBEDTLSSTREAM_ERROR_SERVER_NAME_NOT_SET); + CHECK_OPEN_UNWOUND_WITH_ERROR(transport, SOLIDSYSLOG_CAT_BAD_CONFIG, MBEDTLSSTREAM_ERROR_SERVER_NAME_NOT_SET); } TEST(SolidSyslogMbedTlsStream, SendForwardsBufferToSslWrite) diff --git a/Tests/SolidSyslogCircularBufferTest.cpp b/Tests/SolidSyslogCircularBufferTest.cpp index dc87da2b..0b9cb4e1 100644 --- a/Tests/SolidSyslogCircularBufferTest.cpp +++ b/Tests/SolidSyslogCircularBufferTest.cpp @@ -10,6 +10,7 @@ #include "SolidSyslogBufferDefinition.h" #include "SolidSyslogCircularBuffer.h" #include "SolidSyslogCircularBufferErrors.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullMutex.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" @@ -435,7 +436,8 @@ TEST(SolidSyslogCircularBufferPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&CircularBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(CIRCULARBUFFER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(CIRCULARBUFFER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogCircularBufferPool, FallbackWriteAndReadAreNoOps) @@ -505,7 +507,8 @@ TEST(SolidSyslogCircularBufferPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&CircularBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(CIRCULARBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(CIRCULARBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogCircularBufferPool, DestroyOfStaleHandleReportsWarning) @@ -520,5 +523,6 @@ TEST(SolidSyslogCircularBufferPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&CircularBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(CIRCULARBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(CIRCULARBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogErrorTest.cpp b/Tests/SolidSyslogErrorTest.cpp index 47e2f320..aad13f20 100644 --- a/Tests/SolidSyslogErrorTest.cpp +++ b/Tests/SolidSyslogErrorTest.cpp @@ -18,20 +18,21 @@ TEST_GROUP(SolidSyslogErrorEx) TEST(SolidSyslogErrorEx, ErrorExWithDefaultHandlerDoesNotCrash) { static const struct SolidSyslogErrorSource source = {"test", nullptr}; - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &source, 0U); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &source, 0U, 0); } -TEST(SolidSyslogErrorEx, InstalledHandlerReceivesSeveritySourceCodeAndContext) +TEST(SolidSyslogErrorEx, InstalledHandlerReceivesEventFieldsAndContext) { static const struct SolidSyslogErrorSource source = {"test", nullptr}; ErrorHandlerFake_Install(&sentinel); - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, &source, 7U); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, &source, 7U, 42); CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&source, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(7U, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(7U, ErrorHandlerFake_LastCategory()); + LONGS_EQUAL(42, ErrorHandlerFake_LastDetail()); POINTERS_EQUAL(&sentinel, ErrorHandlerFake_LastContext()); } @@ -41,7 +42,7 @@ TEST(SolidSyslogErrorEx, SetErrorHandlerExWithNullHandlerRestoresDefault) ErrorHandlerFake_Install(&sentinel); SolidSyslog_SetErrorHandler(nullptr, &sentinel); - SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &source, 0U); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, &source, 0U, 0); CALLED_FAKE(ErrorHandlerFake_Handle, NEVER); } diff --git a/Tests/SolidSyslogGetAddrInfoResolverTest.cpp b/Tests/SolidSyslogGetAddrInfoResolverTest.cpp index bbdd8b17..ef6d526d 100644 --- a/Tests/SolidSyslogGetAddrInfoResolverTest.cpp +++ b/Tests/SolidSyslogGetAddrInfoResolverTest.cpp @@ -4,7 +4,10 @@ #include #include "ConfigLockFake.h" +#include "CppUTest/TestHarness.h" #include "ErrorHandlerFake.h" +#include "SocketFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogGetAddrInfoResolver.h" #include "SolidSyslogGetAddrInfoResolverErrors.h" #include "SolidSyslogPosixAddress.h" @@ -12,11 +15,9 @@ #include "SolidSyslogPrival.h" #include "SolidSyslogResolver.h" #include "SolidSyslogResolverDefinition.h" -#include "SocketFake.h" #include "SolidSyslogTransport.h" #include "SolidSyslogTunables.h" #include "TestUtils.h" -#include "CppUTest/TestHarness.h" using namespace CososoTesting; @@ -190,7 +191,8 @@ TEST(SolidSyslogGetAddrInfoResolverPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&GetAddrInfoResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(GETADDRINFORESOLVER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(GETADDRINFORESOLVER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogGetAddrInfoResolverPool, FallbackResolveReturnsFalse) @@ -257,7 +259,8 @@ TEST(SolidSyslogGetAddrInfoResolverPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&GetAddrInfoResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(GETADDRINFORESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(GETADDRINFORESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogGetAddrInfoResolverPool, DestroyOfStaleHandleReportsWarning) @@ -272,5 +275,6 @@ TEST(SolidSyslogGetAddrInfoResolverPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&GetAddrInfoResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(GETADDRINFORESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(GETADDRINFORESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogMetaSdTest.cpp b/Tests/SolidSyslogMetaSdTest.cpp index 9d33115a..024fd4d7 100644 --- a/Tests/SolidSyslogMetaSdTest.cpp +++ b/Tests/SolidSyslogMetaSdTest.cpp @@ -1,8 +1,10 @@ #include #include +#include "CppUTest/TestHarness.h" #include "ErrorHandlerFake.h" #include "SolidSyslogAtomicCounterTestHelper.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFormatter.h" #include "SolidSyslogMetaSd.h" #include "SolidSyslogMetaSdErrors.h" @@ -10,7 +12,6 @@ #include "SolidSyslogStructuredData.h" #include "SolidSyslogTunables.h" #include "TestUtils.h" -#include "CppUTest/TestHarness.h" using namespace CososoTesting; @@ -277,7 +278,8 @@ TEST(SolidSyslogMetaSd, CreateWithNullConfigReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&MetaSdErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(METASD_ERROR_NULL_CONFIG, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(METASD_ERROR_NULL_CONFIG, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogMetaSd, CreateWithNullCounterReportsWarning) @@ -288,7 +290,8 @@ TEST(SolidSyslogMetaSd, CreateWithNullCounterReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&MetaSdErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(METASD_ERROR_NULL_COUNTER, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(METASD_ERROR_NULL_COUNTER, ErrorHandlerFake_LastDetail()); } // Pool tests — prove SOLIDSYSLOG_META_SD_POOL_SIZE caps live instances diff --git a/Tests/SolidSyslogOpenSslAesGcmPolicyTest.cpp b/Tests/SolidSyslogOpenSslAesGcmPolicyTest.cpp index 5b13d016..46e20a91 100644 --- a/Tests/SolidSyslogOpenSslAesGcmPolicyTest.cpp +++ b/Tests/SolidSyslogOpenSslAesGcmPolicyTest.cpp @@ -15,6 +15,8 @@ extern "C" #include "SolidSyslogTunables.h" } +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "TestUtils.h" using namespace CososoTesting; @@ -58,13 +60,14 @@ static bool TestGetKey(void* context, uint8_t* keyOut, size_t capacity, size_t* } // NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) -#define CHECK_REPORTED_ERROR(severity, code) \ +#define CHECK_REPORTED_ERROR(severity, expectedCategory, code) \ do \ { \ CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ POINTERS_EQUAL(&OpenSslAesGcmPolicyErrorSource, ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) // NOLINTEND(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) @@ -74,22 +77,30 @@ static bool TestGetKey(void* context, uint8_t* keyOut, size_t capacity, size_t* * test: seal/open must fail closed and report once. Used only inside the Seal * fixture (they reference its seal()/open() helpers). */ // NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) -#define CHECK_SEAL_REPORTS_ENCRYPT_FAILURE_AT(step) \ - do \ - { \ - ErrorHandlerFake_Install(nullptr); \ - OpenSslFake_SetGcmStepFails(step); \ - CHECK_FALSE(seal()); \ - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_ENCRYPT_FAILED); \ +#define CHECK_SEAL_REPORTS_ENCRYPT_FAILURE_AT(step) \ + do \ + { \ + ErrorHandlerFake_Install(nullptr); \ + OpenSslFake_SetGcmStepFails(step); \ + CHECK_FALSE(seal()); \ + CHECK_REPORTED_ERROR( \ + SOLIDSYSLOG_SEVERITY_ERROR, \ + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, \ + OPENSSLAESGCMPOLICY_ERROR_ENCRYPT_FAILED \ + ); \ } while (0) -#define CHECK_OPEN_REPORTS_DECRYPT_FAILURE_AT(step) \ - do \ - { \ - ErrorHandlerFake_Install(nullptr); \ - OpenSslFake_SetGcmStepFails(step); \ - CHECK_FALSE(open()); \ - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_DECRYPT_FAILED); \ +#define CHECK_OPEN_REPORTS_DECRYPT_FAILURE_AT(step) \ + do \ + { \ + ErrorHandlerFake_Install(nullptr); \ + OpenSslFake_SetGcmStepFails(step); \ + CHECK_FALSE(open()); \ + CHECK_REPORTED_ERROR( \ + SOLIDSYSLOG_SEVERITY_ERROR, \ + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED, \ + OPENSSLAESGCMPOLICY_ERROR_DECRYPT_FAILED \ + ); \ } while (0) // NOLINTEND(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) @@ -222,7 +233,11 @@ TEST(SolidSyslogOpenSslAesGcmPolicy, ExhaustedCreateReportsError) overflow = SolidSyslogOpenSslAesGcmPolicy_Create(&config); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + OPENSSLAESGCMPOLICY_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogOpenSslAesGcmPolicy, NullConfigReturnsNullFallback) @@ -243,7 +258,7 @@ TEST(SolidSyslogOpenSslAesGcmPolicy, BadConfigReportsError) SolidSyslogOpenSslAesGcmPolicy_Create(nullptr); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_BAD_CONFIG); + CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_CAT_BAD_CONFIG, OPENSSLAESGCMPOLICY_ERROR_BAD_CONFIG); } TEST(SolidSyslogOpenSslAesGcmPolicy, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -275,7 +290,11 @@ TEST(SolidSyslogOpenSslAesGcmPolicy, DestroyOfUnknownHandleReportsWarning) SolidSyslogOpenSslAesGcmPolicy_Destroy(&stranger); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, OPENSSLAESGCMPOLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + OPENSSLAESGCMPOLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogOpenSslAesGcmPolicy, DestroyOfStaleHandleReportsWarning) @@ -287,7 +306,11 @@ TEST(SolidSyslogOpenSslAesGcmPolicy, DestroyOfStaleHandleReportsWarning) SolidSyslogOpenSslAesGcmPolicy_Destroy(pooled[0]); pooled[0] = nullptr; - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, OPENSSLAESGCMPOLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + OPENSSLAESGCMPOLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogOpenSslAesGcmPolicySeal, SealRecordGeneratesAFreshNonceIntoTheTrailer) @@ -372,7 +395,11 @@ TEST(SolidSyslogOpenSslAesGcmPolicySeal, SealFailsClosedWhenKeyUnavailable) keyAvailable = false; CHECK_FALSE(seal()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogOpenSslAesGcmPolicySeal, SealFailsClosedWhenKeyIsWrongLength) @@ -381,7 +408,11 @@ TEST(SolidSyslogOpenSslAesGcmPolicySeal, SealFailsClosedWhenKeyIsWrongLength) keyLengthToReport = 16; /* AES-256 requires exactly 32 bytes */ CHECK_FALSE(seal()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogOpenSslAesGcmPolicySeal, OpenFailsClosedWhenKeyUnavailable) @@ -391,7 +422,11 @@ TEST(SolidSyslogOpenSslAesGcmPolicySeal, OpenFailsClosedWhenKeyUnavailable) keyAvailable = false; CHECK_FALSE(open()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + OPENSSLAESGCMPOLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogOpenSslAesGcmPolicySeal, SealReportsNonceFailure) @@ -400,7 +435,11 @@ TEST(SolidSyslogOpenSslAesGcmPolicySeal, SealReportsNonceFailure) OpenSslFake_SetRandBytesFails(true); CHECK_FALSE(seal()); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLAESGCMPOLICY_ERROR_NONCE_FAILED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + OPENSSLAESGCMPOLICY_ERROR_NONCE_FAILED + ); } /* Seal threads every EVP return through an && chain; any non-1 must fail closed diff --git a/Tests/SolidSyslogOpenSslHmacSha256PolicyTest.cpp b/Tests/SolidSyslogOpenSslHmacSha256PolicyTest.cpp index 43a1394f..da7630a9 100644 --- a/Tests/SolidSyslogOpenSslHmacSha256PolicyTest.cpp +++ b/Tests/SolidSyslogOpenSslHmacSha256PolicyTest.cpp @@ -17,6 +17,8 @@ extern "C" #include +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogSecurityPolicyCategories.h" #include "TestUtils.h" using namespace CososoTesting; @@ -59,13 +61,14 @@ static bool TestGetKey(void* context, uint8_t* keyOut, size_t capacity, size_t* /* Asserts exactly one error of (severity, code) was reported from this policy's source. */ // NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) -#define CHECK_REPORTED_ERROR(severity, code) \ +#define CHECK_REPORTED_ERROR(severity, expectedCategory, code) \ do \ { \ CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ LONGS_EQUAL((severity), ErrorHandlerFake_LastSeverity()); \ POINTERS_EQUAL(&OpenSslHmacSha256PolicyErrorSource, ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastCode()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((code), ErrorHandlerFake_LastDetail()); \ } while (0) // NOLINTEND(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) @@ -195,7 +198,11 @@ TEST(SolidSyslogOpenSslHmacSha256Policy, ExhaustedCreateReportsError) overflow = SolidSyslogOpenSslHmacSha256Policy_Create(&config); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_POOL_EXHAUSTED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_POOL_EXHAUSTED, + OPENSSLHMACSHA256POLICY_ERROR_POOL_EXHAUSTED + ); } TEST(SolidSyslogOpenSslHmacSha256Policy, NullConfigReturnsNullFallback) @@ -216,7 +223,11 @@ TEST(SolidSyslogOpenSslHmacSha256Policy, BadConfigReportsError) SolidSyslogOpenSslHmacSha256Policy_Create(nullptr); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_BAD_CONFIG); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_BAD_CONFIG, + OPENSSLHMACSHA256POLICY_ERROR_BAD_CONFIG + ); } TEST(SolidSyslogOpenSslHmacSha256Policy, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -248,7 +259,11 @@ TEST(SolidSyslogOpenSslHmacSha256Policy, DestroyOfUnknownHandleReportsWarning) SolidSyslogOpenSslHmacSha256Policy_Destroy(&stranger); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, OPENSSLHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + OPENSSLHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogOpenSslHmacSha256Policy, DestroyOfStaleHandleReportsWarning) @@ -260,7 +275,11 @@ TEST(SolidSyslogOpenSslHmacSha256Policy, DestroyOfStaleHandleReportsWarning) SolidSyslogOpenSslHmacSha256Policy_Destroy(pooled[0]); pooled[0] = nullptr; - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_WARNING, OPENSSLHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_WARNING, + SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, + OPENSSLHMACSHA256POLICY_ERROR_UNKNOWN_DESTROY + ); } TEST(SolidSyslogOpenSslHmacSha256PolicySeal, SealRecordHmacsTheRecordWithTheFetchedKey) @@ -299,7 +318,11 @@ TEST(SolidSyslogOpenSslHmacSha256PolicySeal, SealRecordReportsHmacFailure) bool sealed = seal(TEST_RECORD, sizeof TEST_RECORD, tag); CHECK_FALSE(sealed); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_HMAC_FAILED); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_SEAL_FAILED, + OPENSSLHMACSHA256POLICY_ERROR_HMAC_FAILED + ); } TEST(SolidSyslogOpenSslHmacSha256PolicySeal, SealRecordReportsKeyUnavailable) @@ -311,7 +334,11 @@ TEST(SolidSyslogOpenSslHmacSha256PolicySeal, SealRecordReportsKeyUnavailable) bool sealed = seal(TEST_RECORD, sizeof TEST_RECORD, tag); CHECK_FALSE(sealed); - CHECK_REPORTED_ERROR(SOLIDSYSLOG_SEVERITY_ERROR, OPENSSLHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_KEY_UNAVAILABLE, + OPENSSLHMACSHA256POLICY_ERROR_KEY_UNAVAILABLE + ); } TEST(SolidSyslogOpenSslHmacSha256PolicySeal, SealRecordWipesTheKeyBufferAfterUse) @@ -350,3 +377,23 @@ TEST(SolidSyslogOpenSslHmacSha256PolicySeal, OpenRecordFailsClosedWhenKeyUnavail CHECK_FALSE(verify(TEST_RECORD, sizeof TEST_RECORD, tag)); } + +// An HMAC computation failure during verify is an OPEN failure, not a SEAL +// failure — the same ComputeTag helper serves both paths, so the category must +// be chosen by the caller. +TEST(SolidSyslogOpenSslHmacSha256PolicySeal, OpenRecordReportsHmacFailureAsOpenFailed) +{ + uint8_t tag[HMAC_SHA256_TAG_SIZE] = {}; + seal(TEST_RECORD, sizeof TEST_RECORD, tag); + ErrorHandlerFake_Install(nullptr); + OpenSslFake_SetHmacFails(true); + + bool verified = verify(TEST_RECORD, sizeof TEST_RECORD, tag); + + CHECK_FALSE(verified); + CHECK_REPORTED_ERROR( + SOLIDSYSLOG_SEVERITY_ERROR, + SOLIDSYSLOG_CAT_SECURITYPOLICY_OPEN_FAILED, + OPENSSLHMACSHA256POLICY_ERROR_HMAC_FAILED + ); +} diff --git a/Tests/SolidSyslogPassthroughBufferTest.cpp b/Tests/SolidSyslogPassthroughBufferTest.cpp index 1c24187c..57c23737 100644 --- a/Tests/SolidSyslogPassthroughBufferTest.cpp +++ b/Tests/SolidSyslogPassthroughBufferTest.cpp @@ -5,12 +5,13 @@ using namespace CososoTesting; #include "ErrorHandlerFake.h" +#include "SenderFake.h" #include "SolidSyslogBuffer.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPassthroughBuffer.h" #include "SolidSyslogPassthroughBufferErrors.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" -#include "SenderFake.h" static const char* const TEST_MESSAGE = "hello"; static const size_t TEST_MESSAGE_LEN = 5; @@ -92,7 +93,8 @@ TEST(SolidSyslogPassthroughBuffer, DestroyWithNullHandleEmitsUnknownDestroyWarni CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PassthroughBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PASSTHROUGHBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PASSTHROUGHBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPassthroughBuffer, UseAfterDestroyIsCrashSafeViaNullBufferVtable) @@ -198,7 +200,8 @@ TEST(SolidSyslogPassthroughBufferPool, CreateWithNullSenderReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PassthroughBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(PASSTHROUGHBUFFER_ERROR_NULL_SENDER, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(PASSTHROUGHBUFFER_ERROR_NULL_SENDER, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPassthroughBufferPool, CreateWithNullSenderReturnsFallbackDistinctFromAnyPoolSlot) diff --git a/Tests/SolidSyslogPoolTest.cpp b/Tests/SolidSyslogPoolTest.cpp index 49cdf3dd..fdb10900 100644 --- a/Tests/SolidSyslogPoolTest.cpp +++ b/Tests/SolidSyslogPoolTest.cpp @@ -5,6 +5,7 @@ #include "SenderFake.h" #include "SolidSyslog.h" #include "SolidSyslogConfig.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogErrors.h" #include "SolidSyslogNullStore.h" #include "SolidSyslogPassthroughBuffer.h" @@ -91,7 +92,8 @@ TEST(SolidSyslogPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPool, FallbackLogSilentlyDropsTheMessage) @@ -163,7 +165,8 @@ TEST(SolidSyslogPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPool, DestroyOfStaleHandleReportsWarning) @@ -178,5 +181,6 @@ TEST(SolidSyslogPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogPosixAddressTest.cpp b/Tests/SolidSyslogPosixAddressTest.cpp index ac0b3942..f5f8c7f3 100644 --- a/Tests/SolidSyslogPosixAddressTest.cpp +++ b/Tests/SolidSyslogPosixAddressTest.cpp @@ -9,6 +9,7 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPosixAddress.h" #include "SolidSyslogPosixAddressErrors.h" #include "SolidSyslogPosixAddressPrivate.h" @@ -130,7 +131,8 @@ TEST(SolidSyslogPosixAddressPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXADDRESS_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXADDRESS_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixAddressPool, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -187,7 +189,8 @@ TEST(SolidSyslogPosixAddressPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixAddressPool, DestroyOfStaleHandleReportsWarning) @@ -202,5 +205,6 @@ TEST(SolidSyslogPosixAddressPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogPosixDatagramTest.cpp b/Tests/SolidSyslogPosixDatagramTest.cpp index de577dbd..d44d0ede 100644 --- a/Tests/SolidSyslogPosixDatagramTest.cpp +++ b/Tests/SolidSyslogPosixDatagramTest.cpp @@ -4,8 +4,10 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SocketFake.h" #include "SolidSyslogDatagram.h" #include "SolidSyslogDatagramDefinition.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPosixAddress.h" #include "SolidSyslogPosixAddressPrivate.h" #include "SolidSyslogPosixDatagram.h" @@ -13,7 +15,6 @@ using namespace CososoTesting; #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" #include "SolidSyslogUdpPayload.h" -#include "SocketFake.h" #include #include #include @@ -313,7 +314,8 @@ TEST(SolidSyslogPosixDatagramPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXDATAGRAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXDATAGRAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixDatagramPool, FallbackSendToReturnsSent) @@ -378,7 +380,8 @@ TEST(SolidSyslogPosixDatagramPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixDatagramPool, DestroyOfStaleHandleReportsWarning) @@ -393,5 +396,6 @@ TEST(SolidSyslogPosixDatagramPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogPosixFileTest.cpp b/Tests/SolidSyslogPosixFileTest.cpp index 978e3499..93351e6f 100644 --- a/Tests/SolidSyslogPosixFileTest.cpp +++ b/Tests/SolidSyslogPosixFileTest.cpp @@ -2,6 +2,7 @@ #include "CppUTest/TestHarness.h" #include "ErrorHandlerFake.h" #include "SocketFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFile.h" #include "SolidSyslogFileDefinition.h" #include "SolidSyslogPosixFile.h" @@ -178,7 +179,8 @@ TEST(SolidSyslogPosixFilePool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXFILE_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXFILE_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixFilePool, FallbackOpenReturnsFalse) @@ -243,7 +245,8 @@ TEST(SolidSyslogPosixFilePool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixFilePool, DestroyOfStaleHandleReportsWarning) @@ -258,5 +261,6 @@ TEST(SolidSyslogPosixFilePool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp b/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp index 3c80da02..16f00764 100644 --- a/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp +++ b/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp @@ -8,16 +8,18 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" #include "MqFake.h" +#include "SenderFake.h" +#include "SolidSyslog.h" #include "SolidSyslogBuffer.h" +#include "SolidSyslogBufferCategories.h" #include "SolidSyslogBufferDefinition.h" -#include "SolidSyslogPosixMessageQueueBuffer.h" -#include "SolidSyslogPosixMessageQueueBufferErrors.h" -#include "SolidSyslog.h" #include "SolidSyslogConfig.h" -#include "SolidSyslogTunables.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogNullStore.h" -#include "SenderFake.h" +#include "SolidSyslogPosixMessageQueueBuffer.h" +#include "SolidSyslogPosixMessageQueueBufferErrors.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogTunables.h" struct SolidSyslogStore; @@ -112,7 +114,8 @@ TEST(SolidSyslogPosixMessageQueueBuffer, WriteWhenMqSendFailsReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMessageQueueBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_SEND_FAILED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_SEND_FAILED, ErrorHandlerFake_LastDetail()); } /* Regression guard: the production check is errno-agnostic @@ -127,7 +130,8 @@ TEST(SolidSyslogPosixMessageQueueBuffer, WriteWithOversizedMessageReportsError) Write(); CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_SEND_FAILED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_SEND_FAILED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixMessageQueueBuffer, ReadWhenMqReceiveFailsReportsError) @@ -140,7 +144,8 @@ TEST(SolidSyslogPosixMessageQueueBuffer, ReadWhenMqReceiveFailsReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMessageQueueBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_RECEIVE_FAILED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_RECEIVE_FAILED, ErrorHandlerFake_LastDetail()); } /* Regression guard: empty queue (EAGAIN) is part of the happy poll loop @@ -268,7 +273,8 @@ TEST(SolidSyslogPosixMessageQueueBufferPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMessageQueueBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixMessageQueueBufferPool, CreateOnMqOpenFailureReportsError) @@ -281,7 +287,8 @@ TEST(SolidSyslogPosixMessageQueueBufferPool, CreateOnMqOpenFailureReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMessageQueueBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_MQ_OPEN_FAILED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BUFFER_BACKEND_FAILED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_MQ_OPEN_FAILED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixMessageQueueBufferPool, CreateOnMqOpenFailureReleasesSlot) @@ -368,7 +375,8 @@ TEST(SolidSyslogPosixMessageQueueBufferPool, DestroyOfUnknownHandleReportsWarnin CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMessageQueueBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } /* Destroy(NULL) is reachable from any integrator who keeps a NullBuffer-fallback @@ -384,7 +392,8 @@ TEST(SolidSyslogPosixMessageQueueBufferPool, DestroyOfNullHandleReportsWarningWi CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMessageQueueBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixMessageQueueBufferPool, DestroyOfStaleHandleReportsWarning) @@ -399,7 +408,8 @@ TEST(SolidSyslogPosixMessageQueueBufferPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMessageQueueBufferErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMESSAGEQUEUEBUFFER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } /* Slot-indexed queue names are only observable with at least two pool diff --git a/Tests/SolidSyslogPosixMutexTest.cpp b/Tests/SolidSyslogPosixMutexTest.cpp index e263bb85..2aa3375b 100644 --- a/Tests/SolidSyslogPosixMutexTest.cpp +++ b/Tests/SolidSyslogPosixMutexTest.cpp @@ -2,6 +2,7 @@ #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMutex.h" #include "SolidSyslogMutexDefinition.h" #include "SolidSyslogPosixMutex.h" @@ -104,7 +105,8 @@ TEST(SolidSyslogPosixMutexPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMUTEX_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMUTEX_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixMutexPool, FallbackLockUnlockAreNoOps) @@ -170,7 +172,8 @@ TEST(SolidSyslogPosixMutexPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixMutexPool, DestroyOfStaleHandleReportsWarning) @@ -185,5 +188,6 @@ TEST(SolidSyslogPosixMutexPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogPosixTcpStreamTest.cpp b/Tests/SolidSyslogPosixTcpStreamTest.cpp index 6ef48508..548cf395 100644 --- a/Tests/SolidSyslogPosixTcpStreamTest.cpp +++ b/Tests/SolidSyslogPosixTcpStreamTest.cpp @@ -12,6 +12,8 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SocketFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPosixAddress.h" #include "SolidSyslogPosixAddressPrivate.h" #include "SolidSyslogPosixTcpStream.h" @@ -21,7 +23,6 @@ using namespace CososoTesting; #include "SolidSyslogStreamDefinition.h" #include "SolidSyslogTransport.h" #include "SolidSyslogTunables.h" -#include "SocketFake.h" namespace { @@ -626,7 +627,8 @@ TEST(SolidSyslogPosixTcpStreamPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXTCPSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXTCPSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixTcpStreamPool, FallbackSendReturnsTrue) @@ -691,7 +693,8 @@ TEST(SolidSyslogPosixTcpStreamPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogPosixTcpStreamPool, DestroyOfStaleHandleReportsWarning) @@ -706,5 +709,6 @@ TEST(SolidSyslogPosixTcpStreamPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&PosixTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(POSIXTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(POSIXTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogStdAtomicCounterPoolTest.cpp b/Tests/SolidSyslogStdAtomicCounterPoolTest.cpp index c6ef3d1d..ba37dbdb 100644 --- a/Tests/SolidSyslogStdAtomicCounterPoolTest.cpp +++ b/Tests/SolidSyslogStdAtomicCounterPoolTest.cpp @@ -4,6 +4,7 @@ #include "ErrorHandlerFake.h" #include "SolidSyslogAtomicCounter.h" #include "SolidSyslogAtomicCounterDefinition.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogStdAtomicCounter.h" #include "SolidSyslogStdAtomicCounterErrors.h" @@ -76,7 +77,8 @@ TEST(SolidSyslogStdAtomicCounterPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&StdAtomicCounterErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(STDATOMICCOUNTER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(STDATOMICCOUNTER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogStdAtomicCounterPool, FallbackIncrementReturnsOne) @@ -141,7 +143,8 @@ TEST(SolidSyslogStdAtomicCounterPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&StdAtomicCounterErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(STDATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(STDATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogStdAtomicCounterPool, DestroyOfStaleHandleReportsWarning) @@ -156,5 +159,6 @@ TEST(SolidSyslogStdAtomicCounterPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&StdAtomicCounterErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(STDATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(STDATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogStreamSenderTest.cpp b/Tests/SolidSyslogStreamSenderTest.cpp index 70a1e074..a062a14f 100644 --- a/Tests/SolidSyslogStreamSenderTest.cpp +++ b/Tests/SolidSyslogStreamSenderTest.cpp @@ -4,8 +4,11 @@ #include #include +#include "CppUTest/TestHarness.h" #include "ErrorHandlerFake.h" +#include "SocketFake.h" #include "SolidSyslogEndpoint.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFormatter.h" #include "SolidSyslogGetAddrInfoResolver.h" #include "SolidSyslogPosixAddress.h" @@ -15,9 +18,7 @@ #include "SolidSyslogStreamSender.h" #include "SolidSyslogStreamSenderErrors.h" #include "SolidSyslogTunables.h" -#include "SocketFake.h" #include "TestUtils.h" -#include "CppUTest/TestHarness.h" using namespace CososoTesting; @@ -719,13 +720,14 @@ TEST(SolidSyslogStreamSenderPool, FillingPoolThenOverflowReturnsDistinctFallback // SolidSyslogUdpSenderBadSetup contract from S12.06. /* Macro (not function) so test failures report the caller's __FILE__/__LINE__. */ -#define CHECK_STREAMSENDER_BAD_SETUP_ERROR(expectedCode) \ - do \ - { \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); \ - POINTERS_EQUAL(&StreamSenderErrorSource, ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((expectedCode), ErrorHandlerFake_LastCode()); \ +#define CHECK_STREAMSENDER_BAD_SETUP_ERROR(expectedCategory, expectedCode) \ + do \ + { \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); \ + POINTERS_EQUAL(&StreamSenderErrorSource, ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((expectedCode), ErrorHandlerFake_LastDetail()); \ } while (0) // clang-format off @@ -765,28 +767,28 @@ TEST_GROUP(SolidSyslogStreamSenderBadSetup) TEST(SolidSyslogStreamSenderBadSetup, CreateWithNullConfigReportsError) { SolidSyslogStreamSender_Create(nullptr); - CHECK_STREAMSENDER_BAD_SETUP_ERROR(STREAMSENDER_ERROR_NULL_CONFIG); + CHECK_STREAMSENDER_BAD_SETUP_ERROR(SOLIDSYSLOG_CAT_BAD_CONFIG, STREAMSENDER_ERROR_NULL_CONFIG); } TEST(SolidSyslogStreamSenderBadSetup, CreateWithNullResolverReportsError) { config.Resolver = nullptr; SolidSyslogStreamSender_Create(&config); - CHECK_STREAMSENDER_BAD_SETUP_ERROR(STREAMSENDER_ERROR_NULL_RESOLVER); + CHECK_STREAMSENDER_BAD_SETUP_ERROR(SOLIDSYSLOG_CAT_BAD_CONFIG, STREAMSENDER_ERROR_NULL_RESOLVER); } TEST(SolidSyslogStreamSenderBadSetup, CreateWithNullStreamReportsError) { config.Stream = nullptr; SolidSyslogStreamSender_Create(&config); - CHECK_STREAMSENDER_BAD_SETUP_ERROR(STREAMSENDER_ERROR_NULL_STREAM); + CHECK_STREAMSENDER_BAD_SETUP_ERROR(SOLIDSYSLOG_CAT_BAD_CONFIG, STREAMSENDER_ERROR_NULL_STREAM); } TEST(SolidSyslogStreamSenderBadSetup, CreateWithNullAddressReportsError) { config.Address = nullptr; SolidSyslogStreamSender_Create(&config); - CHECK_STREAMSENDER_BAD_SETUP_ERROR(STREAMSENDER_ERROR_NULL_ADDRESS); + CHECK_STREAMSENDER_BAD_SETUP_ERROR(SOLIDSYSLOG_CAT_BAD_CONFIG, STREAMSENDER_ERROR_NULL_ADDRESS); } TEST(SolidSyslogStreamSenderBadSetup, SendOnBadSetupSenderReturnsTrue) diff --git a/Tests/SolidSyslogSwitchingSenderTest.cpp b/Tests/SolidSyslogSwitchingSenderTest.cpp index 6c6109a0..3fbab4cc 100644 --- a/Tests/SolidSyslogSwitchingSenderTest.cpp +++ b/Tests/SolidSyslogSwitchingSenderTest.cpp @@ -1,15 +1,16 @@ #include #include +#include "CppUTest/TestHarness.h" #include "ErrorHandlerFake.h" #include "SenderFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogSender.h" #include "SolidSyslogSwitchingSender.h" #include "SolidSyslogSwitchingSenderErrors.h" #include "SolidSyslogTunables.h" #include "TestUtils.h" -#include "CppUTest/TestHarness.h" using namespace CososoTesting; @@ -386,7 +387,8 @@ TEST(SolidSyslogSwitchingSenderBadSetup, CreateWithNullConfigReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SwitchingSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SWITCHINGSENDER_ERROR_NULL_CONFIG, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SWITCHINGSENDER_ERROR_NULL_CONFIG, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogSwitchingSenderBadSetup, CreateWithNullSendersReportsError) @@ -396,7 +398,8 @@ TEST(SolidSyslogSwitchingSenderBadSetup, CreateWithNullSendersReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SwitchingSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SWITCHINGSENDER_ERROR_NULL_SENDERS, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SWITCHINGSENDER_ERROR_NULL_SENDERS, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogSwitchingSenderBadSetup, CreateWithNullSelectorReportsError) @@ -406,7 +409,8 @@ TEST(SolidSyslogSwitchingSenderBadSetup, CreateWithNullSelectorReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SwitchingSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SWITCHINGSENDER_ERROR_NULL_SELECTOR, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SWITCHINGSENDER_ERROR_NULL_SELECTOR, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogSwitchingSenderBadSetup, SendOnBadSetupSenderReturnsTrueAndDrops) diff --git a/Tests/SolidSyslogTest.cpp b/Tests/SolidSyslogTest.cpp index 3b6f47e1..32ba18d0 100644 --- a/Tests/SolidSyslogTest.cpp +++ b/Tests/SolidSyslogTest.cpp @@ -2,32 +2,33 @@ #include #include +#include "BufferFake.h" +#include "CppUTest/TestHarness.h" +#include "ErrorHandlerFake.h" +#include "SenderFake.h" #include "SolidSyslog.h" #include "SolidSyslogAtomicCounterTestHelper.h" +#include "SolidSyslogBuffer.h" +#include "SolidSyslogCircularBuffer.h" #include "SolidSyslogConfig.h" +#include "SolidSyslogErrorCategory.h" +#include "SolidSyslogErrors.h" +#include "SolidSyslogFormatter.h" #include "SolidSyslogMetaSd.h" -#include "SolidSyslogTimeQualitySd.h" -#include "SolidSyslogCircularBuffer.h" -#include "SolidSyslogPassthroughBuffer.h" #include "SolidSyslogNullMutex.h" #include "SolidSyslogNullStore.h" -#include "SolidSyslogFormatter.h" +#include "SolidSyslogPassthroughBuffer.h" +#include "SolidSyslogPrival.h" +#include "SolidSyslogStore.h" #include "SolidSyslogStructuredDataDefinition.h" +#include "SolidSyslogTimeQuality.h" +#include "SolidSyslogTimeQualitySd.h" +#include "SolidSyslogTimestamp.h" #include "SolidSyslogTunables.h" -#include "BufferFake.h" -#include "ErrorHandlerFake.h" -#include "SolidSyslogErrors.h" #include "StoreFake.h" -#include "SenderFake.h" #include "StringFake.h" #include "SyslogFieldParser.h" -#include "SolidSyslogBuffer.h" -#include "SolidSyslogPrival.h" -#include "SolidSyslogStore.h" -#include "SolidSyslogTimeQuality.h" -#include "SolidSyslogTimestamp.h" #include "TestUtils.h" -#include "CppUTest/TestHarness.h" using namespace CososoTesting; @@ -854,7 +855,8 @@ TEST(SolidSyslogLifecycle, ServiceWithNullHandleReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_SERVICE_NULL_HANDLE, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_ARGUMENT, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_SERVICE_NULL_HANDLE, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, LogWithNullHandleReportsError) @@ -866,7 +868,8 @@ TEST(SolidSyslogLifecycle, LogWithNullHandleReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_LOG_NULL_HANDLE, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_ARGUMENT, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_LOG_NULL_HANDLE, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, LogWithNullMessageReportsError) @@ -880,7 +883,8 @@ TEST(SolidSyslogLifecycle, LogWithNullMessageReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_LOG_NULL_MESSAGE, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_ARGUMENT, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_LOG_NULL_MESSAGE, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, CreateWithNullConfigReportsError) @@ -892,7 +896,8 @@ TEST(SolidSyslogLifecycle, CreateWithNullConfigReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_CONFIG, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_CONFIG, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, CreateWithNullBufferReportsError) @@ -906,7 +911,8 @@ TEST(SolidSyslogLifecycle, CreateWithNullBufferReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_BUFFER, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_BUFFER, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, CreateWithNullSenderReportsError) @@ -920,7 +926,8 @@ TEST(SolidSyslogLifecycle, CreateWithNullSenderReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_SENDER, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_SENDER, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, CreateWithNullStoreReportsError) @@ -934,7 +941,8 @@ TEST(SolidSyslogLifecycle, CreateWithNullStoreReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_STORE, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_NULL_STORE, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, CreateWithNullSdArrayAndNonZeroCountReportsError) @@ -949,7 +957,8 @@ TEST(SolidSyslogLifecycle, CreateWithNullSdArrayAndNonZeroCountReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_INCONSISTENT_SD, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_CREATE_INCONSISTENT_SD, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, ServiceWithDefaultStoreDrainsThroughToRealSender) @@ -977,7 +986,8 @@ TEST(SolidSyslogLifecycle, DestroyWithUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, DestroyWithNullHandleReportsWarning) @@ -989,7 +999,8 @@ TEST(SolidSyslogLifecycle, DestroyWithNullHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&SolidSyslogErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogLifecycle, CreateWithNullConfigDoesNotBlockSubsequentCreate) diff --git a/Tests/SolidSyslogTimeQualitySdTest.cpp b/Tests/SolidSyslogTimeQualitySdTest.cpp index c98876b2..045ba0b9 100644 --- a/Tests/SolidSyslogTimeQualitySdTest.cpp +++ b/Tests/SolidSyslogTimeQualitySdTest.cpp @@ -3,6 +3,7 @@ #include "CppUTest/TestHarness.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFormatter.h" #include "SolidSyslogPrival.h" #include "SolidSyslogStructuredData.h" @@ -238,5 +239,6 @@ TEST(SolidSyslogTimeQualitySdBadSetup, CreateWithNullCallbackReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&TimeQualitySdErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(TIMEQUALITYSD_ERROR_NULL_CALLBACK, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(TIMEQUALITYSD_ERROR_NULL_CALLBACK, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogTlsStreamPoolTest.cpp b/Tests/SolidSyslogTlsStreamPoolTest.cpp index a52dc02a..a6fee390 100644 --- a/Tests/SolidSyslogTlsStreamPoolTest.cpp +++ b/Tests/SolidSyslogTlsStreamPoolTest.cpp @@ -14,6 +14,7 @@ extern "C" #include "StreamFake.h" } +#include "SolidSyslogErrorCategory.h" #include "TestUtils.h" using namespace CososoTesting; @@ -101,7 +102,8 @@ TEST(SolidSyslogTlsStreamPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&TlsStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(TLSSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(TLSSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogTlsStreamPool, FallbackSendReturnsTrueToDropOnTheFloor) @@ -166,7 +168,8 @@ TEST(SolidSyslogTlsStreamPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&TlsStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(TLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(TLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogTlsStreamPool, DestroyOfStaleHandleReportsWarning) @@ -181,5 +184,6 @@ TEST(SolidSyslogTlsStreamPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&TlsStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(TLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(TLSSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogTlsStreamTest.cpp b/Tests/SolidSyslogTlsStreamTest.cpp index d6c9dd20..933d1e7e 100644 --- a/Tests/SolidSyslogTlsStreamTest.cpp +++ b/Tests/SolidSyslogTlsStreamTest.cpp @@ -5,29 +5,32 @@ #include #include +#include "AddressFake.h" +#include "CppUTest/TestHarness.h" #include "ErrorHandlerFake.h" #include "OpenSslFake.h" -#include "AddressFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogStream.h" #include "SolidSyslogTlsStream.h" +#include "SolidSyslogTlsStreamCategories.h" #include "SolidSyslogTlsStreamErrors.h" #include "SolidSyslogTransport.h" #include "SolidSyslogTunables.h" #include "StreamFake.h" #include "TestUtils.h" -#include "CppUTest/TestHarness.h" using namespace CososoTesting; -#define CHECK_OPEN_UNWOUND_WITH_ERROR(transport, expectedCode) \ - do \ - { \ - LONGS_EQUAL(1, StreamFake_CloseCallCount(transport)); \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - POINTERS_EQUAL(&TlsStreamErrorSource, ErrorHandlerFake_LastSource()); \ - UNSIGNED_LONGS_EQUAL((expectedCode), ErrorHandlerFake_LastCode()); \ - LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); \ +#define CHECK_OPEN_UNWOUND_WITH_ERROR(transport, expectedCategory, expectedCode) \ + do \ + { \ + LONGS_EQUAL(1, StreamFake_CloseCallCount(transport)); \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + POINTERS_EQUAL(&TlsStreamErrorSource, ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + UNSIGNED_LONGS_EQUAL((expectedCode), ErrorHandlerFake_LastDetail()); \ + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); \ } while (0) class TEST_SolidSyslogTlsStream_ReadReturnsNegativeOneOnHardErrorAndClosesSsl_Test; @@ -281,7 +284,11 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenCipherListRejected) ReCreateStreamWithUpdatedConfig(); OpenSslFake_SetCipherListFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, CipherListFailureFreesCtx) @@ -686,7 +693,11 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenHandshakeFails) OpenSslFake_SetConnectFails(true); OpenSslFake_SetGetErrorReturn(SSL_ERROR_SSL); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_HANDSHAKE_REJECTED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + TLSSTREAM_ERROR_HANDSHAKE_REJECTED + ); } TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenSet1HostFails) @@ -695,7 +706,7 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenSet1HostFails) ReCreateStreamWithUpdatedConfig(); OpenSslFake_SetSet1HostFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_SERVER_NAME_NOT_SET); + CHECK_OPEN_UNWOUND_WITH_ERROR(transport, SOLIDSYSLOG_CAT_BAD_CONFIG, TLSSTREAM_ERROR_SERVER_NAME_NOT_SET); } TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenSniHostnameSetupFails) @@ -704,28 +715,40 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenSniHostnameSetupFails) ReCreateStreamWithUpdatedConfig(); OpenSslFake_SetSniHostnameFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_SERVER_NAME_NOT_SET); + CHECK_OPEN_UNWOUND_WITH_ERROR(transport, SOLIDSYSLOG_CAT_BAD_CONFIG, TLSSTREAM_ERROR_SERVER_NAME_NOT_SET); } TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenCtxNewFails) { OpenSslFake_SetCtxNewFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenSslNewFails) { OpenSslFake_SetSslNewFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_SESSION_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_SESSION_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenLoadVerifyLocationsFails) { OpenSslFake_SetLoadVerifyLocationsFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, LoadVerifyLocationsFailureFreesCtx) @@ -739,7 +762,11 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenMinProtoVersionFails) { OpenSslFake_SetMinProtoVersionFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, MinProtoVersionFailureFreesCtx) @@ -753,14 +780,22 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenBioMethNewFails) { OpenSslFake_SetBioMethNewFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_SESSION_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_SESSION_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenBioNewFails) { OpenSslFake_SetBioNewFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_SESSION_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_SESSION_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, BioNewFailureFreesBioMethodInline) @@ -893,7 +928,11 @@ TEST(SolidSyslogTlsStream, OpenFailsWhenOnlyClientCertIsSet) config.ClientKeyPath = nullptr; ReCreateStreamWithUpdatedConfig(); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, OpenMakesNoClientIdentityCallsWhenOnlyClientCertIsSet) @@ -914,7 +953,11 @@ TEST(SolidSyslogTlsStream, OpenFailsWhenOnlyClientKeyIsSet) config.ClientKeyPath = "/some/path/client.key"; ReCreateStreamWithUpdatedConfig(); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, OpenMakesNoClientIdentityCallsWhenOnlyClientKeyIsSet) @@ -946,7 +989,11 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenUseCertChainFileFails) ReCreateStreamWithUpdatedConfig(); OpenSslFake_SetUseCertChainFileFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, UseCertChainFileFailureFreesCtx) @@ -967,7 +1014,11 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenUsePrivateKeyFileFails) ReCreateStreamWithUpdatedConfig(); OpenSslFake_SetUsePrivateKeyFileFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, UsePrivateKeyFileFailureFreesCtx) @@ -988,7 +1039,11 @@ TEST(SolidSyslogTlsStream, OpenReturnsFalseWhenCheckPrivateKeyFails) ReCreateStreamWithUpdatedConfig(); OpenSslFake_SetCheckPrivateKeyFails(true); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_CONTEXT_INIT_FAILED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_INIT_FAILED, + TLSSTREAM_ERROR_CONTEXT_INIT_FAILED + ); } TEST(SolidSyslogTlsStream, CheckPrivateKeyFailureFreesCtx) @@ -1107,7 +1162,11 @@ TEST(SolidSyslogTlsStream, OpenFailsWhenHandshakeNeverCompletes) progress, so the bounded budget should expire and Open returns false. */ ArrangePersistentHandshakeError(SSL_ERROR_WANT_READ); CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_HANDSHAKE_TIMEOUT); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + TLSSTREAM_ERROR_HANDSHAKE_TIMEOUT + ); } TEST(SolidSyslogTlsStream, OpenInvokesConfiguredHandshakeTimeoutGetter) @@ -1146,7 +1205,11 @@ TEST(SolidSyslogTlsStream, OpenFailsImmediatelyOnHardSslError) CHECK_FALSE(SolidSyslogStream_Open(stream, addr)); CALLED_FAKE(OpenSslFake_Connect, ONCE); CALLED_FUNCTION(NoOpSleep, NEVER); - CHECK_OPEN_UNWOUND_WITH_ERROR(transport, TLSSTREAM_ERROR_HANDSHAKE_REJECTED); + CHECK_OPEN_UNWOUND_WITH_ERROR( + transport, + SOLIDSYSLOG_CAT_TLSSTREAM_HANDSHAKE_FAILED, + TLSSTREAM_ERROR_HANDSHAKE_REJECTED + ); } TEST(SolidSyslogTlsStream, SecondOpenAfterFailedFirstOpenSucceeds) diff --git a/Tests/SolidSyslogUdpSenderTest.cpp b/Tests/SolidSyslogUdpSenderTest.cpp index c0d45141..1703d716 100644 --- a/Tests/SolidSyslogUdpSenderTest.cpp +++ b/Tests/SolidSyslogUdpSenderTest.cpp @@ -4,24 +4,25 @@ #include #include +#include "CppUTest/TestHarness.h" #include "DatagramFake.h" #include "ErrorHandlerFake.h" +#include "SocketFake.h" +#include "SolidSyslogDatagram.h" #include "SolidSyslogEndpoint.h" #include "SolidSyslogError.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFormatter.h" #include "SolidSyslogGetAddrInfoResolver.h" #include "SolidSyslogPosixAddress.h" #include "SolidSyslogPosixDatagram.h" #include "SolidSyslogPrival.h" +#include "SolidSyslogSender.h" +#include "SolidSyslogSenderDefinition.h" #include "SolidSyslogTunables.h" #include "SolidSyslogUdpSender.h" #include "SolidSyslogUdpSenderErrors.h" -#include "SolidSyslogSender.h" -#include "SolidSyslogSenderDefinition.h" -#include "SocketFake.h" -#include "SolidSyslogDatagram.h" #include "TestUtils.h" -#include "CppUTest/TestHarness.h" using namespace CososoTesting; @@ -429,7 +430,8 @@ TEST(SolidSyslogUdpSenderDestroy, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } // clang-format off @@ -763,7 +765,8 @@ TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullConfigReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_CONFIG, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_CONFIG, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogUdpSenderBadSetup, SendOnBadSetupSenderReturnsTrue) @@ -785,7 +788,8 @@ TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullResolverReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_RESOLVER, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_RESOLVER, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullDatagramReportsError) @@ -795,7 +799,8 @@ TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullDatagramReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_DATAGRAM, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_DATAGRAM, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullEndpointReportsError) @@ -805,7 +810,8 @@ TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullEndpointReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_ENDPOINT, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_ENDPOINT, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullAddressReportsError) @@ -815,7 +821,8 @@ TEST(SolidSyslogUdpSenderBadSetup, CreateWithNullAddressReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_ADDRESS, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_CONFIG, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_NULL_ADDRESS, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogUdpSenderBadSetup, NullEndpointVersionIsOptional) @@ -833,7 +840,8 @@ TEST(SolidSyslogUdpSenderBadSetup, SendWithNullBufferReportsErrorAndDoesNotSend) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_SEND_NULL_BUFFER, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_BAD_ARGUMENT, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_SEND_NULL_BUFFER, ErrorHandlerFake_LastDetail()); CALLED_FAKE(SocketFake_Sendto, NEVER); } @@ -909,7 +917,8 @@ TEST(SolidSyslogUdpSenderPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&UdpSenderErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(UDPSENDER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST_GROUP(SolidSyslogUdpSenderErrorSource){}; diff --git a/Tests/SolidSyslogWindowsAtomicCounterPoolTest.cpp b/Tests/SolidSyslogWindowsAtomicCounterPoolTest.cpp index cb1d833b..30fabb22 100644 --- a/Tests/SolidSyslogWindowsAtomicCounterPoolTest.cpp +++ b/Tests/SolidSyslogWindowsAtomicCounterPoolTest.cpp @@ -4,6 +4,7 @@ #include "ErrorHandlerFake.h" #include "SolidSyslogAtomicCounter.h" #include "SolidSyslogAtomicCounterDefinition.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" #include "SolidSyslogWindowsAtomicCounter.h" @@ -76,7 +77,8 @@ TEST(SolidSyslogWindowsAtomicCounterPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsAtomicCounterErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSATOMICCOUNTER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSATOMICCOUNTER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWindowsAtomicCounterPool, FallbackIncrementReturnsOne) @@ -141,7 +143,8 @@ TEST(SolidSyslogWindowsAtomicCounterPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsAtomicCounterErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWindowsAtomicCounterPool, DestroyOfStaleHandleReportsWarning) @@ -156,5 +159,6 @@ TEST(SolidSyslogWindowsAtomicCounterPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsAtomicCounterErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSATOMICCOUNTER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogWindowsFileTest.cpp b/Tests/SolidSyslogWindowsFileTest.cpp index 7e09796f..a1b684e6 100644 --- a/Tests/SolidSyslogWindowsFileTest.cpp +++ b/Tests/SolidSyslogWindowsFileTest.cpp @@ -2,6 +2,7 @@ #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogFile.h" #include "SolidSyslogFileDefinition.h" #include "SolidSyslogPrival.h" @@ -206,7 +207,8 @@ TEST(SolidSyslogWindowsFilePool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSFILE_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSFILE_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWindowsFilePool, FallbackOpenReturnsFalse) @@ -271,7 +273,8 @@ TEST(SolidSyslogWindowsFilePool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWindowsFilePool, DestroyOfStaleHandleReportsWarning) @@ -286,5 +289,6 @@ TEST(SolidSyslogWindowsFilePool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsFileErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSFILE_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogWindowsMutexTest.cpp b/Tests/SolidSyslogWindowsMutexTest.cpp index f5a8a284..af087af9 100644 --- a/Tests/SolidSyslogWindowsMutexTest.cpp +++ b/Tests/SolidSyslogWindowsMutexTest.cpp @@ -2,6 +2,7 @@ #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogMutex.h" #include "SolidSyslogMutexDefinition.h" #include "SolidSyslogPrival.h" @@ -104,7 +105,8 @@ TEST(SolidSyslogWindowsMutexPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSMUTEX_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSMUTEX_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWindowsMutexPool, FallbackLockUnlockAreNoOps) @@ -170,7 +172,8 @@ TEST(SolidSyslogWindowsMutexPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWindowsMutexPool, DestroyOfStaleHandleReportsWarning) @@ -185,5 +188,6 @@ TEST(SolidSyslogWindowsMutexPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WindowsMutexErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINDOWSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINDOWSMUTEX_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogWinsockAddressTest.cpp b/Tests/SolidSyslogWinsockAddressTest.cpp index 0fafb93f..2b1504d6 100644 --- a/Tests/SolidSyslogWinsockAddressTest.cpp +++ b/Tests/SolidSyslogWinsockAddressTest.cpp @@ -8,6 +8,7 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" #include "SolidSyslogWinsockAddress.h" @@ -129,7 +130,8 @@ TEST(SolidSyslogWinsockAddressPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKADDRESS_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKADDRESS_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockAddressPool, CreateAcquiresAndReleasesConfigLockOnFirstFreeSlot) @@ -186,7 +188,8 @@ TEST(SolidSyslogWinsockAddressPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockAddressPool, DestroyOfStaleHandleReportsWarning) @@ -201,5 +204,6 @@ TEST(SolidSyslogWinsockAddressPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockAddressErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKADDRESS_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogWinsockDatagramTest.cpp b/Tests/SolidSyslogWinsockDatagramTest.cpp index cd13a4bc..ac352b06 100644 --- a/Tests/SolidSyslogWinsockDatagramTest.cpp +++ b/Tests/SolidSyslogWinsockDatagramTest.cpp @@ -4,13 +4,14 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" -#include "SolidSyslogWinsockAddress.h" -#include "SolidSyslogWinsockAddressPrivate.h" #include "SolidSyslogDatagram.h" #include "SolidSyslogDatagramDefinition.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogTunables.h" #include "SolidSyslogUdpPayload.h" +#include "SolidSyslogWinsockAddress.h" +#include "SolidSyslogWinsockAddressPrivate.h" #include "SolidSyslogWinsockDatagram.h" #include "SolidSyslogWinsockDatagramErrors.h" #include "SolidSyslogWinsockDatagramInternal.h" @@ -319,7 +320,8 @@ TEST(SolidSyslogWinsockDatagramPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKDATAGRAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKDATAGRAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockDatagramPool, FallbackSendToIsNoOp) @@ -390,7 +392,8 @@ TEST(SolidSyslogWinsockDatagramPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockDatagramPool, DestroyOfStaleHandleReportsWarning) @@ -405,5 +408,6 @@ TEST(SolidSyslogWinsockDatagramPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockDatagramErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKDATAGRAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogWinsockResolverTest.cpp b/Tests/SolidSyslogWinsockResolverTest.cpp index e54f55f3..c34472c8 100644 --- a/Tests/SolidSyslogWinsockResolverTest.cpp +++ b/Tests/SolidSyslogWinsockResolverTest.cpp @@ -4,12 +4,13 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" -#include "SolidSyslogWinsockAddress.h" -#include "SolidSyslogWinsockAddressPrivate.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogResolver.h" #include "SolidSyslogResolverDefinition.h" #include "SolidSyslogTunables.h" +#include "SolidSyslogWinsockAddress.h" +#include "SolidSyslogWinsockAddressPrivate.h" #include "SolidSyslogWinsockResolver.h" #include "SolidSyslogWinsockResolverErrors.h" #include "SolidSyslogWinsockResolverInternal.h" @@ -191,7 +192,8 @@ TEST(SolidSyslogWinsockResolverPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKRESOLVER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKRESOLVER_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockResolverPool, FallbackResolveIsNoOp) @@ -259,7 +261,8 @@ TEST(SolidSyslogWinsockResolverPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockResolverPool, DestroyOfStaleHandleReportsWarning) @@ -274,5 +277,6 @@ TEST(SolidSyslogWinsockResolverPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockResolverErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKRESOLVER_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } diff --git a/Tests/SolidSyslogWinsockTcpStreamTest.cpp b/Tests/SolidSyslogWinsockTcpStreamTest.cpp index 60c6e5bd..38ef5e14 100644 --- a/Tests/SolidSyslogWinsockTcpStreamTest.cpp +++ b/Tests/SolidSyslogWinsockTcpStreamTest.cpp @@ -4,13 +4,14 @@ using namespace CososoTesting; #include "ConfigLockFake.h" #include "ErrorHandlerFake.h" -#include "SolidSyslogWinsockAddress.h" -#include "SolidSyslogWinsockAddressPrivate.h" +#include "SolidSyslogErrorCategory.h" #include "SolidSyslogPrival.h" #include "SolidSyslogStream.h" #include "SolidSyslogStreamDefinition.h" #include "SolidSyslogTransport.h" #include "SolidSyslogTunables.h" +#include "SolidSyslogWinsockAddress.h" +#include "SolidSyslogWinsockAddressPrivate.h" #include "SolidSyslogWinsockTcpStream.h" #include "SolidSyslogWinsockTcpStreamErrors.h" #include "SolidSyslogWinsockTcpStreamInternal.h" @@ -581,7 +582,8 @@ TEST(SolidSyslogWinsockTcpStreamPool, ExhaustedCreateReportsError) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKTCPSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_POOL_EXHAUSTED, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKTCPSTREAM_ERROR_POOL_EXHAUSTED, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockTcpStreamPool, FallbackSendIsNoOp) @@ -646,7 +648,8 @@ TEST(SolidSyslogWinsockTcpStreamPool, DestroyOfUnknownHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockTcpStreamPool, DestroyOfStaleHandleReportsWarning) @@ -661,7 +664,8 @@ TEST(SolidSyslogWinsockTcpStreamPool, DestroyOfStaleHandleReportsWarning) CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); POINTERS_EQUAL(&WinsockTcpStreamErrorSource, ErrorHandlerFake_LastSource()); - UNSIGNED_LONGS_EQUAL(WINSOCKTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastCode()); + UNSIGNED_LONGS_EQUAL(SOLIDSYSLOG_CAT_UNKNOWN_DESTROY, ErrorHandlerFake_LastCategory()); + UNSIGNED_LONGS_EQUAL(WINSOCKTCPSTREAM_ERROR_UNKNOWN_DESTROY, ErrorHandlerFake_LastDetail()); } TEST(SolidSyslogWinsockTcpStream, DestroyClosesWithSocketFd) diff --git a/Tests/Support/ErrorHandlerFake.c b/Tests/Support/ErrorHandlerFake.c index bcba0eb3..09b1f3dc 100644 --- a/Tests/Support/ErrorHandlerFake.c +++ b/Tests/Support/ErrorHandlerFake.c @@ -7,20 +7,17 @@ static int handleCallCount; static enum SolidSyslogSeverity lastSeverity; static const struct SolidSyslogErrorSource* lastSource; -static uint8_t lastCode; +static uint16_t lastCategory; +static int32_t lastDetail; static const void* lastContext; -static void Handle( - void* context, - enum SolidSyslogSeverity severity, - const struct SolidSyslogErrorSource* source, - uint8_t code -) +static void Handle(void* context, const struct SolidSyslogErrorEvent* event) { handleCallCount++; - lastSeverity = severity; - lastSource = source; - lastCode = code; + lastSeverity = event->Severity; + lastSource = event->Source; + lastCategory = event->Category; + lastDetail = event->Detail; lastContext = context; } @@ -29,7 +26,8 @@ void ErrorHandlerFake_Install(void* context) handleCallCount = 0; lastSeverity = SOLIDSYSLOG_SEVERITY_DEBUG; lastSource = NULL; - lastCode = 0U; + lastCategory = 0U; + lastDetail = 0; lastContext = NULL; SolidSyslog_SetErrorHandler(Handle, context); } @@ -49,9 +47,14 @@ const struct SolidSyslogErrorSource* ErrorHandlerFake_LastSource(void) return lastSource; } -uint8_t ErrorHandlerFake_LastCode(void) +uint16_t ErrorHandlerFake_LastCategory(void) { - return lastCode; + return lastCategory; +} + +int32_t ErrorHandlerFake_LastDetail(void) +{ + return lastDetail; } const void* ErrorHandlerFake_LastContext(void) diff --git a/Tests/Support/ErrorHandlerFake.h b/Tests/Support/ErrorHandlerFake.h index 53e17cf1..0e5ced6e 100644 --- a/Tests/Support/ErrorHandlerFake.h +++ b/Tests/Support/ErrorHandlerFake.h @@ -14,7 +14,8 @@ EXTERN_C_BEGIN int ErrorHandlerFake_HandleCallCount(void); enum SolidSyslogSeverity ErrorHandlerFake_LastSeverity(void); const struct SolidSyslogErrorSource* ErrorHandlerFake_LastSource(void); - uint8_t ErrorHandlerFake_LastCode(void); + uint16_t ErrorHandlerFake_LastCategory(void); + int32_t ErrorHandlerFake_LastDetail(void); const void* ErrorHandlerFake_LastContext(void); EXTERN_C_END diff --git a/Tests/Support/TestUtils.h b/Tests/Support/TestUtils.h index 6aff92f2..0013efa8 100644 --- a/Tests/Support/TestUtils.h +++ b/Tests/Support/TestUtils.h @@ -36,4 +36,18 @@ enum #define CALLED_FAKE(getter, count) LONGS_EQUAL((count), getter##CallCount()) #define CALLED_FAKE_ON(getter, instance, count) LONGS_EQUAL((count), getter##CallCount(instance)) +/* Assert the last error event captured by ErrorHandlerFake matches an expected + * (source, category, detail) triple. Prefer the portable Category — it survives + * a backend swap — over the per-class Detail code when a portable reaction is + * the thing under test. Use at a site that includes "ErrorHandlerFake.h". */ +// NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) +#define CHECK_ERROR_EVENT(expectedSource, expectedCategory, expectedDetail) \ + do \ + { \ + POINTERS_EQUAL((expectedSource), ErrorHandlerFake_LastSource()); \ + UNSIGNED_LONGS_EQUAL((expectedCategory), ErrorHandlerFake_LastCategory()); \ + LONGS_EQUAL((expectedDetail), ErrorHandlerFake_LastDetail()); \ + } while (0) +// NOLINTEND(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) + #endif /* TESTUTILS_H */ diff --git a/misra_suppressions.txt b/misra_suppressions.txt index 3e9259b1..4e6c3138 100644 --- a/misra_suppressions.txt +++ b/misra_suppressions.txt @@ -34,59 +34,59 @@ misra-c2012-11.3:Core/Source/SolidSyslogPassthroughBuffer.c:49 misra-c2012-11.3:Core/Source/SolidSyslogStreamSender.c:147 misra-c2012-11.3:Core/Source/SolidSyslogSwitchingSender.c:59 misra-c2012-11.3:Core/Source/SolidSyslogTimeQualitySd.c:59 -misra-c2012-11.3:Core/Source/SolidSyslogUdpSender.c:101 +misra-c2012-11.3:Core/Source/SolidSyslogUdpSender.c:103 misra-c2012-11.3:Platform/Atomics/Source/SolidSyslogStdAtomicCounter.c:25 misra-c2012-11.3:Platform/FatFs/Source/SolidSyslogFatFsFile.c:45 misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawAddressPrivate.h:24 misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawAddressPrivate.h:31 -misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c:34 -misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c:54 +misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c:35 +misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawAddressStatic.c:56 misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawDatagram.c:61 -misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c:202 +misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c:205 misra-c2012-11.3:Platform/LwipRaw/Source/SolidSyslogLwipRawTcpStream.c:130 misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpAddress.c:10 misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressPrivate.h:19 misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressPrivate.h:26 -misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c:34 -misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c:54 +misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c:35 +misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpAddressStatic.c:56 misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpDatagram.c:49 misra-c2012-11.3:Platform/FreeRtos/Source/SolidSyslogFreeRtosMutex.c:40 misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpResolver.c:44 misra-c2012-11.3:Platform/PlusTcp/Source/SolidSyslogPlusTcpTcpStream.c:114 -misra-c2012-11.3:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:94 -misra-c2012-11.3:Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c:63 -misra-c2012-11.3:Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c:76 -misra-c2012-11.3:Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c:80 -misra-c2012-11.3:Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c:64 -misra-c2012-11.3:Platform/OpenSsl/Source/SolidSyslogTlsStream.c:82 +misra-c2012-11.3:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:96 +misra-c2012-11.3:Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c:66 +misra-c2012-11.3:Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c:78 +misra-c2012-11.3:Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c:82 +misra-c2012-11.3:Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c:67 +misra-c2012-11.3:Platform/OpenSsl/Source/SolidSyslogTlsStream.c:84 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixAddress.c:10 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixAddressPrivate.h:19 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixAddressPrivate.h:24 -misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixAddressStatic.c:34 -misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixAddressStatic.c:54 +misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixAddressStatic.c:35 +misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixAddressStatic.c:56 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixDatagram.c:55 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixFile.c:66 -misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c:129 +misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c:133 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixMutex.c:47 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixTcpStream.c:100 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockAddress.c:9 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockAddressPrivate.h:19 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockAddressPrivate.h:26 -misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c:34 -misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c:54 +misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c:35 +misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockAddressStatic.c:56 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWindowsAtomicCounter.c:29 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWindowsFile.c:73 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWindowsMutex.c:34 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockDatagram.c:94 misra-c2012-11.3:Platform/Windows/Source/SolidSyslogWinsockTcpStream.c:181 -misra-c2012-11.5:Core/Source/SolidSyslogUdpSender.c:205 +misra-c2012-11.5:Core/Source/SolidSyslogUdpSender.c:207 misra-c2012-11.5:Platform/LwipRaw/Source/SolidSyslogLwipRawDatagram.c:70 -misra-c2012-11.5:Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c:145 -misra-c2012-11.5:Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c:207 +misra-c2012-11.5:Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c:147 +misra-c2012-11.5:Platform/LwipRaw/Source/SolidSyslogLwipRawDnsResolver.c:210 misra-c2012-11.5:Platform/LwipRaw/Source/SolidSyslogLwipRawTcpStream.c:139 misra-c2012-11.5:Platform/LwipRaw/Source/SolidSyslogLwipRawTcpStream.c:147 -misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:271 -misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:283 +misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:278 +misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:290 misra-c2012-11.5:Platform/Windows/Source/SolidSyslogWinsockDatagram.c:138 misra-c2012-11.5:Platform/Windows/Source/SolidSyslogWinsockTcpStream.c:353 misra-c2012-11.5:Platform/Windows/Source/SolidSyslogWinsockTcpStream.c:373 @@ -102,7 +102,6 @@ misra-c2012-18.7:Core/Source/SolidSyslogFormatter.c:12 # D.006 — Rule 11.8: const-strip false-positives + platform-API (Winsock, lwIP) # See docs/misra-deviations.md#d006 misra-c2012-11.8:Core/Source/BlockSequence.c:465 -misra-c2012-11.8:Core/Source/SolidSyslog.c:50 misra-c2012-11.8:Core/Source/SolidSyslog.c:51 misra-c2012-11.8:Core/Source/SolidSyslog.c:52 misra-c2012-11.8:Core/Source/SolidSyslog.c:53 @@ -110,12 +109,13 @@ misra-c2012-11.8:Core/Source/SolidSyslog.c:54 misra-c2012-11.8:Core/Source/SolidSyslog.c:55 misra-c2012-11.8:Core/Source/SolidSyslog.c:56 misra-c2012-11.8:Core/Source/SolidSyslog.c:57 +misra-c2012-11.8:Core/Source/SolidSyslog.c:58 misra-c2012-11.8:Core/Source/SolidSyslogMessageFormatter.c:57 misra-c2012-11.8:Core/Source/SolidSyslogMessageFormatter.c:59 misra-c2012-11.8:Core/Source/SolidSyslogMessageFormatter.c:61 misra-c2012-11.8:Core/Source/SolidSyslogMessageFormatter.c:63 misra-c2012-11.8:Core/Source/SolidSyslogMessageFormatter.c:67 -misra-c2012-11.8:Core/Source/SolidSyslogBlockStoreStatic.c:40 +misra-c2012-11.8:Core/Source/SolidSyslogBlockStoreStatic.c:41 misra-c2012-11.8:Platform/LwipRaw/Source/SolidSyslogLwipRawDatagram.c:155 misra-c2012-11.8:Platform/Windows/Source/SolidSyslogWinsockTcpStream.c:93 @@ -142,12 +142,12 @@ misra-c2012-5.7:Core/Source/SolidSyslogStreamSender.c:19 misra-c2012-5.7:Core/Source/SolidSyslogUdpPayload.c:5 misra-c2012-5.7:Platform/PlusTcp/Source/SolidSyslogPlusTcpResolver.c:21 misra-c2012-5.7:Platform/PlusTcp/Source/SolidSyslogPlusTcpTcpStream.c:28 -misra-c2012-5.7:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:19 -misra-c2012-5.7:Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c:16 -misra-c2012-5.7:Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c:19 -misra-c2012-5.7:Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c:17 -misra-c2012-5.7:Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c:17 -misra-c2012-5.7:Platform/OpenSsl/Source/SolidSyslogTlsStream.c:21 +misra-c2012-5.7:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:21 +misra-c2012-5.7:Platform/MbedTls/Source/SolidSyslogMbedTlsHmacSha256Policy.c:18 +misra-c2012-5.7:Platform/MbedTls/Source/SolidSyslogMbedTlsAesGcmPolicy.c:21 +misra-c2012-5.7:Platform/OpenSsl/Source/SolidSyslogOpenSslAesGcmPolicy.c:19 +misra-c2012-5.7:Platform/OpenSsl/Source/SolidSyslogOpenSslHmacSha256Policy.c:19 +misra-c2012-5.7:Platform/OpenSsl/Source/SolidSyslogTlsStream.c:23 misra-c2012-5.7:Platform/Posix/Source/SolidSyslogGetAddrInfoResolver.c:20 misra-c2012-5.7:Platform/Posix/Source/SolidSyslogPosixDatagram.c:21 misra-c2012-5.7:Platform/Posix/Source/SolidSyslogPosixSleep.c:6 @@ -175,7 +175,7 @@ misra-c2012-5.7:Core/Source/SolidSyslogCrc16Policy.c:10 misra-c2012-5.7:Core/Source/SolidSyslogOriginSdPrivate.h:9 misra-c2012-5.7:Platform/FreeRtos/Source/SolidSyslogFreeRtosSysUpTime.c:7 misra-c2012-5.7:Platform/Posix/Source/SolidSyslogPosixHostname.c:10 -misra-c2012-5.7:Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c:21 +misra-c2012-5.7:Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c:23 misra-c2012-5.7:Platform/Posix/Source/SolidSyslogPosixMessageQueueBufferPrivate.h:12 misra-c2012-5.7:Platform/Posix/Source/SolidSyslogPosixSysUpTime.c:6 misra-c2012-5.7:Platform/Windows/Source/SolidSyslogWindowsClock.c:21 @@ -196,8 +196,8 @@ misra-c2012-8.9:Core/Source/SolidSyslogFileBlockDevice.c:16 # D.013 — Rule 11.5: void* ↔ unsigned char* at third-party byte-buffer API boundaries # See docs/misra-deviations.md#d013 -misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:308 -misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:327 +misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:315 +misra-c2012-11.5:Platform/MbedTls/Source/SolidSyslogMbedTlsStream.c:334 # D.014 — Rule 8.7: public-API SolidSyslogErrorSource objects with external linkage # See docs/misra-deviations.md#d014