A high-performance, dependency-free traceroute implementation in pure C.

• Fully non-blocking architecture driven by poll() for faster ICMP draining
• Monotonic timing pipeline for sub-millisecond RTT accuracy
• Runtime tuning via CLI flags for hops, probes, concurrency, and timeouts
• Reverse DNS cache with optional suppression (-n) to optimise lookups
• Expanded socket buffers and smarter probe scheduling for lower latency traces

Fastrace is a blazingly fast traceroute utility designed for network diagnostics and performance analysis. It maps the route that packets take across an IP network from source to destination, providing detailed timing information and identifying potential bottlenecks or routing issues.

• Zero External Dependencies: Relies solely on standard C libraries and system calls
• Maximum Performance: Event-driven pipeline with parallel probing and non-blocking IO
• Low Memory Footprint: Uses compact data structures with tight allocations sized to the trace
• Dual Socket Implementation: Uses UDP for probes and raw sockets for response capture
• Visual Route Mapping: Displays network topology with a structured, tree-like representation
• Runtime Tunability: Allows hop count, probe volume, concurrency, and DNS behaviour to be adjusted live

Fastrace uses two socket types for maximum effectiveness:

• UDP socket (SOCK_DGRAM) for sending probe packets
• Raw ICMP socket (SOCK_RAW) for receiving router responses

send_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
recv_sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);

Each probe is tracked using a specialized structure:

typedef struct {
    int ttl;                /* Time-to-Live value */
    int probe;              /* Probe sequence number */
    struct timeval sent_time; /* Timestamp when sent */
    int received;           /* Whether response was received */
    struct in_addr addr;    /* Address of responding hop */
    double rtt;             /* Round-trip time in ms */
    int port;              /* UDP port used for this probe */
} probe_t;

Fastrace implements a configurable multi-TTL probing system that keeps several hops "in flight" simultaneously. The concurrency window can be tuned at runtime (-c <count>), enabling the tracer to saturate available ICMP feedback channels without overwhelming links.

The response processor relies on a poll()-driven event loop and non-blocking sockets to eagerly drain ICMP bursts while avoiding idle busy-waiting:

struct pollfd pfd = { .fd = recv_sock, .events = POLLIN | POLLERR };
if (poll(&pfd, 1, config.wait_timeout_ms) > 0) {
    drain_icmp_socket();
}

Fastrace implements precise handling of network protocols:

• UDP Probes: Sending UDP packets with incrementing TTL values
• TTL Management: Systematic incrementing of TTL values to discover route hops
• ICMP Response Processing: Parsing ICMP responses from routers
• Port-based Probe Identification: Using unique ports to match responses to probes

Fastrace provides a structured visual representation of network paths:

• Tree-like format shows branching at load-balanced routes
• Clear arrows indicate path progression
• Distinct formatting for primary and alternative routes

Non-blocking sockets combined with poll() wakeups eliminate unnecessary sleeps and react instantly to bursts of ICMP replies.

Probe cadence is tuned via config.probe_delay_us and the runtime -q option, letting users increase sample density when needed without recompilation.

clock_gettime(CLOCK_MONOTONIC) powers RTT measurements and hop deadlines, delivering microsecond precision unaffected by system clock changes.

Designed to be compiled with aggressive optimization flags:

gcc -O3 -o fastrace fastrace.c

A lightweight reverse DNS cache prevents repeated PTR lookups for load-balanced hops, cutting latency and reducing resolver load.

Fastrace significantly outperforms standard traceroute in several key metrics:

• Operating System: Linux, macOS, or other Unix-like systems with raw socket support
• Permissions: Root/sudo access required (raw sockets)
• Compiler: GCC with C99 support or later
• Architecture: x86, x86_64, ARM, or any platform with standard C library support

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netinet/udp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>

The project includes a Makefile for easy compilation and installation:

# Standard optimized build
make

# Build with debugging symbols
make debug

# Build with maximum performance optimizations
make optimized

# Install to system (default: /usr/local/bin)
sudo make install

# Uninstall from system
sudo make uninstall

# Clean build artifacts
make clean

If you prefer not to use the Makefile, you can compile directly:

gcc -O3 -o fastrace fastrace.c

