Linux has many IPC mechanisms — pipes, FIFOs, System V message queues, shared memory. Why use UNIX domain sockets?

UNIX domain sockets combine the best of both worlds: the ease of the socket API (which developers already know from networking) with high performance of local IPC. They are used by many critical Linux services — systemd, D-Bus, X11 display server, MySQL, PostgreSQL, and Docker all use UNIX domain sockets.

UNIX domain sockets come in two main types:

Important: Unlike UDP datagrams over a network, UNIX domain datagrams are reliable and ordered. The kernel handles them entirely in memory, so they cannot get lost or reordered. However, if the receiver’s buffer is full, the sender will block until space is available.

Every socket needs an address. For UNIX domain sockets, the address is either a file system path or an abstract name. The structure used is struct sockaddr_un defined in <sys/un.h>.

#include <sys/un.h>

struct sockaddr_un {
    sa_family_t sun_family;   /* Always AF_UNIX */
    char        sun_path[108]; /* Socket path (or abstract name) */
};

Key points about sockaddr_un:

• sun_family must always be AF_UNIX
• sun_path holds the file system path as a null-terminated string
• The maximum path length is 108 characters (including the null terminator) on Linux
• For abstract namespace sockets, sun_path[0] is a null byte ('\0')

When calculating the length to pass to bind(), use the SUN_LEN() macro or calculate manually:

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>

int main(void)
{
    struct sockaddr_un addr;
    socklen_t addr_len;

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, "/tmp/my_socket", sizeof(addr.sun_path) - 1);

    /* Calculate the correct length for bind() */
    /* Method 1: using offsetof + strlen */
    addr_len = offsetof(struct sockaddr_un, sun_path) + strlen(addr.sun_path) + 1;

    /* Method 2: using SUN_LEN macro (same result) */
    addr_len = SUN_LEN(&addr);

    printf("Address family : %d (AF_UNIX = %d)\n", addr.sun_family, AF_UNIX);
    printf("Socket path    : %s\n", addr.sun_path);
    printf("Address length : %u bytes\n", (unsigned)addr_len);

    return 0;
}

Creating a UNIX domain socket uses the same socket() call as network sockets:

#include <sys/socket.h>

/* Prototype */
int socket(int domain, int type, int protocol);

/* For UNIX domain stream socket */
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) {
    perror("socket");
    exit(EXIT_FAILURE);
}

/* For UNIX domain datagram socket */
int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
if (fd == -1) {
    perror("socket");
    exit(EXIT_FAILURE);
}

The third argument (protocol) is always 0 for UNIX domain sockets — there is only one protocol for each socket type in this domain.

When you call bind() on a UNIX domain socket, the kernel creates a special file in the file system at the given path. This file has type socket (shown as s by ls -l).

$ ls -l /tmp/my_socket
srwxrwxrwx 1 ravi ravi 0 Jun 13 10:00 /tmp/my_socket
^
|_ 's' = socket file type

Important rules about socket files:

/* Safe bind pattern — remove old socket file first */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_PATH "/tmp/my_socket"

int create_and_bind_socket(void)
{
    int fd;
    struct sockaddr_un addr;

    fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (fd == -1) {
        perror("socket");
        return -1;
    }

    /* Remove old socket file if it exists */
    if (remove(SOCKET_PATH) == -1 && errno != ENOENT) {
        perror("remove");
        close(fd);
        return -1;
    }

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);

    if (bind(fd, (struct sockaddr *)&addr, SUN_LEN(&addr)) == -1) {
        perror("bind");
        close(fd);
        return -1;
    }

    return fd;
}

UNIX Domain Stream Socket — Server/Client Flow:

UNIX Domain Datagram Socket — Flow:

#include <sys/socket.h>   /* socket(), bind(), connect(), listen(), accept() */
#include <sys/un.h>       /* struct sockaddr_un, AF_UNIX */
#include <unistd.h>       /* close(), read(), write(), unlink() */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

Compile with:

gcc -Wall -o server server.c
gcc -Wall -o client client.c