IPC — Inter-Process Communication

child got: ping
parent done

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void) {
    int p2c[2];   /* parent-to-child pipe */
    int c2p[2];   /* child-to-parent pipe */

    if (pipe(p2c) == -1 || pipe(c2p) == -1) {
        perror("pipe"); return 1;
    }

    pid_t pid = fork();
    if (pid == -1) { perror("fork"); return 1; }

    if (pid == 0) {
        /* ── CHILD ── */
        close(p2c[1]);   /* won't write to parent-to-child */
        close(c2p[0]);   /* won't read from child-to-parent */

        int val;
        read(p2c[0], &val, sizeof(int));   /* receive number from parent */
        close(p2c[0]);

        val *= 2;   /* double it */

        write(c2p[1], &val, sizeof(int));  /* send back */
        close(c2p[1]);
        exit(0);

    } else {
        /* ── PARENT ── */
        close(p2c[0]);   /* won't read from parent-to-child */
        close(c2p[1]);   /* won't write to child-to-parent */

        int send_val = 21;
        write(p2c[1], &send_val, sizeof(int));
        close(p2c[1]);   /* signal child we're done sending */

        int recv_val;
        read(c2p[0], &recv_val, sizeof(int));
        close(c2p[0]);

        printf("Sent: %d, Received: %d\n", send_val, recv_val);
        waitpid(pid, NULL, 0);
    }

    return 0;
}

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void) {
    int fds[2];
    pipe(fds);

    if (fork() == 0) {
        /* child — FIX: close the write end before reading */
        close(fds[1]);          /* ← THIS WAS MISSING */
        char buf[16];
        ssize_t n = read(fds[0], buf, 15);
        buf[n] = '\0';
        printf("child: %s\n", buf);
        close(fds[0]);
        _exit(0);
    }

    /* parent */
    close(fds[0]);   /* also good practice: close read end in parent */
    write(fds[1], "hello", 5);
    close(fds[1]);
    wait(NULL);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void) {
    int fds[2];
    if (pipe(fds) == -1) { perror("pipe"); return 1; }

    pid_t pid = fork();
    if (pid == -1) { perror("fork"); return 1; }

    if (pid == 0) {
        /* ── CHILD: wire stdin to pipe read end, then exec cat ── */
        close(fds[1]);           /* child won't write */

        /* dup2: make fd 0 (stdin) point to fds[0] (pipe read end) */
        if (dup2(fds[0], 0) == -1) { perror("dup2"); exit(1); }
        close(fds[0]);           /* original fd no longer needed */

        /* Now fd 0 (stdin) is the pipe read end.
           cat reads from stdin, which is now our pipe. */
        execlp("cat", "cat", NULL);
        perror("execlp");   /* only reached if exec fails */
        exit(1);

    } else {
        /* ── PARENT: write data into pipe, then close write end ── */
        close(fds[0]);           /* parent won't read */

        const char *data = "hello world\n";
        write(fds[1], data, strlen(data));
        close(fds[1]);           /* close sends EOF to cat's stdin */

        waitpid(pid, NULL, 0);
    }

    return 0;
}

/* Creating and using a FIFO */

/* Step 1: create (one-time setup, e.g. at startup or via shell) */
mkfifo("/tmp/myfifo", 0666);

/* Step 2: writer process (any process that knows the path) */
int wfd = open("/tmp/myfifo", O_WRONLY);   /* blocks until reader opens */
write(wfd, "data", 4);
close(wfd);

/* Step 3: reader process (any process that knows the path) */
int rfd = open("/tmp/myfifo", O_RDONLY);   /* blocks until writer opens */
char buf[16];
read(rfd, buf, 16);
close(rfd);

/* Cleanup */
unlink("/tmp/myfifo");   /* remove from filesystem */

/* ===== PART 1: same_direction ===== */
int same_direction(struct duck *d1, struct duck *d2) {
    /* Returns 0 if either velocity is zero */
    if (d1->velocity[0] == 0.0f || d2->velocity[0] == 0.0f)
        return 0;
    /* Both positive or both negative → same direction → positive result */
    /* One positive one negative → negative result */
    if ((d1->velocity[0] > 0.0f && d2->velocity[0] > 0.0f) ||
        (d1->velocity[0] < 0.0f && d2->velocity[0] < 0.0f))
        return 1;
    return -1;
}

