Unix Sockets

Chapter 1: Overview

Unix domain sockets look like special files in the filesystem (just like FIFOs), but you don't use open() and read(). Instead, you use the sockets API: socket(), bind(), listen(), accept(), connect(), send(), recv().

The communication follows a client-server pattern:

The "address" of a Unix socket is a filesystem path. Both sides reference the same path to establish a connection. The key data structure is struct sockaddr_un:

c
struct sockaddr_un {
    unsigned short sun_family;  /* AF_UNIX */
    char           sun_path[108]; /* socket path */
};

Chapter 2: socket() — Creating the Endpoint

The first step for both server and client is creating a socket descriptor with socket():

c
#include <sys/socket.h>
#include <sys/un.h>

int s;
s = socket(AF_UNIX, SOCK_STREAM, 0);

socket() returns a file descriptor, just like open(). This descriptor is an endpoint — think of it as the phone itself, before you've dialed a number or picked up a ringing call.

Chapter 3: Being a Server

A server does five things: socket, bind, listen, accept, handle. Let's walk through each step.

Step 1: socket()

Create the socket (you already know this from Chapter 2).

Step 2: bind()

Associate the socket with a filesystem path:

c
struct sockaddr_un local;

local.sun_family = AF_UNIX;
strcpy(local.sun_path, "/tmp/echo_socket");
unlink(local.sun_path);  /* remove if exists */

int len = strlen(local.sun_path) + sizeof(local.sun_family);
bind(s, (struct sockaddr *)&local, len);

Step 3: listen()

Tell the socket to start accepting incoming connections:

c
listen(s, 5);  /* backlog of 5 pending connections */

The second argument is the backlog — how many connections can queue up before you call accept(). Additional clients get ECONNREFUSED.

Step 4: accept()

Block until a client connects, then return a new socket descriptor for that connection:

c
struct sockaddr_un remote;
int t = sizeof(remote);
int s2 = accept(s, (struct sockaddr *)&remote, &t);

Step 5: Handle the connection

Use send() and recv() on the new descriptor s2. When done, close(s2) and loop back to accept().

Chapter 4: Being a Client

The client side is much simpler. No bind(), no listen(), no accept(). Just create a socket and connect:

c
int s;
struct sockaddr_un remote;

s = socket(AF_UNIX, SOCK_STREAM, 0);

remote.sun_family = AF_UNIX;
strcpy(remote.sun_path, "/tmp/echo_socket");
int len = strlen(remote.sun_path) + sizeof(remote.sun_family);

connect(s, (struct sockaddr *)&remote, len);

/* Now send() and recv() freely */
send(s, "Hello!", 6, 0);
recv(s, buf, 100, 0);
close(s);

Chapter 5: echos.c — The Echo Server

Beej's echo server waits for a connection, receives whatever the client sends, and echoes it right back. Here's the full program:

c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCK_PATH "echo_socket"

int main(void) {
    int s, s2, t, len;
    struct sockaddr_un local, remote;
    char str[100];

    s = socket(AF_UNIX, SOCK_STREAM, 0);

    local.sun_family = AF_UNIX;
    strcpy(local.sun_path, SOCK_PATH);
    unlink(local.sun_path);
    len = strlen(local.sun_path)
        + sizeof(local.sun_family);

    bind(s, (struct sockaddr *)&local, len);
    listen(s, 5);

    for(;;) {
        int done, n;
        printf("Waiting for a connection...\n");
        t = sizeof(remote);
        s2 = accept(s, (struct sockaddr *)&remote,
                    &t);
        printf("Connected.\n");

        done = 0;
        do {
            n = recv(s2, str, 100, 0);
            if (n <= 0) {
                if (n < 0) perror("recv");
                done = 1;
            }
            if (!done)
                send(s2, str, n, 0);
        } while (!done);

        close(s2);
    }
    return 0;
}

Chapter 6: echoc.c — The Echo Client

The client is simpler — no bind, no listen, no accept. Just connect and talk:

c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCK_PATH "echo_socket"

int main(void) {
    int s, t, len;
    struct sockaddr_un remote;
    char str[100];

    s = socket(AF_UNIX, SOCK_STREAM, 0);

    remote.sun_family = AF_UNIX;
    strcpy(remote.sun_path, SOCK_PATH);
    len = strlen(remote.sun_path)
        + sizeof(remote.sun_family);

    connect(s, (struct sockaddr *)&remote, len);

    while(printf("> "),
          fgets(str, 100, stdin),
          !feof(stdin)) {
        send(s, str, strlen(str), 0);

        t = recv(s, str, 100, 0);
        if (t > 0) {
            str[t] = '\0';
            printf("echo> %s", str);
        } else {
            printf("Server closed\n");
            exit(1);
        }
    }
    close(s);
    return 0;
}

Chapter 7: socketpair() — Quick Full-Duplex Pipes

What if you want a two-way pipe between a parent and child process, without all the server/client setup? That's what socketpair() is for. It creates two connected sockets in one call — no bind, no listen, no accept, no connect.

c
#include <sys/socket.h>

int sv[2];
socketpair(AF_UNIX, SOCK_STREAM, 0, sv);

After this call, sv[0] and sv[1] are connected to each other. Write to sv[0], read from sv[1]. Write to sv[1], read from sv[0]. Bidirectional.

The typical pattern: call socketpair(), then fork(). The parent uses sv[0], the child uses sv[1]:

c
int sv[2];
char buf;

socketpair(AF_UNIX, SOCK_STREAM, 0, sv);

if (!fork()) {
    /* Child: use sv[1] */
    read(sv[1], &buf, 1);
    printf("child: read '%c'\n", buf);
    buf = toupper(buf);
    write(sv[1], &buf, 1);
} else {
    /* Parent: use sv[0] */
    write(sv[0], "b", 1);
    read(sv[0], &buf, 1);
    printf("parent: read '%c'\n", buf);
    wait(NULL);
}

Chapter 8: Echo Server Simulator

Watch the full client-server interaction play out step by step. Type a message, watch it travel through the socket, and see the echo come back.

Chapter 9: Beyond Unix Sockets

You've now seen every IPC mechanism in the Unix toolkit. Let's put them all in perspective:

"Wouldn't it be grand if you could send data in both directions like you can with a socket? Well, hope no longer, because the answer is here: Unix Domain Sockets!" — Beej