Linux Inter Process Communication (IPC) from Scratch in C

Understand how sockets enable inter-process communication on Linux, for both same-machine and networked processes. Learn socket APIs and a client-server workflow using typical system calls.

Outline the socket design state machine for Linux IPC, from creating the master socket to accepting new clients and processing service requests with per-client data sockets.

Learn how the accept system call converts a server's master socket into a client communication file descriptor, enabling bidirectional, connection-oriented data exchange with new clients.

Explore implementing a unix domain server in C via the server.c state machine, covering socket creation, 128-byte buffer, and summing numbers until zero.

Explain the unix domain client in C: create a data socket, connect using the server's socket name, send integers, and read the server's reply.

Learn how to implement multiplexing in c using select and accept, maintaining a master socket and per-client fds in an fd set to handle multiple connections.

Demonstrates a multiplexed Unix domain server in C that accepts multiple clients via select, computes per-client sums of integers, and handles new connections concurrently.

Learn to build a unix domain socket IPC system where a routing table manager propagates create, update, and delete operations across connected clients and dumps the table to new connections.

Explore message queue as a Linux IPC mechanism, learn its concepts and APIs, understand enqueue and dequeue workflows, and walk through a kernel-resident queue based sender and receiver implementation.

Create and use a kernel-space message queue from user-space processes to enable IPC, where queues are identified by a string ID that bridges sender and receiver.

Use mq_receive to fetch the oldest message with the highest priority from a message queue, filling the provided buffer and returning the bytes received; blocking behavior is controlled at open.

Learn how the message queue unlink API destroys a queue by releasing the kernel resource after all users close it, returning zero on success and minus one on failure.

Download the source and run the sender and receiver C files to demonstrate message queue IPC, where the sender sends user input to the receiver and the receiver prints it.

Explore how shared memory enables fast inter process communication in Linux by using memory mappings and system calls, with hands-on guidance on implementing sender and receiver processes.

Explore memory mapping in Linux via the map system call, creating virtual pages that map to physical memory and update the page table, with text files mapped as virtual memory.

Learn how memory mapping via the map system call creates shared memory by mapping external memory into multiple processes' virtual address spaces, sharing physical pages and synchronizing changes.

Demonstrate Linux ipc with shared memory via programs using mmap as a malloc substitute, importing text into address space, and using shm_open, ftruncate, mmap, read, write, and shm_unlink across processes.

Explore design constraints for shared memory as inter-process communication, with one publisher, many subscribers, and infrequent updates. Publishers notify subscribers after updates via inter-process communication mechanisms; subscribers read fresh memory.

Explore how Linux signals enable inter-process communication by signaling between processes, capturing signals, and applying default actions, signal handlers, and registration that pre-empts execution.

Explore Linux well known signals, including SIGINT, SIGUSR1 and SIGUSR2, SIGKILL, SIGABRT, SIGTERM, SIGSEGV, and SIGCHLD, and learn their default behaviors, catchability, and how child termination via fork triggers SIGCHLD.

Synchronize new clients with the rtm server by exchanging pids over unix domain sockets, updating in-memory routing and arp tables via shared memory, and signaling clients to flush on command.

Explore socket programming with a tcp focus, learn client-server architecture in C, and master multiplexing with the select and accept system calls to handle multiple clients.

Analyze the accept system call on the TCP server to establish a bi-directional connection, handle client requests, and return a communication file descriptor for data exchange.

Follow the ten steps of the state machine to implement a tcp server; this lecture walks through setup, socket creation, bind, and listen with a tcp server dot c example.

This lecture explains building a tcp server that uses select to monitor the master socket, accept new clients, and exchange data in an infinite loop.

Read a and b from the client, compute their sum, and reply with the result; close the connection when both values are zero, and loop to await the next client.

Observe a blocking TCP server design where the server handles only one client at a time, blocked during data receive, illustrating limitations and the single-client use case.

Explore tcp server design with multiplexing to handle multiple clients using fd_set and select. Learn how to compile and run the tcp client and server on localhost and exchange values.

Explore the high level design of a multiplexed tcp server that can handle multiple clients using a master socket, per-client file descriptors, an fd array, and the select system call.

Explore a TCP server with multiplexing implemented via select, managing the master socket and client file descriptors, accepting connections, and handling data exchange across multiple clients.

Review the socket APIs, including socket, select, accept, bind, listen, receive, send, and close, and analyze a TCP server with multiplexing and 31 connections, contrasting with UDP's simplicity.

Learn to build a distributed transparent memory system using sockets in C, presenting an eight-gigabyte, multi-node memory as a single, user-visible memory space.

Deploy and simulate a six-node ring topology on a single machine by running the same program in six terminals, each binding to 127.0.0.1 with unique UDP and TCP ports.

Explain the put request algorithm in a ring topology, hashing K with K mod N to locate the node, forward via UDP, and retrieve X from the originator over TCP.

Describe how a node in a ring topology processes a put forward message by hashing the key and comparing the node ID; if originator, store key in hash table.

Follow the pseudo code to implement a tcp/udp ipc project in c using select to monitor tcp, udp, and console, handling put/get messages in a ring topology.

Learn how a single C program models a ring topology with hash function k mod n and roles, supporting put and get requests using tcp/udp servers and clients with select.

Develop a tcp/ip stack memory manager and practice thread synchronization within Linux ipc concepts from scratch. Learn debugging techniques on Linux socket programming and network protocol development from scratch.