Laan Tungir
c109c93382
- Complete C library template with OpenSSL-based crypto - Comprehensive build system (Makefile, build.sh) - Example code and test suite - Documentation and usage guides - Cross-platform compatibility (x64/ARM64) - Production-ready structure for C library projects
349 lines
12 KiB
C
349 lines
12 KiB
C
/*
|
|
* Makefile-Based Static Linking Test
|
|
*
|
|
* This test validates static linking configuration by parsing the Makefile
|
|
* instead of analyzing compiled binaries. This approach is faster, more reliable,
|
|
* and catches configuration issues at the source.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
// Test result tracking
|
|
static int tests_run = 0;
|
|
static int tests_passed = 0;
|
|
|
|
// Test macros
|
|
#define ASSERT(condition, message) \
|
|
do { \
|
|
tests_run++; \
|
|
if (condition) { \
|
|
printf("✓ %s: PASSED\n", message); \
|
|
tests_passed++; \
|
|
} else { \
|
|
printf("✗ %s: FAILED\n", message); \
|
|
} \
|
|
} while(0)
|
|
|
|
#define ASSERT_CONTAINS(haystack, needle, message) \
|
|
ASSERT(strstr(haystack, needle) != NULL, message)
|
|
|
|
#define ASSERT_NOT_CONTAINS(haystack, needle, message) \
|
|
ASSERT(strstr(haystack, needle) == NULL, message)
|
|
|
|
// File reading utility
|
|
char* read_file(const char* filename) {
|
|
FILE* file = fopen(filename, "r");
|
|
if (!file) {
|
|
printf("ERROR: Cannot open %s\n", filename);
|
|
return NULL;
|
|
}
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
long length = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
char* content = malloc(length + 1);
|
|
if (!content) {
|
|
fclose(file);
|
|
return NULL;
|
|
}
|
|
|
|
fread(content, 1, length, file);
|
|
content[length] = '\0';
|
|
fclose(file);
|
|
|
|
return content;
|
|
}
|
|
|
|
// Extract variable value from Makefile
|
|
char* extract_makefile_variable(const char* content, const char* variable) {
|
|
char search_pattern[256];
|
|
snprintf(search_pattern, sizeof(search_pattern), "%s =", variable);
|
|
|
|
char* line_start = strstr(content, search_pattern);
|
|
if (!line_start) {
|
|
snprintf(search_pattern, sizeof(search_pattern), "%s=", variable);
|
|
line_start = strstr(content, search_pattern);
|
|
}
|
|
|
|
if (!line_start) return NULL;
|
|
|
|
// Find start of value (after '=')
|
|
char* value_start = strchr(line_start, '=');
|
|
if (!value_start) return NULL;
|
|
value_start++; // Skip '='
|
|
|
|
// Skip whitespace
|
|
while (*value_start == ' ' || *value_start == '\t') {
|
|
value_start++;
|
|
}
|
|
|
|
// Find end of line
|
|
char* line_end = strchr(value_start, '\n');
|
|
if (!line_end) {
|
|
line_end = value_start + strlen(value_start);
|
|
}
|
|
|
|
// Handle line continuations with backslash
|
|
char* result = malloc(2048);
|
|
char* result_ptr = result;
|
|
char* current = value_start;
|
|
|
|
while (current < line_end) {
|
|
if (*current == '\\' && (current + 1) < line_end && *(current + 1) == '\n') {
|
|
// Line continuation - skip to next line
|
|
current += 2; // Skip '\\\n'
|
|
// Find next non-whitespace
|
|
while (current < line_end && (*current == ' ' || *current == '\t')) {
|
|
current++;
|
|
}
|
|
*result_ptr++ = ' '; // Add space between continued lines
|
|
} else {
|
|
*result_ptr++ = *current++;
|
|
}
|
|
}
|
|
*result_ptr = '\0';
|
|
|
|
// Trim trailing whitespace
|
|
result_ptr--;
|
|
while (result_ptr > result && (*result_ptr == ' ' || *result_ptr == '\t')) {
|
|
*result_ptr-- = '\0';
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Test static linking configuration
|
|
void test_static_linking_flags(const char* makefile_content) {
|
|
printf("\n=== Static Linking Flags Test ===\n");
|
|
|
|
// Check TEST_LDFLAGS contains -static
|
|
char* test_ldflags = extract_makefile_variable(makefile_content, "TEST_LDFLAGS");
|
|
if (test_ldflags) {
|
|
ASSERT_CONTAINS(test_ldflags, "-static", "TEST_LDFLAGS contains -static flag");
|
|
free(test_ldflags);
|
|
} else {
|
|
ASSERT(0, "TEST_LDFLAGS variable found in Makefile");
|
|
}
|
|
|
|
// Check ARM64_TEST_LDFLAGS contains -static
|
|
char* arm64_test_ldflags = extract_makefile_variable(makefile_content, "ARM64_TEST_LDFLAGS");
|
|
if (arm64_test_ldflags) {
|
|
ASSERT_CONTAINS(arm64_test_ldflags, "-static", "ARM64_TEST_LDFLAGS contains -static flag");
|
|
free(arm64_test_ldflags);
|
|
} else {
|
|
ASSERT(0, "ARM64_TEST_LDFLAGS variable found in Makefile");
|
|
}
|
|
}
|
|
|
|
// Test forbidden dynamic library links
|
|
void test_forbidden_dynamic_links(const char* makefile_content) {
|
|
printf("\n=== Forbidden Dynamic Links Test ===\n");
|
|
|
|
// List of libraries that should not be dynamically linked in core tests
|
|
const char* forbidden_libs[] = {
|
|
"-lsecp256k1", // Should be statically included
|
|
"-lsodium", // Not used
|
|
"-lwally", // Not used
|
|
"-lmbedtls", // Replaced with OpenSSL
|
|
"-lmbedx509", // Replaced with OpenSSL
|
|
"-lmbedcrypto", // Replaced with OpenSSL
|
|
NULL
|
|
};
|
|
|
|
for (int i = 0; forbidden_libs[i] != NULL; i++) {
|
|
// Check that forbidden library is not in TEST_LDFLAGS
|
|
char* test_ldflags = extract_makefile_variable(makefile_content, "TEST_LDFLAGS");
|
|
if (test_ldflags) {
|
|
char message[256];
|
|
snprintf(message, sizeof(message), "TEST_LDFLAGS does not contain %s", forbidden_libs[i]);
|
|
ASSERT_NOT_CONTAINS(test_ldflags, forbidden_libs[i], message);
|
|
free(test_ldflags);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that we use the static library
|
|
void test_static_library_usage(const char* makefile_content) {
|
|
printf("\n=== Static Library Usage Test ===\n");
|
|
|
|
// Check that TEST_LDFLAGS links against our static library
|
|
char* test_ldflags = extract_makefile_variable(makefile_content, "TEST_LDFLAGS");
|
|
if (test_ldflags) {
|
|
ASSERT_CONTAINS(test_ldflags, "-lnostr_core", "TEST_LDFLAGS links against libnostr_core");
|
|
ASSERT_CONTAINS(test_ldflags, "-lm", "TEST_LDFLAGS links against math library");
|
|
free(test_ldflags);
|
|
}
|
|
|
|
// Check ARM64 version
|
|
char* arm64_test_ldflags = extract_makefile_variable(makefile_content, "ARM64_TEST_LDFLAGS");
|
|
if (arm64_test_ldflags) {
|
|
ASSERT_CONTAINS(arm64_test_ldflags, "-lnostr_core_arm64", "ARM64_TEST_LDFLAGS links against ARM64 static library");
|
|
free(arm64_test_ldflags);
|
|
}
|
|
}
|
|
|
|
// Test that compilation flags disable problematic features for static tests only
|
|
void test_compilation_flags(const char* makefile_content) {
|
|
printf("\n=== Compilation Flags Test ===\n");
|
|
|
|
// Check TEST_CFLAGS contains DISABLE_NIP05 (static tests need to avoid curl)
|
|
char* test_cflags = extract_makefile_variable(makefile_content, "TEST_CFLAGS");
|
|
if (test_cflags) {
|
|
ASSERT_CONTAINS(test_cflags, "-DDISABLE_NIP05", "TEST_CFLAGS disables NIP-05 to avoid curl dependency");
|
|
free(test_cflags);
|
|
}
|
|
|
|
// Check that main compilation does NOT disable NIP05 (NIP-05 should be enabled by default)
|
|
// Look for DISABLE_NIP05 in object file compilation rules - should NOT be there
|
|
char* obj_rule_start = strstr(makefile_content, "%.o: %.c");
|
|
if (obj_rule_start) {
|
|
char* obj_rule_end = strstr(obj_rule_start, "\n\n");
|
|
if (!obj_rule_end) obj_rule_end = makefile_content + strlen(makefile_content);
|
|
|
|
char* obj_rule = malloc(obj_rule_end - obj_rule_start + 1);
|
|
strncpy(obj_rule, obj_rule_start, obj_rule_end - obj_rule_start);
|
|
obj_rule[obj_rule_end - obj_rule_start] = '\0';
|
|
|
|
ASSERT_NOT_CONTAINS(obj_rule, "-DDISABLE_NIP05", "Main compilation does not disable NIP-05");
|
|
free(obj_rule);
|
|
}
|
|
}
|
|
|
|
// Test static curl usage (no dynamic -lcurl)
|
|
void test_static_curl_usage(const char* makefile_content) {
|
|
printf("\n=== Static Curl Usage Test ===\n");
|
|
|
|
// Count occurrences of -lcurl (should be zero - we use static libcurl.a)
|
|
int curl_count = 0;
|
|
const char* search_pos = makefile_content;
|
|
while ((search_pos = strstr(search_pos, "-lcurl")) != NULL) {
|
|
curl_count++;
|
|
search_pos += 6; // Move past "-lcurl"
|
|
}
|
|
|
|
char message[256];
|
|
snprintf(message, sizeof(message), "No dynamic curl usage found (found %d -lcurl occurrences)", curl_count);
|
|
ASSERT(curl_count == 0, message);
|
|
|
|
// Verify HTTP and NIP-05 tests use static libcurl.a instead
|
|
ASSERT_CONTAINS(makefile_content, "./curl-install/lib/libcurl.a", "Static libcurl.a is used");
|
|
|
|
// Verify curl include path is used
|
|
ASSERT_CONTAINS(makefile_content, "-I./curl-install/include", "Curl include path is used");
|
|
|
|
// Verify both HTTP and NIP-05 tests use static linking
|
|
char* http_test_line = strstr(makefile_content, "$(HTTP_TEST_EXEC): tests/http_test.c");
|
|
if (http_test_line) {
|
|
char* next_rule = strstr(http_test_line, "\n\n");
|
|
if (!next_rule) next_rule = makefile_content + strlen(makefile_content);
|
|
|
|
char* http_section = malloc(next_rule - http_test_line + 1);
|
|
strncpy(http_section, http_test_line, next_rule - http_test_line);
|
|
http_section[next_rule - http_test_line] = '\0';
|
|
|
|
ASSERT_CONTAINS(http_section, "./curl-install/lib/libcurl.a", "HTTP test uses static libcurl.a");
|
|
ASSERT_CONTAINS(http_section, "-static", "HTTP test uses static linking");
|
|
|
|
free(http_section);
|
|
}
|
|
|
|
char* nip05_test_line = strstr(makefile_content, "$(NIP05_TEST_EXEC): tests/nip05_test.c");
|
|
if (nip05_test_line) {
|
|
char* next_rule = strstr(nip05_test_line, "\n\n");
|
|
if (!next_rule) next_rule = makefile_content + strlen(makefile_content);
|
|
|
|
char* nip05_section = malloc(next_rule - nip05_test_line + 1);
|
|
strncpy(nip05_section, nip05_test_line, next_rule - nip05_test_line);
|
|
nip05_section[next_rule - nip05_test_line] = '\0';
|
|
|
|
ASSERT_CONTAINS(nip05_section, "./curl-install/lib/libcurl.a", "NIP-05 test uses static libcurl.a");
|
|
ASSERT_CONTAINS(nip05_section, "-static", "NIP-05 test uses static linking");
|
|
|
|
free(nip05_section);
|
|
}
|
|
}
|
|
|
|
// Test that only one Makefile exists
|
|
void test_single_makefile_policy() {
|
|
printf("\n=== Single Makefile Policy Test ===\n");
|
|
|
|
// Check that subdirectory Makefiles don't exist or are minimal/deprecated
|
|
int makefile_violations = 0;
|
|
|
|
// Check tests/Makefile
|
|
if (access("tests/Makefile", F_OK) == 0) {
|
|
char* tests_makefile = read_file("tests/Makefile");
|
|
if (tests_makefile) {
|
|
// If tests/Makefile exists and contains actual build rules, it's a violation
|
|
if (strstr(tests_makefile, "LDFLAGS") || strstr(tests_makefile, "gcc")) {
|
|
makefile_violations++;
|
|
printf("WARNING: tests/Makefile contains build rules (should be consolidated)\n");
|
|
}
|
|
free(tests_makefile);
|
|
}
|
|
}
|
|
|
|
// Check nostr_websocket/Makefile
|
|
if (access("nostr_websocket/Makefile", F_OK) == 0) {
|
|
char* websocket_makefile = read_file("nostr_websocket/Makefile");
|
|
if (websocket_makefile) {
|
|
// If websocket Makefile exists and contains build rules, it's a violation
|
|
if (strstr(websocket_makefile, "LDFLAGS") || strstr(websocket_makefile, "gcc")) {
|
|
makefile_violations++;
|
|
printf("WARNING: nostr_websocket/Makefile contains build rules (should be consolidated)\n");
|
|
}
|
|
free(websocket_makefile);
|
|
}
|
|
}
|
|
|
|
char message[256];
|
|
snprintf(message, sizeof(message), "No Makefile policy violations found (found %d violations)", makefile_violations);
|
|
ASSERT(makefile_violations == 0, message);
|
|
}
|
|
|
|
int main() {
|
|
printf("Makefile-Based Static Linking Test\n");
|
|
printf("==================================\n");
|
|
printf("Testing static linking configuration by parsing Makefile...\n");
|
|
|
|
// Read the main Makefile
|
|
char* makefile_content = read_file("Makefile");
|
|
if (!makefile_content) {
|
|
printf("FATAL: Cannot read Makefile\n");
|
|
return 1;
|
|
}
|
|
|
|
// Run all tests
|
|
test_static_linking_flags(makefile_content);
|
|
test_forbidden_dynamic_links(makefile_content);
|
|
test_static_library_usage(makefile_content);
|
|
test_compilation_flags(makefile_content);
|
|
test_static_curl_usage(makefile_content);
|
|
test_single_makefile_policy();
|
|
|
|
free(makefile_content);
|
|
|
|
// Summary
|
|
printf("\n============================================\n");
|
|
printf("TEST SUMMARY\n");
|
|
printf("============================================\n");
|
|
printf("Tests run: %d\n", tests_run);
|
|
printf("Tests passed: %d\n", tests_passed);
|
|
|
|
if (tests_passed == tests_run) {
|
|
printf("ALL TESTS PASSED!\n");
|
|
printf("✅ Makefile static linking configuration is correct\n");
|
|
printf("✅ No forbidden dynamic dependencies\n");
|
|
printf("✅ Single Makefile policy enforced\n");
|
|
return 0;
|
|
} else {
|
|
printf("%d TESTS FAILED!\n", tests_run - tests_passed);
|
|
printf("❌ Makefile configuration needs fixes\n");
|
|
return 1;
|
|
}
|
|
}
|