/* ===== PARTS 2–5: update_position ===== */

/* Helper: returns 1 if two ducks are within radius 2.5 of each other */
static int ducks_clash(struct duck *a, struct duck *b) {
    float diff = a->position[0] - b->position[0];
    if (diff < 0.0f) diff = -diff;
    return diff < 2.5f;
}

void update_position(struct duck **ducks, int n, int max,
                     float timestep, int *died) {
    *died = 0;

    /* ===== PART 2: Update positions (p' = p + v*dt, resolve clashes) ===== */
    for (int i = 0; i < max; i++) {
        if (ducks[i] == NULL) continue;

        struct duck *curr = ducks[i];
        float new_pos = curr->position[0] + curr->velocity[0] * timestep;
        int k = 0;

        /* Keep stepping forward by velocity until no clash */
        int clash = 1;
        while (clash) {
            clash = 0;
            for (int j = 0; j < max; j++) {
                if (j == i || ducks[j] == NULL) continue;
                /* Temporarily check if new_pos clashes with ducks[j] */
                float diff = new_pos - ducks[j]->position[0];
                if (diff < 0.0f) diff = -diff;
                if (diff < 2.5f) {
                    clash = 1;
                    k++;
                    new_pos = curr->position[0]
                              + curr->velocity[0] * timestep
                              + curr->velocity[0] * k;
                    break;
                }
            }
        }
        curr->position[0] = new_pos;
    }

    /* ===== PART 3: Overtaking ===== */
    /* Repeat until no overtakes remain (re-scan on any overtake) */
    int overtook = 1;
    while (overtook) {
        overtook = 0;
        for (int i = 0; i < max; i++) {
            if (ducks[i] == NULL) continue;
            struct duck *curr = ducks[i];
            struct duck *front = curr->duck_in_front;
            if (front == NULL) continue;

            /* Overtake condition: same direction AND curr is further than front */
            if (same_direction(curr, front) > 0) {
                int curr_overtook = 0;
                if (curr->velocity[0] > 0.0f) {
                    /* Positive direction: higher position = further */
                    curr_overtook = (curr->position[0] > front->position[0]);
                } else {
                    /* Negative direction: lower position = further */
                    curr_overtook = (curr->position[0] < front->position[0]);
                }
                if (curr_overtook) {
                    struct duck *front_in_front = front->duck_in_front;
                    /* Swap: front's duck_in_front becomes curr */
                    front->duck_in_front = curr;
                    /* curr takes front's old front */
                    curr->duck_in_front = front_in_front;
                    /* Update quack functions */
                    curr->quack = angry_quack;
                    front->quack = sad_quack;
                    overtook = 1;
                    /* Assumption: restart the scan to catch cascading overtakes */
                    break;
                }
            }
        }
    }

    /* ===== PART 4: Flying separate ways ===== */
    for (int i = 0; i < max; i++) {
        if (ducks[i] == NULL) continue;
        struct duck *curr = ducks[i];
        struct duck *front = curr->duck_in_front;
        if (front == NULL) continue;

        /* If NOT same direction (includes one velocity = 0) */
        if (same_direction(curr, front) <= 0) {
            curr->duck_in_front = NULL;
            front->quack = sad_quack;
        }
    }

    /* ===== PART 5: Dead ducks ===== */
    /* Mark initially dead ducks (|velocity| < 0.005) */
    int changed = 1;
    while (changed) {
        changed = 0;
        for (int i = 0; i < max; i++) {
            if (ducks[i] == NULL) continue;
            struct duck *curr = ducks[i];

            /* Primary death condition */
            int should_die = 0;
            float v = curr->velocity[0];
            if (v < 0.0f) v = -v;
            if (v < 0.005f) should_die = 1;

            /* Cascade: sad_quack duck whose duck_in_front is dead (NULL after free) */
            /* We track dead ducks by checking if duck_in_front points to a freed slot.
               To detect this, we check if duck_in_front is non-NULL but not in the array */
            if (!should_die && curr->quack == sad_quack
                && curr->duck_in_front != NULL) {
                /* Check if duck_in_front is a dead duck (not in the array anymore) */
                int found = 0;
                for (int j = 0; j < max; j++) {
                    if (ducks[j] == curr->duck_in_front) { found = 1; break; }
                }
                if (!found) should_die = 1;
            }

            if (should_die) {
                free(curr);
                ducks[i] = NULL;
                (*died)++;
                changed = 1;
            }
        }
    }

    /* Fix up: living ducks with references to dead ducks → set duck_in_front to NULL */
    for (int i = 0; i < max; i++) {
        if (ducks[i] == NULL) continue;
        struct duck *curr = ducks[i];
        if (curr->duck_in_front == NULL) continue;
        int found = 0;
        for (int j = 0; j < max; j++) {
            if (ducks[j] == curr->duck_in_front) { found = 1; break; }
        }
        if (!found) curr->duck_in_front = NULL;
    }

    /* Set quack function based on deaths */
    quack_f final_quack = (*died == 0) ? happy_quack : neutral_quack;
    for (int i = 0; i < max; i++) {
        if (ducks[i] != NULL)
            ducks[i]->quack = final_quack;
    }
}

