1. What is Out-of-Band Data?

Out-of-band data is a feature of stream sockets (not datagram sockets). It allows a sender to mark certain data as high priority. The receiver is notified that high-priority data is waiting even if it has not yet read all the normal (in-band) data that came before it.

The receiver gets a SIGURG signal when out-of-band data arrives. It can then handle the urgent situation before going back to read the normal data.

Real-world users of OOB data:

• telnet — sends interrupt (Ctrl+C) as OOB to abort a running command
• rlogin — remote login, uses OOB for session control signals
• ftp — uses OOB to abort a running file transfer

2. How to Send and Receive OOB Data

OOB data is sent using send() with the MSG_OOB flag, and received using recv() with the same MSG_OOB flag.

Sender Side

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

/* Send normal data first */
send(sockfd, "Hello World", 11, 0);

/* Send 1 byte of OOB data — must be exactly 1 byte with TCP */
send(sockfd, "!", 1, MSG_OOB);

/* Send more normal data */
send(sockfd, "Goodbye", 7, 0);

Receiver Side — Signal Handler Approach

#include <sys/socket.h>
#include <signal.h>
#include <fcntl.h>
#include <stdio.h>

int oob_socket; /* global so signal handler can use it */

/* SIGURG signal handler — called when OOB data arrives */
void sigurg_handler(int sig)
{
    char oob_byte;
    int n;

    /*
     * Use MSG_OOB flag to read the out-of-band byte.
     * This reads the OOB data without consuming the normal stream.
     */
    n = recv(oob_socket, &oob_byte, 1, MSG_OOB);
    if (n == 1) {
        printf("Received OOB byte: 0x%02x ('%c')\n",
               (unsigned char)oob_byte, oob_byte);
        /* Handle the urgent command here */
    }
}

int setup_oob_receiver(int sockfd)
{
    oob_socket = sockfd;

    /* Register the SIGURG handler */
    signal(SIGURG, sigurg_handler);

    /*
     * Tell the kernel which process should receive SIGURG
     * when OOB data arrives on this socket.
     * Without this, SIGURG is not sent to anyone.
     */
    if (fcntl(sockfd, F_SETOWN, getpid()) == -1) {
        perror("fcntl F_SETOWN");
        return -1;
    }

    return 0;
}

int main(void)
{
    int sockfd;
    char buf[256];
    ssize_t n;

    /* ... connect/accept ... */
    setup_oob_receiver(sockfd);

    /* Normal read loop — SIGURG will interrupt this asynchronously */
    while ((n = read(sockfd, buf, sizeof(buf))) > 0) {
        buf[n] = '\0';
        printf("Normal data: %s\n", buf);
    }

    return 0;
}

3. TCP’s Critical Limitation: Only 1 Byte at a Time

This is the most important thing to know about OOB data in TCP: at most 1 byte can be marked as out-of-band at any one time.

This is not an artificial API restriction — it comes from how TCP itself works internally.

How TCP Urgent Mode Works Internally

The Overwrite Problem

/* PROBLEM: What happens if sender sends two OOB bytes quickly */

send(sockfd, "A", 1, MSG_OOB);  /* First OOB byte */
send(sockfd, "B", 1, MSG_OOB);  /* Second OOB byte */

/*
 * If the receiver has not yet read the first OOB byte "A",
 * the indication for "A" is LOST when "B" arrives.
 * TCP only keeps track of ONE urgent position at a time.
 *
 * The receiver will only see "B" as OOB data.
 * "A" becomes indistinguishable from normal stream data.
 */

4. UNIX Domain Sockets and OOB Data

Some UNIX implementations support out-of-band data for UNIX domain stream sockets as well. Linux does not support this. OOB data on Linux only works with TCP (Internet domain stream sockets).

5. Why OOB Data Is Discouraged Today

Modern socket programming advice discourages the use of out-of-band data for several reasons:

• Limited to 1 byte at a time in TCP
• Can be unreliable in some network configurations and TCP implementations
• Behavior is not consistent across all UNIX implementations
• Some network equipment (firewalls, routers) may strip or mishandle urgent data
• Only works with stream sockets

Better Alternative: Two Separate Socket Connections

The recommended modern approach is to maintain two separate stream sockets between the same pair of communicating processes:

Advantages of two sockets over OOB data:

• Can send multiple bytes of priority data (not limited to 1 byte)
• Works with any stream socket domain (UNIX domain, TCP, etc.)
• Much more portable and reliable
• Easier to reason about and debug

#include <sys/socket.h>
#include <sys/select.h>

/*
 * Modern approach: two separate connections.
 * Monitor both with select() in a single loop.
 */
void two_socket_server(int data_fd, int ctrl_fd)
{
    fd_set readfds;
    char buf[1024];
    int maxfd = (data_fd > ctrl_fd) ? data_fd : ctrl_fd;
    ssize_t n;

    for (;;) {
        FD_ZERO(&readfds);
        FD_SET(data_fd, &readfds);
        FD_SET(ctrl_fd, &readfds);

        if (select(maxfd + 1, &readfds, NULL, NULL, NULL) < 0) {
            perror("select");
            break;
        }

        /* Check high-priority control channel first */
        if (FD_ISSET(ctrl_fd, &readfds)) {
            n = read(ctrl_fd, buf, sizeof(buf));
            if (n > 0) {
                buf[n] = '\0';
                printf("PRIORITY command: %s\n", buf);
                /* e.g., "ABORT", "PAUSE", "CANCEL" */
                if (strncmp(buf, "ABORT", 5) == 0) break;
            }
        }

        /* Then handle normal data */
        if (FD_ISSET(data_fd, &readfds)) {
            n = read(data_fd, buf, sizeof(buf));
            if (n > 0) {
                printf("Normal data: %zu bytes\n", (size_t)n);
                /* Process the data */
            }
        }
    }
}

Interview Questions