For maximum performance:

gcc -O3 -march=native -mtune=native -flto -o fastrace fastrace.c

For debugging:

gcc -g -O0 -Wall -Wextra -o fastrace_debug fastrace.c

Example:

sudo ./fastrace google.com

Tracing route to google.com (172.217.168.46)
Maximum hops: 30, Protocol: UDP
TTL │ IP Address         (RTT ms)   Hostname
────┼─────────────────────────────────────────
1   │→ 192.168.1.1      (  2.58 ms) router.local
2   │→ * * * (timeout)
3   │→ * * * (timeout)
4   │→ 37.26.81.21      ( 88.01 ms)
5   │→ 79.140.91.10     ( 31.21 ms)
6   │→ 195.22.202.203   ( 38.73 ms)
7   │→ 72.14.209.224    ( 60.76 ms)
      └→ 72.14.223.184   ( 61.65 ms)
8   │→ 142.251.244.109  ( 59.57 ms)
      └→ 216.239.62.49   ( 71.36 ms)
      └→ 142.250.210.95  ( 70.25 ms)
9   │→ 142.251.247.141  ( 59.79 ms)
      └→ 142.251.52.85   ( 60.25 ms)
      └→ 209.85.243.245  ( 62.33 ms)
10  │→ 34.8.172.215     ( 62.42 ms) 215.172.8.34.bc.googleusercontent.com

This visual format shows:

• Primary routes with horizontal arrows (→)
• Alternative/branching paths with indented branch indicators (└→)
• Precise RTT measurements for each hop
• Hostname resolution where available
• Clear visualization of load-balanced paths

The Time-to-Live (TTL) field in the IP header is systematically incremented to discover each router along the path. Each probe uses a unique UDP port derived from its TTL and probe index, allowing responses to be matched instantly.

Probes are uniquely identified by using a different UDP port for each probe:

int port = BASE_PORT + (ttl * NUM_PROBES) + probe_num;

This allows accurate matching of responses to their corresponding probes.

RTT measurements now rely on the monotonic clock, protecting calculations from user/system time adjustments while preserving microsecond resolution.

Reverse DNS lookups are cached for the lifetime of the run. Use -n to disable lookups entirely when only IP addresses are required.

Each probe uses a unique UDP port to identify it:

int port = BASE_PORT + (ttl * NUM_PROBES) + probe_num;

Received when a packet's TTL expires, containing the original UDP header:

if (icmp->icmp_type == ICMP_TIME_EXCEEDED) {
    /* Extract original UDP header and match by port */
}

Received when reaching the destination port (indicating target reached):

if (icmp->icmp_type == ICMP_DEST_UNREACH && icmp->icmp_code == ICMP_PORT_UNREACH) {
    /* Process port unreachable message */
}

Fastrace implements robust error handling:

• Socket Creation Failures: Proper detection and reporting
• Send/Receive Errors: Graceful handling with appropriate error messages
• Hostname Resolution Failures: Fallback to IP address display
• Signal Handling: Clean termination on interrupts (SIGINT)

void handle_signal(int sig) {
    if (sig == SIGINT) {
        printf("\nTraceroute interrupted.\n");
        finished = 1;
        cleanup();
        exit(0);
    }
}

Fastrace maintains a minimal memory footprint:

• Static Allocation: Pre-allocated probe tracking array
• Limited Dynamic Allocation: Used only for hostname resolution
• Proper Cleanup: Resources are freed upon completion or interruption

• Root Privileges: Required for raw socket operations
• Input Validation: Proper validation of command-line arguments
• Buffer Management: Fixed-size buffers with bounds checking

Contributions are welcome! Key areas for potential enhancement:

1. IPv6 Support: Extend to support IPv6 tracerouting
2. TCP Probing: Add alternative probe methods for bypassing UDP-filtered routes
3. Statistical Analysis: Enhanced RTT variance and packet loss reporting
4. Visualization: Text-based route visualization capabilities

This project is licensed under the BSD-2 License - see the LICENSE file for details.

Copyright © 2025 Davide Santangelo

• Based on the principles of Van Jacobson's traceroute algorithm
• Inspired by modern high-performance network diagnostic tools