@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/examples/systems/ipc-pipes.c

@@ -0,0 +1,181 @@
+/**
+ * @file ipc-pipes.c
+ * @brief Example demonstrating inter-process communication using pipes
+ * 
+ * This example shows:
+ * - Creating pipes for IPC
+ * - Bidirectional communication between parent and child
+ * - Proper file descriptor management
+ * - Error handling for pipe operations
+ * - Resource cleanup
+ * 
+ * Compile: gcc -Wall -Wextra -std=c11 -o ipc-pipes ipc-pipes.c
+ * Run: ./ipc-pipes
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+#define BUFFER_SIZE 256
+#define MESSAGE_COUNT 5
+
+/**
+ * @brief Simple pipe communication example
+ * @return 0 on success, -1 on error
+ */
+int simple_pipe_example(void) {
+    int pipefd[2];
+    pid_t pid;
+    char buffer[BUFFER_SIZE];
+
+    // Create pipe
+    if (pipe(pipefd) < 0) {
+        perror("pipe");
+        return -1;
+    }
+
+    pid = fork();
+    if (pid < 0) {
+        perror("fork");
+        close(pipefd[0]);
+        close(pipefd[1]);
+        return -1;
+    }
+
+    if (pid == 0) {
+        // Child process: write to pipe
+        close(pipefd[0]);  // Close read end
+
+        const char *message = "Hello from child process!";
+        ssize_t written = write(pipefd[1], message, strlen(message) + 1);
+        if (written < 0) {
+            perror("write");
+            close(pipefd[1]);
+            exit(EXIT_FAILURE);
+        }
+
+        close(pipefd[1]);
+        exit(EXIT_SUCCESS);
+    } else {
+        // Parent process: read from pipe
+        close(pipefd[1]);  // Close write end
+
+        ssize_t bytes_read = read(pipefd[0], buffer, sizeof(buffer) - 1);
+        if (bytes_read < 0) {
+            perror("read");
+            close(pipefd[0]);
+            return -1;
+        }
+
+        buffer[bytes_read] = '\0';
+        printf("Parent received: %s\n", buffer);
+
+        close(pipefd[0]);
+        wait(NULL);  // Wait for child to finish
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Bidirectional pipe communication example
+ * @return 0 on success, -1 on error
+ */
+int bidirectional_pipe_example(void) {
+    int parent_to_child[2];  // Parent writes, child reads
+    int child_to_parent[2];  // Child writes, parent reads
+    pid_t pid;
+    char buffer[BUFFER_SIZE];
+
+    // Create both pipes
+    if (pipe(parent_to_child) < 0) {
+        perror("pipe (parent_to_child)");
+        return -1;
+    }
+
+    if (pipe(child_to_parent) < 0) {
+        perror("pipe (child_to_parent)");
+        close(parent_to_child[0]);
+        close(parent_to_child[1]);
+        return -1;
+    }
+
+    pid = fork();
+    if (pid < 0) {
+        perror("fork");
+        close(parent_to_child[0]);
+        close(parent_to_child[1]);
+        close(child_to_parent[0]);
+        close(child_to_parent[1]);
+        return -1;
+    }
+
+    if (pid == 0) {
+        // Child process
+        close(parent_to_child[1]);  // Close write end of parent->child
+        close(child_to_parent[0]);  // Close read end of child->parent
+
+        // Read from parent
+        ssize_t bytes_read = read(parent_to_child[0], buffer, sizeof(buffer) - 1);
+        if (bytes_read > 0) {
+            buffer[bytes_read] = '\0';
+            printf("Child received: %s\n", buffer);
+
+            // Send response to parent
+            const char *response = "ACK from child";
+            write(child_to_parent[1], response, strlen(response) + 1);
+        }
+
+        close(parent_to_child[0]);
+        close(child_to_parent[1]);
+        exit(EXIT_SUCCESS);
+    } else {
+        // Parent process
+        close(parent_to_child[0]);  // Close read end of parent->child
+        close(child_to_parent[1]);  // Close write end of child->parent
+
+        // Send message to child
+        const char *message = "Hello from parent";
+        write(parent_to_child[1], message, strlen(message) + 1);
+        close(parent_to_child[1]);
+
+        // Read response from child
+        ssize_t bytes_read = read(child_to_parent[0], buffer, sizeof(buffer) - 1);
+        if (bytes_read > 0) {
+            buffer[bytes_read] = '\0';
+            printf("Parent received: %s\n", buffer);
+        }
+
+        close(child_to_parent[0]);
+        wait(NULL);
+    }
+
+    return 0;
+}
+
+int main(void) {
+    printf("=== IPC Pipes Example ===\n\n");
+
+    printf("Example 1: Simple one-way pipe\n");
+    if (simple_pipe_example() < 0) {
+        fprintf(stderr, "Simple pipe example failed\n");
+        return EXIT_FAILURE;
+    }
+    printf("\n");
+
+    printf("Example 2: Bidirectional pipe communication\n");
+    if (bidirectional_pipe_example() < 0) {
+        fprintf(stderr, "Bidirectional pipe example failed\n");
+        return EXIT_FAILURE;
+    }
+    printf("\n");
+
+    printf("All IPC examples completed successfully\n");
+    return EXIT_SUCCESS;
+}
+

package/augment-extensions/coding-standards/c/examples/systems/process-management.c

@@ -0,0 +1,153 @@
+/**
+ * @file process-management.c
+ * @brief Example demonstrating POSIX process management with fork/exec/wait
+ * 
+ * This example shows:
+ * - Proper fork() usage with error checking
+ * - Process creation and management
+ * - Parent-child process coordination
+ * - Exit status handling
+ * - Resource cleanup
+ * 
+ * Compile: gcc -Wall -Wextra -std=c11 -o process-management process-management.c
+ * Run: ./process-management
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+/**
+ * @brief Spawn a child process to execute a command
+ * @param command Command to execute
+ * @param args Arguments for the command (NULL-terminated)
+ * @return 0 on success, -1 on error
+ */
+int spawn_process(const char *command, char *const args[]) {
+    if (command == NULL || args == NULL) {
+        fprintf(stderr, "Error: NULL command or args\n");
+        return -1;
+    }
+
+    pid_t pid = fork();
+    
+    if (pid < 0) {
+        // Fork failed
+        perror("fork");
+        return -1;
+    } else if (pid == 0) {
+        // Child process
+        execvp(command, args);
+        // If execvp returns, it failed
+        perror("execvp");
+        exit(EXIT_FAILURE);
+    } else {
+        // Parent process
+        int status;
+        pid_t result = waitpid(pid, &status, 0);
+        
+        if (result < 0) {
+            perror("waitpid");
+            return -1;
+        }
+        
+        if (WIFEXITED(status)) {
+            int exit_code = WEXITSTATUS(status);
+            printf("Child process %d exited with status %d\n", pid, exit_code);
+            return exit_code == 0 ? 0 : -1;
+        } else if (WIFSIGNALED(status)) {
+            int signal = WTERMSIG(status);
+            fprintf(stderr, "Child process %d terminated by signal %d\n", pid, signal);
+            return -1;
+        }
+    }
+    
+    return 0;
+}
+
+/**
+ * @brief Create multiple child processes and wait for all
+ * @param count Number of child processes to create
+ * @return 0 on success, -1 on error
+ */
+int spawn_multiple_processes(int count) {
+    if (count <= 0 || count > 100) {
+        fprintf(stderr, "Error: Invalid process count %d\n", count);
+        return -1;
+    }
+
+    pid_t *children = malloc(count * sizeof(pid_t));
+    if (children == NULL) {
+        perror("malloc");
+        return -1;
+    }
+
+    // Create child processes
+    for (int i = 0; i < count; i++) {
+        pid_t pid = fork();
+        
+        if (pid < 0) {
+            perror("fork");
+            // Clean up already created processes
+            for (int j = 0; j < i; j++) {
+                kill(children[j], SIGTERM);
+            }
+            free(children);
+            return -1;
+        } else if (pid == 0) {
+            // Child process
+            printf("Child %d (PID %d) running\n", i, getpid());
+            sleep(1);  // Simulate work
+            exit(EXIT_SUCCESS);
+        } else {
+            // Parent process
+            children[i] = pid;
+        }
+    }
+
+    // Wait for all children
+    int failed = 0;
+    for (int i = 0; i < count; i++) {
+        int status;
+        pid_t result = waitpid(children[i], &status, 0);
+        
+        if (result < 0) {
+            perror("waitpid");
+            failed++;
+        } else if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+            fprintf(stderr, "Child %d failed\n", children[i]);
+            failed++;
+        }
+    }
+
+    free(children);
+    return failed == 0 ? 0 : -1;
+}
+
+int main(void) {
+    printf("=== Process Management Example ===\n\n");
+
+    // Example 1: Simple process execution
+    printf("Example 1: Execute 'ls -l' command\n");
+    char *args[] = {"ls", "-l", NULL};
+    if (spawn_process("ls", args) < 0) {
+        fprintf(stderr, "Failed to execute ls command\n");
+    }
+    printf("\n");
+
+    // Example 2: Multiple child processes
+    printf("Example 2: Create 3 child processes\n");
+    if (spawn_multiple_processes(3) < 0) {
+        fprintf(stderr, "Failed to create multiple processes\n");
+        return EXIT_FAILURE;
+    }
+    printf("\n");
+
+    printf("All examples completed successfully\n");
+    return EXIT_SUCCESS;
+}
+

package/augment-extensions/coding-standards/c/examples/systems/signal-handling.c

@@ -0,0 +1,162 @@
+/**
+ * @file signal-handling.c
+ * @brief Example demonstrating POSIX signal handling
+ * 
+ * This example shows:
+ * - Registering signal handlers with sigaction()
+ * - Handling common signals (SIGINT, SIGTERM, SIGUSR1)
+ * - Async-signal-safe operations
+ * - Graceful shutdown
+ * - Signal masking
+ * 
+ * Compile: gcc -Wall -Wextra -std=c11 -o signal-handling signal-handling.c
+ * Run: ./signal-handling (Press Ctrl+C to test SIGINT)
+ */
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+// Global flag for graceful shutdown (volatile sig_atomic_t is async-signal-safe)
+static volatile sig_atomic_t shutdown_requested = 0;
+static volatile sig_atomic_t usr1_count = 0;
+
+/**
+ * @brief Signal handler for SIGINT and SIGTERM
+ * @param signum Signal number
+ */
+void shutdown_handler(int signum) {
+    // Only async-signal-safe operations allowed here
+    shutdown_requested = 1;
+    
+    // write() is async-signal-safe, printf() is not
+    const char *msg = (signum == SIGINT) ? 
+        "Received SIGINT, shutting down...\n" :
+        "Received SIGTERM, shutting down...\n";
+    write(STDOUT_FILENO, msg, strlen(msg));
+}
+
+/**
+ * @brief Signal handler for SIGUSR1
+ * @param signum Signal number
+ */
+void usr1_handler(int signum) {
+    (void)signum;  // Unused parameter
+    usr1_count++;
+    
+    const char *msg = "Received SIGUSR1\n";
+    write(STDOUT_FILENO, msg, strlen(msg));
+}
+
+/**
+ * @brief Install signal handlers using sigaction()
+ * @return 0 on success, -1 on error
+ */
+int install_signal_handlers(void) {
+    struct sigaction sa_shutdown;
+    struct sigaction sa_usr1;
+
+    // Setup shutdown handler (SIGINT, SIGTERM)
+    memset(&sa_shutdown, 0, sizeof(sa_shutdown));
+    sa_shutdown.sa_handler = shutdown_handler;
+    sigemptyset(&sa_shutdown.sa_mask);
+    sa_shutdown.sa_flags = SA_RESTART;  // Restart interrupted system calls
+
+    if (sigaction(SIGINT, &sa_shutdown, NULL) < 0) {
+        perror("sigaction(SIGINT)");
+        return -1;
+    }
+
+    if (sigaction(SIGTERM, &sa_shutdown, NULL) < 0) {
+        perror("sigaction(SIGTERM)");
+        return -1;
+    }
+
+    // Setup SIGUSR1 handler
+    memset(&sa_usr1, 0, sizeof(sa_usr1));
+    sa_usr1.sa_handler = usr1_handler;
+    sigemptyset(&sa_usr1.sa_mask);
+    sa_usr1.sa_flags = SA_RESTART;
+
+    if (sigaction(SIGUSR1, &sa_usr1, NULL) < 0) {
+        perror("sigaction(SIGUSR1)");
+        return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Example of signal masking
+ * @return 0 on success, -1 on error
+ */
+int signal_masking_example(void) {
+    sigset_t mask, oldmask;
+
+    printf("Blocking SIGUSR1 for 3 seconds...\n");
+
+    // Block SIGUSR1
+    sigemptyset(&mask);
+    sigaddset(&mask, SIGUSR1);
+    
+    if (sigprocmask(SIG_BLOCK, &mask, &oldmask) < 0) {
+        perror("sigprocmask(SIG_BLOCK)");
+        return -1;
+    }
+
+    printf("SIGUSR1 is now blocked. Send signal with: kill -USR1 %d\n", getpid());
+    sleep(3);
+
+    // Unblock SIGUSR1
+    printf("Unblocking SIGUSR1...\n");
+    if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0) {
+        perror("sigprocmask(SIG_SETMASK)");
+        return -1;
+    }
+
+    printf("SIGUSR1 is now unblocked\n");
+    return 0;
+}
+
+/**
+ * @brief Main application loop
+ */
+void run_application(void) {
+    printf("Application running (PID: %d)\n", getpid());
+    printf("Press Ctrl+C to trigger SIGINT\n");
+    printf("Send SIGUSR1 with: kill -USR1 %d\n", getpid());
+    printf("Send SIGTERM with: kill -TERM %d\n\n", getpid());
+
+    // Demonstrate signal masking
+    signal_masking_example();
+
+    // Main loop
+    int iteration = 0;
+    while (!shutdown_requested) {
+        printf("Working... (iteration %d, SIGUSR1 count: %d)\n", 
+               iteration++, (int)usr1_count);
+        sleep(2);
+    }
+
+    printf("\nShutdown complete. Total SIGUSR1 signals: %d\n", (int)usr1_count);
+}
+
+int main(void) {
+    printf("=== Signal Handling Example ===\n\n");
+
+    // Install signal handlers
+    if (install_signal_handlers() < 0) {
+        fprintf(stderr, "Failed to install signal handlers\n");
+        return EXIT_FAILURE;
+    }
+
+    // Run application
+    run_application();
+
+    printf("Application terminated gracefully\n");
+    return EXIT_SUCCESS;
+}
+

package/augment-extensions/coding-standards/c/module.json

@@ -0,0 +1,149 @@
+{
+  "name": "c-standards",
+  "version": "1.0.0",
+  "displayName": "C Coding Standards",
+  "description": "Comprehensive C programming language coding standards for systems programming, embedded systems, kernel development, device drivers, real-time systems, networking, and legacy code maintenance",
+  "type": "coding-standards",
+  "language": "c",
+  "author": "Augment Extensions",
+  "license": "MIT",
+  "repository": "https://github.com/mytech-today-now/augment-extensions",
+  "keywords": [
+    "c",
+    "coding-standards",
+    "systems-programming",
+    "embedded",
+    "kernel",
+    "drivers",
+    "real-time",
+    "networking",
+    "legacy"
+  ],
+  "tags": [
+    "c",
+    "systems",
+    "embedded",
+    "kernel",
+    "drivers",
+    "realtime",
+    "networking",
+    "legacy"
+  ],
+  "dependencies": {},
+  "optionalDependencies": {
+    "clang-tidy": ">=14.0.0",
+    "cppcheck": ">=2.0.0",
+    "valgrind": ">=3.18.0"
+  },
+  "augment": {
+    "minVersion": "1.0.0",
+    "characterCount": 0,
+    "priority": "high",
+    "category": "coding-standards",
+    "autoLoad": false,
+    "appliesTo": {
+      "filePatterns": [
+        "**/*.c",
+        "**/*.h"
+      ],
+      "projectTypes": [
+        "systems",
+        "embedded",
+        "kernel",
+        "drivers",
+        "realtime",
+        "networking",
+        "legacy"
+      ]
+    }
+  },
+  "categories": {
+    "systems": {
+      "description": "Systems programming (POSIX, IPC, processes, signals)",
+      "rules": ["categories/systems.md"],
+      "examples": ["examples/systems/"]
+    },
+    "embedded": {
+      "description": "Embedded systems (microcontrollers, ISRs, hardware registers)",
+      "rules": ["categories/embedded.md"],
+      "examples": ["examples/embedded/"]
+    },
+    "kernel": {
+      "description": "Linux kernel development (modules, drivers, subsystems)",
+      "rules": ["categories/kernel.md"],
+      "examples": ["examples/kernel/"]
+    },
+    "drivers": {
+      "description": "Device drivers (character, block, network devices)",
+      "rules": ["categories/drivers.md"],
+      "examples": ["examples/drivers/"]
+    },
+    "realtime": {
+      "description": "Real-time systems (RTOS, scheduling, determinism)",
+      "rules": ["categories/realtime.md"],
+      "examples": ["examples/realtime/"]
+    },
+    "networking": {
+      "description": "Network programming (sockets, protocols, packet processing)",
+      "rules": ["categories/networking.md"],
+      "examples": ["examples/networking/"]
+    },
+    "legacy": {
+      "description": "Legacy code maintenance and modernization",
+      "rules": ["categories/legacy.md"],
+      "examples": ["examples/legacy/"]
+    }
+  },
+  "universalRules": [
+    "universal/naming.md",
+    "universal/memory-safety.md",
+    "universal/error-handling.md",
+    "universal/documentation.md",
+    "universal/header-guards.md",
+    "universal/const-correctness.md"
+  ],
+  "features": {
+    "configuration": true,
+    "ruleRegistry": true,
+    "promptGeneration": true,
+    "staticAnalysis": true,
+    "customRules": true,
+    "hotReload": true
+  },
+  "installation": {
+    "required": false,
+    "steps": [
+      "Link module using: augx link coding-standards/c",
+      "Or manually copy contents to project's .augment/ folder",
+      "Configure categories in .augment/c-standards.json"
+    ]
+  },
+  "configuration": {
+    "schema": "config/schema.json",
+    "defaults": "config/defaults.json",
+    "examples": [
+      "config/examples/systems.json",
+      "config/examples/embedded.yaml"
+    ]
+  },
+  "contents": [
+    "module.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    ".gitignore",
+    "src/",
+    "rules/",
+    "examples/",
+    "templates/",
+    "config/",
+    "tests/",
+    "docs/"
+  ],
+  "links": {
+    "homepage": "https://github.com/mytech-today-now/augment-extensions",
+    "documentation": "https://github.com/mytech-today-now/augment-extensions/tree/main/augment-extensions/coding-standards/c",
+    "issues": "https://github.com/mytech-today-now/augment-extensions/issues"
+  }
+}
+