When you need two processes on different machines to communicate, you have no choice — you must use Internet domain sockets (AF_INET or AF_INET6) with TCP or UDP.

But what if both processes are on the same machine? You then have two options:

The TLPI text says that writing with only Internet domain sockets is often the simplest approach since it works on both single host and across a network — but there are specific reasons to prefer UNIX domain sockets for local IPC.

On many Linux and Unix implementations, UNIX domain sockets are faster than Internet domain sockets for local IPC.

Why? With Internet domain sockets on the same machine, data still goes through the full TCP/IP stack — TCP segmentation, IP header processing, checksum calculation, loopback routing — even though the data never leaves the machine. With UNIX domain sockets, the kernel skips all of this and copies data directly through kernel memory.

Important caveat: Modern Linux kernels have significantly optimized the loopback path. The performance difference may be small for many workloads. Always benchmark your specific use case before making assumptions.

This is one of the strongest reasons to use UNIX domain sockets for local IPC. Because a UNIX socket appears as a file in the filesystem, you can use standard file permission bits and ownership to control which users or groups can connect to it.

/* Example: Create a UNIX domain socket accessible only to a specific group */
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define SOCKET_PATH "/var/run/myapp.sock"

int create_restricted_socket(void)
{
    int sfd;
    struct sockaddr_un addr;

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

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

    unlink(SOCKET_PATH);   /* Remove old socket file if it exists */

    if (bind(sfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        return -1;
    }

    /* Set permissions: owner can read/write, group can read/write, others nothing */
    /* This means only processes running as the socket owner or in its group       */
    /* can connect — a simple form of authentication                               */
    if (chmod(SOCKET_PATH, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) == -1) {
        perror("chmod");
        return -1;
    }

    return sfd;
}

On Linux, the socket file can also be placed in a directory with restricted access, adding another layer of control based on directory permissions.

UNIX domain sockets support two capabilities that are impossible with Internet domain sockets:

/* Skeleton: Receiving peer credentials on Linux */
#include <sys/socket.h>
#include <sys/un.h>

int get_peer_credentials(int conn_fd)
{
    struct ucred cred;
    socklen_t len = sizeof(cred);

    /* SO_PEERCRED is a Linux-specific socket option */
    if (getsockopt(conn_fd, SOL_SOCKET, SO_PEERCRED, &cred, &len) == -1) {
        perror("getsockopt SO_PEERCRED");
        return -1;
    }

    printf("Peer PID: %ld\n", (long)cred.pid);
    printf("Peer UID: %ld\n", (long)cred.uid);
    printf("Peer GID: %ld\n", (long)cred.gid);

    return 0;
}

The socket API is deliberately similar for both domains. Here is how a server creation looks side-by-side:

/* ====== Internet Domain Server ====== */
int create_inet_server(int port)
{
    int sfd;
    struct sockaddr_in addr;

    sfd = socket(AF_INET, SOCK_STREAM, 0);  /* AF_INET for internet */

    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(port);       /* Port number         */
    addr.sin_addr.s_addr = INADDR_ANY;        /* All interfaces      */

    bind(sfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(sfd, 5);
    return sfd;
}

/* ====== UNIX Domain Server ====== */
int create_unix_server(const char *path)
{
    int sfd;
    struct sockaddr_un addr;

    sfd = socket(AF_UNIX, SOCK_STREAM, 0);   /* AF_UNIX for local  */

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;                /* Address family      */
    strncpy(addr.sun_path, path,              /* Filesystem path     */
            sizeof(addr.sun_path) - 1);

    unlink(path);   /* Clean up old socket file if it exists */
    bind(sfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(sfd, 5);
    return sfd;
}

The key differences are just the address family (AF_INET vs AF_UNIX) and the address structure (sockaddr_in vs sockaddr_un). The bind(), listen(), accept(), read(), write() calls are identical.

One extra step for UNIX sockets: you should call unlink(path) before binding to remove a stale socket file from a previous run.