#include <sys/socket.h>

/* Creates a pair of connected sockets */
int socketpair(int domain,    /* Must be AF_UNIX */
               int type,      /* SOCK_STREAM or SOCK_DGRAM */
               int protocol,  /* Must be 0 */
               int sv[2]);    /* Output: two file descriptors */

/* Returns 0 on success, -1 on error */
/* sv[0] and sv[1] are connected to each other */
/* Writing to sv[0] can be read from sv[1], and vice versa */

Important rules:

• domain must be AF_UNIX — socketpair works only for local sockets
• type can be SOCK_STREAM or SOCK_DGRAM
• The two sockets are indistinguishable — either end can send or receive
• No binding is needed — these sockets have no address in the file system
• Commonly used with fork() for parent-child communication

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/wait.h>

int main(void)
{
    int    sv[2];
    pid_t  pid;
    char   buf[128];
    ssize_t n;

    /* Create the socket pair BEFORE forking */
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
        perror("socketpair");
        exit(EXIT_FAILURE);
    }

    /* sv[0] and sv[1] are now connected to each other */
    printf("sv[0]=%d, sv[1]=%d\n", sv[0], sv[1]);

    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        /* CHILD: use sv[1], close sv[0] */
        close(sv[0]);

        /* Read message from parent */
        n = read(sv[1], buf, sizeof(buf) - 1);
        if (n > 0) {
            buf[n] = '\0';
            printf("Child received: %s\n", buf);
        }

        /* Send reply */
        const char *reply = "Hello from child!";
        write(sv[1], reply, strlen(reply));

        close(sv[1]);
        exit(EXIT_SUCCESS);

    } else {
        /* PARENT: use sv[0], close sv[1] */
        close(sv[1]);

        /* Send message to child */
        const char *msg = "Hello from parent!";
        write(sv[0], msg, strlen(msg));

        /* Read reply from child */
        n = read(sv[0], buf, sizeof(buf) - 1);
        if (n > 0) {
            buf[n] = '\0';
            printf("Parent received: %s\n", buf);
        }

        close(sv[0]);
        waitpid(pid, NULL, 0);
    }

    return 0;
}

Expected output:

sv[0]=3, sv[1]=4
Child received: Hello from parent!
Parent received: Hello from child!

Rule of thumb: If you just need simple parent-child communication in one direction, use pipe() (simpler, slightly less overhead). If you need bidirectional communication or want to pass file descriptors, use socketpair().

This implements the sequence number server (originally in Section 44.8 for FIFOs) using UNIX domain stream sockets. Each client request gets the next number in a global sequence.

Sequence number server (seqnum_sv.c):

/* seqnum_sv.c — sequence number server using UNIX domain stream sockets */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdint.h>

#define SOCK_PATH  "/tmp/seqnum_sv"
#define BACKLOG    5

/* Protocol: client sends how many numbers it wants (uint32_t)
 *           server replies with the starting number (uint32_t) */

int main(void)
{
    struct sockaddr_un addr;
    int                sfd, cfd;
    uint32_t           seq_num = 0;   /* Next sequence number to allocate */
    uint32_t           req, resp;

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

    remove(SOCK_PATH);

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

    if (bind(sfd, (struct sockaddr *)&addr, SUN_LEN(&addr)) == -1) {
        perror("bind"); exit(EXIT_FAILURE);
    }

    if (listen(sfd, BACKLOG) == -1) {
        perror("listen"); exit(EXIT_FAILURE);
    }

    printf("Sequence number server listening on %s\n", SOCK_PATH);

    for (;;) {
        cfd = accept(sfd, NULL, NULL);
        if (cfd == -1) {
            perror("accept");
            continue;
        }

        /* Read the client's request: how many sequence numbers do you want? */
        if (read(cfd, &req, sizeof(req)) != sizeof(req)) {
            fprintf(stderr, "Failed to read request\n");
            close(cfd);
            continue;
        }

        /* Reply: starting number of the allocated block */
        resp = seq_num;
        seq_num += req;

        printf("Client requests %u numbers: allocating %u..%u\n",
               req, resp, seq_num - 1);

        if (write(cfd, &resp, sizeof(resp)) != sizeof(resp)) {
            fprintf(stderr, "Failed to write response\n");
        }

        close(cfd);
    }

    unlink(SOCK_PATH);
    return 0;
}

Sequence number client (seqnum_cl.c):

/* seqnum_cl.c — sequence number client */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdint.h>

#define SOCK_PATH "/tmp/seqnum_sv"

int main(int argc, char *argv[])
{
    struct sockaddr_un addr;
    int                sfd;
    uint32_t           req, resp;
    unsigned long      count;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <count>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    count = strtoul(argv[1], NULL, 10);
    req   = (uint32_t)count;

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

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

    if (connect(sfd, (struct sockaddr *)&addr, SUN_LEN(&addr)) == -1) {
        perror("connect"); exit(EXIT_FAILURE);
    }

    /* Send the number of sequence numbers we want */
    if (write(sfd, &req, sizeof(req)) != sizeof(req)) {
        fprintf(stderr, "Failed to write request\n");
        exit(EXIT_FAILURE);
    }

    /* Receive the starting number */
    if (read(sfd, &resp, sizeof(resp)) != sizeof(resp)) {
        fprintf(stderr, "Failed to read response\n");
        exit(EXIT_FAILURE);
    }

    printf("PID %ld: allocated sequence numbers %u..%u\n",
           (long)getpid(), resp, resp + req - 1);

    close(sfd);
    return 0;
}

Test with multiple clients simultaneously:

# Terminal 1
./seqnum_sv

# Terminal 2 — multiple clients at once
./seqnum_cl 3 &
./seqnum_cl 5 &
./seqnum_cl 2 &
wait