/*
 * DESIGN OVERVIEW
 * ===============
 * Linear chain: P0 → P1 → P2 → ... → Pn-1
 * Each adjacent pair Pi and Pi+1 shares TWO pipes:
 *   up_pipe[i]   : Pi+1 writes → Pi reads   (child-to-parent direction)
 *   down_pipe[i] : Pi writes → Pi+1 reads   (parent-to-child direction)
 *
 * For n processes there are (n-1) adjacent pairs → 2*(n-1) pipes total.
 *
 * MESSAGE PACKET FORMAT (fixed 56-byte struct):
 *   int  src;        // originating process index
 *   int  dest;       // destination process index
 *   char msg[50];    // message payload
 *   int  hop_dir;    // +1 = travelling toward higher index, -1 = toward lower
 *
 * ROUTING: Each process Pi, upon receiving a packet:
 *   - If dest == i: consume it (call user handler).
 *   - If dest > i:  forward down (to Pi+1) if a down pipe exists.
 *   - If dest < i:  forward up   (to Pi-1) if an up pipe exists.
 *   - Never forward back to the pipe it arrived from (prevents cycles).
 *
 * Each process only ever forwards a packet once (it came from one direction
 * → it goes in the other direction). The packet converges in O(n) hops.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

#define MAX_N 64

/* Pipe file descriptors — each row is one pipe: [0]=read, [1]=write */
static int down_pipe[MAX_N][2];  /* down_pipe[i]: P_i → P_{i+1} */
static int up_pipe[MAX_N][2];    /* up_pipe[i]:   P_{i+1} → P_i  */

static int my_index;   /* this process's index */
static int n_procs;    /* total number of processes */

/* Message packet */
typedef struct {
    int  src;
    int  dest;
    char msg[50];
} packet_t;

/* ===== Part i: create_children ===== */
/*
 * Called by P0 initially; P0 creates P1, which then creates P2, etc.
 * Alternatively: P0 calls create_children in a loop.
 * Here we use the chain: each Pi forks Pi+1.
 *
 * All pipes for the entire chain are created by P0 BEFORE any fork,
 * so all processes inherit all pipe fds.
 * Each process then closes the ends it doesn't need.
 */
