What are Sockets as an IPC Mechanism?
Learn what sockets are as IPC — bidirectional, local or networked, Unix domain sockets — with a C example and OS interview Q&A.
Expected Interview Answer
A socket is a bidirectional communication endpoint, addressed by the kernel’s networking or Unix-domain stack, that lets two processes exchange data using the same read/write style API whether they are on the same machine or across a network.
Sockets are created with socket(), bound to an address (an IP:port pair for network sockets, or a filesystem path for Unix domain sockets), and then connected via connect()/accept() for stream-oriented, connection-based communication, or used directly with sendto()/recvfrom() for connectionless datagram communication. Unlike a pipe, a socket is inherently bidirectional and does not require a common ancestor process — any two processes that know each other’s address can communicate, including processes on entirely different hosts, which is what makes sockets the universal building block for client-server and distributed systems. On the same machine, Unix domain sockets skip the network protocol stack entirely and copy data directly through the kernel, making them faster than TCP loopback sockets while still offering an addressable, multi-client rendezvous point similar to a named pipe but bidirectional and connection-oriented. The tradeoff versus shared memory is the same copy overhead as any message-passing style IPC, but sockets buy portability: the same code that talks to a process on the same machine can talk to one across the world.
- Bidirectional by default, unlike a plain pipe
- Works between unrelated processes, and across machines over a network
- Unix domain sockets give near-message-passing speed for local IPC
- Same API scales from local IPC to full distributed client-server systems
AI Mentor Explanation
A socket is like a two-way radio channel between a commentator and a stadium announcer, addressed by a specific channel number that either side can dial into, unlike a one-way relay tube that only carries messages one direction. Either party can talk or listen at any moment once the channel is open, and the channel works whether the announcer is in the same stadium or broadcasting from a different city entirely. A local walkie-talkie channel within the same ground is faster to set up than a long-distance radio link, mirroring how Unix domain sockets beat network sockets for local traffic.
Step-by-Step Explanation
Step 1
Create the socket
A process calls socket(domain, type, protocol) to get a socket descriptor, choosing AF_INET for network or AF_UNIX for local IPC.
Step 2
Bind and listen (server)
The server binds the socket to an address (IP:port or filesystem path) and calls listen() to accept incoming connections.
Step 3
Connect and accept
The client calls connect() to that address; the server's accept() returns a new connected socket for that client.
Step 4
Bidirectional read/write
Both sides use send()/recv() (or read()/write()) freely in either direction until either side closes the connection.
What Interviewer Expects
- Clear definition: bidirectional, addressable communication endpoint, local or networked
- Distinction between stream (TCP-style, connection-oriented) and datagram (UDP-style, connectionless) sockets
- Knowledge of Unix domain sockets as a fast local-only variant
- Understanding that sockets work between unrelated and even remote processes, unlike pipes
Common Mistakes
- Thinking sockets are only for networked, cross-machine communication
- Confusing a listening socket with a connected socket returned by accept()
- Forgetting that Unix domain sockets bypass the network stack for local speed
- Assuming sockets are unidirectional like a plain pipe
Best Answer (HR Friendly)
“A socket is a two-way communication endpoint that works the same whether the two programs are on the same computer or on opposite sides of the world, which is why it is the backbone of client-server systems like web servers. On the same machine, there is a lighter version called a Unix domain socket that skips the network layer for speed, while still letting any two programs that know its address connect, even if one did not start the other.”
Code Example
int srv = socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un addr = { .sun_family = AF_UNIX };
strcpy(addr.sun_path, "/tmp/mysocket");
bind(srv, (struct sockaddr *)&addr, sizeof(addr));
listen(srv, 5);
int client_fd = accept(srv, NULL, NULL); /* blocks until a client connects */
char buf[64];
int n = read(client_fd, buf, sizeof(buf));
buf[n] = '\0';
printf("server got: %s\n", buf);
write(client_fd, "ack", 3); /* sockets are bidirectional */
close(client_fd);
close(srv);Follow-up Questions
- How does a Unix domain socket differ in performance from a TCP loopback socket?
- What is the difference between SOCK_STREAM and SOCK_DGRAM sockets?
- How does accept() relate to the original listening socket descriptor?
- When would you choose sockets over shared memory or message queues for local IPC?
MCQ Practice
1. What distinguishes a socket from a plain pipe as an IPC mechanism?
Unlike a unidirectional pipe requiring a common ancestor, sockets are bidirectional and addressable, working locally or across a network.
2. What makes a Unix domain socket typically faster than a TCP loopback socket for local IPC?
Unix domain sockets skip IP/TCP protocol processing entirely, transferring data directly within the kernel for lower overhead.
3. Which socket type is connectionless and does not guarantee ordering?
SOCK_DGRAM sockets (like UDP) send independent datagrams with no connection setup and no delivery/order guarantee, unlike SOCK_STREAM.
Flash Cards
What is a socket as IPC? — A bidirectional, addressable communication endpoint usable locally or across a network.
How does a socket differ from a pipe? — Sockets are bidirectional and work between unrelated or remote processes; pipes are unidirectional and need a common ancestor.
What is a Unix domain socket? — A local-only socket variant that bypasses the network stack for faster same-machine IPC.
Stream vs datagram sockets? — Stream (SOCK_STREAM) is connection-oriented and ordered; datagram (SOCK_DGRAM) is connectionless with no ordering guarantee.