#define _POSIX_C_SOURCE 199309L
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>

/*
 * SA_SIGINFO handler prototype — three arguments:
 *   sig:      signal number
 *   info:     pointer to siginfo_t with details
 *   ucontext: saved CPU context (rarely used — cast to ucontext_t *)
 */
static void info_handler(int sig, siginfo_t *info, void *ucontext)
{
    /* UNSAFE: printf used for demonstration only */
    printf("\n=== Signal Received ===\n");
    printf("  Signal number : %d\n", info->si_signo);
    printf("  si_code       : %d ", info->si_code);

    switch (info->si_code) {
        case SI_USER:   printf("(SI_USER — sent by user process via kill/raise)\n"); break;
        case SI_KERNEL: printf("(SI_KERNEL — sent by kernel)\n"); break;
        case SI_QUEUE:  printf("(SI_QUEUE — sent via sigqueue)\n"); break;
        default:        printf("(other)\n"); break;
    }

    /* si_pid and si_uid only valid when signal sent by a process */
    if (info->si_code == SI_USER || info->si_code == SI_QUEUE) {
        printf("  Sender PID    : %d\n", (int)info->si_pid);
        printf("  Sender UID    : %d\n", (int)info->si_uid);
    }
    printf("========================\n");
}

int main(void)
{
    struct sigaction sa;
    sa.sa_sigaction = info_handler;   /* Must use sa_sigaction (not sa_handler) */
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO;         /* Enable the 3-argument handler */

    sigaction(SIGUSR1, &sa, NULL);
    sigaction(SIGUSR2, &sa, NULL);
    sigaction(SIGINT,  &sa, NULL);

    printf("PID = %d\n", (int)getpid());
    printf("Send signals: kill -USR1 %d  or  kill -USR2 %d\n",
           (int)getpid(), (int)getpid());
    printf("Press Ctrl+C to trigger SIGINT from terminal.\n\n");

    /* Wait for 5 signals */
    int count = 0;
    while (count < 5) {
        pause();
        count++;
    }
    printf("Done.\n");
    return 0;
}

#define _POSIX_C_SOURCE 199309L
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

static char altstack_buf[SIGSTKSZ];

static void sigsegv_handler(int sig, siginfo_t *info, void *ucontext)
{
    /*
     * si_addr is set for hardware-generated SIGSEGV and SIGBUS.
     * It contains the memory address that caused the fault.
     */

    /* Use write() — async-signal-safe */
    char buf[256];
    int len = snprintf(buf, sizeof(buf),   /* snprintf is NOT safe but used here for demo */
        "\n[SIGSEGV] Fault at address: %p\n"
        "  si_code: %d (%s)\n",
        info->si_addr,
        info->si_code,
        (info->si_code == SEGV_MAPERR) ? "SEGV_MAPERR (unmapped address)" :
        (info->si_code == SEGV_ACCERR) ? "SEGV_ACCERR (bad permissions)"  :
                                          "other");
    write(STDERR_FILENO, buf, len);

    /* Terminate — cannot return from SIGSEGV (would re-trigger) */
    _exit(EXIT_FAILURE);
}

int main(void)
{
    /* Need alternate stack since SIGSEGV may occur on stack overflow */
    stack_t ss = {
        .ss_sp    = altstack_buf,
        .ss_size  = sizeof(altstack_buf),
        .ss_flags = 0
    };
    sigaltstack(&ss, NULL);

    struct sigaction sa;
    sa.sa_sigaction = sigsegv_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO | SA_ONSTACK;  /* Both flags together */
    sigaction(SIGSEGV, &sa, NULL);

    printf("[Main] About to dereference NULL pointer...\n");
    fflush(stdout);

    /* Trigger SIGSEGV intentionally */
    volatile int *bad = (int *)0x12345678;
    *bad = 42;

    return 0;  /* Never reached */
}

#define _POSIX_C_SOURCE 199309L
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>

static void sigchld_handler(int sig, siginfo_t *info, void *ucontext)
{
    /* UNSAFE: printf for demo only */
    printf("\n[SIGCHLD Handler]\n");
    printf("  Child PID    : %d\n",   (int)info->si_pid);
    printf("  Child UID    : %d\n",   (int)info->si_uid);

    switch (info->si_code) {
        case CLD_EXITED:
            printf("  Event        : Exited normally\n");
            printf("  Exit status  : %d\n", info->si_status);
            break;
        case CLD_KILLED:
            printf("  Event        : Killed by signal %d\n", info->si_status);
            break;
        case CLD_DUMPED:
            printf("  Event        : Killed with core dump\n");
            break;
        case CLD_STOPPED:
            printf("  Event        : Stopped by signal %d\n", info->si_status);
            break;
        case CLD_CONTINUED:
            printf("  Event        : Continued\n");
            break;
        default:
            printf("  Event        : Unknown si_code %d\n", info->si_code);
    }
    printf("  User CPU time : %ld clock ticks\n", (long)info->si_utime);
    printf("  Sys CPU time  : %ld clock ticks\n", (long)info->si_stime);

    /* Still need to call waitpid to reap the zombie */
    int status;
    waitpid(info->si_pid, &status, WNOHANG);
}

int main(void)
{
    struct sigaction sa;
    sa.sa_sigaction = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO | SA_RESTART;
    sigaction(SIGCHLD, &sa, NULL);

    /* Fork 3 children with different exit behaviours */
    for (int i = 0; i < 3; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            /* Child */
            switch (i) {
                case 0: sleep(1); printf("[Child %d] Exiting with status 42\n", i); _exit(42); break;
                case 1: sleep(2); printf("[Child %d] Exiting with status 0\n",  i); _exit(0);  break;
                case 2: sleep(3); printf("[Child %d] Killing self with SIGTERM\n",i); raise(SIGTERM); break;
            }
        }
    }

    /* Parent waits for all 3 children to exit */
    printf("[Parent] Waiting for children...\n");
    sleep(5);
    printf("[Parent] Done.\n");
    return 0;
}