void create_children(int n, int my_idx) {
    n_procs = n;
    my_index = my_idx;

    /* P0 creates all pipes before any forking */
    if (my_idx == 0) {
        for (int i = 0; i < n - 1; i++) {
            pipe(down_pipe[i]);
            pipe(up_pipe[i]);
        }
    }

    if (my_idx < n - 1) {
        /* Fork the next process in the chain */
        pid_t pid = fork();
        if (pid == 0) {
            /* Child becomes P_{my_idx + 1} */
            create_children(n, my_idx + 1);
            /* Child stays in its event loop — does not return */
        }
        /* Parent continues to close unused fds and run its event loop */
    }

    /* Close all pipe ends we don't need:
     * Pi only uses:
     *   down_pipe[i-1] read end   (receive from parent)
     *   up_pipe[i-1]   write end  (send to parent)
     *   down_pipe[i]   write end  (send to child)
     *   up_pipe[i]     read end   (receive from child)
     * Everything else gets closed.
     */
    for (int i = 0; i < n - 1; i++) {
        int is_sender   = (i == my_idx);       /* down: we write to child */
        int is_receiver = (i == my_idx - 1);   /* down: we read from parent */
        int is_up_recv  = (i == my_idx);        /* up:   we read from child */
        int is_up_send  = (i == my_idx - 1);    /* up:   we write to parent */

        if (!is_receiver)  close(down_pipe[i][0]);
        if (!is_sender)    close(down_pipe[i][1]);
        if (!is_up_recv)   close(up_pipe[i][0]);
        if (!is_up_send)   close(up_pipe[i][1]);
    }
}

/* ===== Part ii: send_message and receive_message ===== */

/*
 * Send a message from this process to dest_process.
 * Writes the packet onto the appropriate pipe (up or down from here).
 */
void send_message(int dest_process, char *msg, int msg_len) {
    packet_t pkt;
    pkt.src  = my_index;
    pkt.dest = dest_process;
    memset(pkt.msg, 0, sizeof(pkt.msg));
    int copy_len = msg_len < 50 ? msg_len : 49;
    memcpy(pkt.msg, msg, copy_len);

    if (dest_process > my_index) {
        /* Send toward higher index: write to down_pipe[my_index] write end */
        write(down_pipe[my_index][1], &pkt, sizeof(pkt));
    } else if (dest_process < my_index) {
        /* Send toward lower index: write to up_pipe[my_index-1] write end */
        write(up_pipe[my_index - 1][1], &pkt, sizeof(pkt));
    }
    /* dest_process == my_index: deliver locally (no pipe needed) */
}

/*
 * Called when data is available on one of our incoming pipes.
 * Reads one packet, handles or forwards it.
 * 'buffer' is filled with the message if we are the destination.
 * *nread is set to the message length; 0 if we forwarded (not for us).
 */
void receive_message(char *buffer, int *nread, int buffer_max,
                     int from_fd) {
    packet_t pkt;
    ssize_t r = read(from_fd, &pkt, sizeof(pkt));
    if (r <= 0) { *nread = 0; return; }

    if (pkt.dest == my_index) {
        /* We are the destination — deliver to caller */
        int len = strnlen(pkt.msg, 50);
        int copy = len < buffer_max - 1 ? len : buffer_max - 1;
        memcpy(buffer, pkt.msg, copy);
        buffer[copy] = '\0';
        *nread = copy;
    } else {
        /* Forward toward destination — but never back on the same pipe */
        *nread = 0;
        if (pkt.dest > my_index && my_index < n_procs - 1) {
            write(down_pipe[my_index][1], &pkt, sizeof(pkt));
        } else if (pkt.dest < my_index && my_index > 0) {
            write(up_pipe[my_index - 1][1], &pkt, sizeof(pkt));
        }
    }
}

/* ===== Part iii: free_resources (called on SIGTERM) ===== */
void free_resources(void) {
    /* Close all open pipe ends held by this process */
    for (int i = 0; i < n_procs - 1; i++) {
        close(down_pipe[i][0]);
        close(down_pipe[i][1]);
        close(up_pipe[i][0]);
        close(up_pipe[i][1]);
        /* (harmless double-close on already-closed fds will just fail silently) */
    }
    /* Wait for any children if we forked one */
    while (waitpid(-1, NULL, WNOHANG) > 0);
}

static void sigterm_handler(int sig) {
    (void)sig;
    free_resources();
    _exit(0);
}

/* Register the handler */
void setup_sigterm(void) {
    struct sigaction sa;
    sa.sa_handler = sigterm_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGTERM, &sa, NULL);
}