The Core Idea: One Listener, Many Services

How inetd Works Internally

Understanding inetd’s internal mechanics is important because it uses the same system calls you have already learned, just in a clever way.

/* Inside inetd's child process (simplified): */

/* cfd = connected socket (for TCP), or the UDP socket for UDP */

dup2(cfd, STDIN_FILENO);    /* stdin  (fd 0) now points to the socket */
dup2(cfd, STDOUT_FILENO);   /* stdout (fd 1) now points to the socket */
dup2(cfd, STDERR_FILENO);   /* stderr (fd 2) now points to the socket */

/* Close original cfd since we have copies as 0, 1, 2 */
if (cfd > STDERR_FILENO)
    close(cfd);

/* Close all other inherited file descriptors from inetd */
/* (inetd had many sockets open for other services) */
for (int fd = 3; fd < max_fd; fd++)
    close(fd);

/* Now exec the server program.
 * It reads from stdin (=socket) and writes to stdout (=socket).
 * It doesn't even need to know it's talking over a network! */
execve(server_program_path, server_argv, environ);

The Configuration File: /etc/inetd.conf

inetd’s behavior is controlled entirely by /etc/inetd.conf. Each line describes one service. The format is:

# Format:
# service  socket-type  protocol  wait/nowait  user  server-path  server-args
#
# service     = name from /etc/services (or a port number)
# socket-type = stream (TCP) or dgram (UDP)
# protocol    = tcp or udp
# wait/nowait = wait: inetd waits for server to exit before accepting more (UDP)
#               nowait: inetd accepts the next connection immediately (TCP)
# user        = username the server runs as
# server-path = full path to the server executable
# server-args = arguments passed to the server (argv[0] is program name)

# Example lines from a real /etc/inetd.conf:

# Echo service (TCP) - nowait: inetd doesn't wait, serves next client
echo    stream  tcp  nowait  root  /usr/sbin/echod  echod

# Echo service (UDP) - wait: inetd waits for this datagram exchange to finish
echo    dgram   udp  wait    root  /usr/sbin/echod  echod

# Daytime service - server is built-in to inetd (no external program)
daytime stream  tcp  nowait  root  internal

# FTP service
ftp     stream  tcp  nowait  root  /usr/sbin/ftpd   ftpd

# Telnet service
telnet  stream  tcp  nowait  root  /usr/sbin/telnetd telnetd -a

Writing an inetd-Compatible Server

Here is the key insight: because inetd sets up stdin and stdout to be the socket, your server program does not need any socket code at all! It just reads from stdin and writes to stdout. This is a beautifully simple design.

/*
 * simple_echo_inetd.c
 *
 * An echo server designed to be launched by inetd.
 * inetd connects stdin/stdout to the client socket before exec-ing us.
 * We just read from stdin and write to stdout — no socket code needed!
 *
 * In /etc/inetd.conf:
 *   echo  stream  tcp  nowait  root  /usr/local/bin/simple_echo_inetd  simple_echo_inetd
 *
 * Compile: gcc -o simple_echo_inetd simple_echo_inetd.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define BUF_SIZE 4096

int main(void)
{
    char buf[BUF_SIZE];
    ssize_t numRead;

    /*
     * stdin (fd 0)  = the client's connected TCP socket (set up by inetd)
     * stdout (fd 1) = the same socket
     *
     * We read data and write it back. That is the entire echo protocol.
     * No socket(), bind(), listen(), accept() needed!
     */
    while ((numRead = read(STDIN_FILENO, buf, BUF_SIZE)) > 0) {
        /* Write all bytes back to stdout (=socket) */
        ssize_t written = 0;
        while (written < numRead) {
            ssize_t n = write(STDOUT_FILENO,
                              buf + written,
                              numRead - written);
            if (n <= 0)
                return EXIT_FAILURE;
            written += n;
        }
    }

    /*
     * numRead == 0: client closed connection — normal exit.
     * numRead == -1: read error.
     */
    return (numRead == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}

xinetd — The Modern Replacement

The original inetd is simple but lacks security features. Most modern Linux distributions use xinetd (extended inetd) instead. xinetd adds:

xinetd Configuration Format

xinetd uses a different configuration format from inetd — each service gets its own block in /etc/xinetd.d/:

# /etc/xinetd.d/echo-stream
# xinetd configuration for TCP echo service

service echo
{
    type            = INTERNAL          # handled inside xinetd
    id              = echo-stream       # unique ID
    socket_type     = stream            # TCP
    protocol        = tcp
    user            = root
    wait            = no                # nowait for TCP
    disable         = no                # enable this service
}

# Example of an external service with access control:
# /etc/xinetd.d/my-service
service my_service
{
    socket_type     = stream
    protocol        = tcp
    wait            = no
    user            = nobody            # run as unprivileged user
    server          = /usr/local/bin/my_server
    server_args     = -v
    only_from       = 192.168.1.0/24   # only allow local subnet
    instances       = 10               # max 10 simultaneous connections
    per_source      = 3                # max 3 connections per source IP
    log_on_success  = HOST DURATION    # log on successful connection
    log_on_failure  = HOST             # log on rejected connection
    disable         = no
}

Modern Alternative: systemd Socket Activation

On modern Linux systems (virtually all major distributions since ~2012), systemd has replaced both inetd and xinetd with a feature called socket activation. The concept is the same — listen on a port, launch the server on demand — but integrated into systemd’s service management framework.

# /etc/systemd/system/echo.socket
[Unit]
Description=Echo Service Socket

[Socket]
ListenStream=7         # TCP port 7
Accept=yes             # spawn a new service instance per connection

[Install]
WantedBy=sockets.target


# /etc/systemd/system/echo@.service
[Unit]
Description=Echo Service Instance
Requires=echo.socket

[Service]
Type=simple
ExecStart=/usr/local/bin/simple_echo_inetd   # same inetd-style program!
StandardInput=socket      # stdin is the accepted socket
StandardOutput=socket     # stdout is the accepted socket

inetd vs xinetd vs systemd — Quick Comparison

Interview Questions & Answers