New option --traceroute to send a traceroute with fping

gsnw-sebast · gsnw-sebast · commit 3d057ad749b7 · 2026-01-06T17:09:32.000+01:00
diff --git a/doc/fping.pod b/doc/fping.pod
@@ -165,6 +165,14 @@ the local receive time in the same format, in addition to normal output.
 Cannot be used together with B<-b> because ICMP timestamp messages have a fixed size.
 IPv4 only, requires root privileges or cap_net_raw.
 
+=item B<--traceroute>
+
+Sends a traceroute based on ICMP echo request. Root privileges are required and only one host is allowed.
+
+Example usage:
+
+$: fping --traceroute 127.0.0.1
+
 =item B<-J>, B<--json>
 
 Format output JSON (-c, -C, or -l required)
diff --git a/src/fping.c b/src/fping.c
@@ -168,6 +168,10 @@ extern int h_errno;
 #define RESP_ERROR -3
 #define RESP_TIMEOUT -4
 
+/* Traceroute */
+#define TRACEROUTE_DEFAULT_MAX_TTL 30
+#define TRACEROUTE_DONE_TTL 100
+
 /* debugging flags */
 #if defined(DEBUG) || defined(_DEBUG)
 #define DBG_TRACE 1
@@ -297,6 +301,7 @@ typedef struct host_entry {
     int64_t min_reply_i; /* shortest response time */
     int64_t total_time_i; /* sum of response times */
     int64_t *resp_times; /* individual response times */
+    int trace_ttl; /* current traceroute ttl */
 
     /* to avoid allocating two struct events each time that we send a ping, we
      * preallocate here two struct events for each ping that we might send for
@@ -423,6 +428,7 @@ int timestamp_flag = 0;
 int timestamp_format_flag = 0;
 int random_data_flag = 0;
 int cumulative_stats_flag = 0;
+int traceroute_flag = 0;
 int check_source_flag = 0;
 int icmp_request_typ = 0;
 int print_tos_flag = 0;
@@ -486,6 +492,7 @@ void stats_add(HOST_ENTRY *h, int index, int success, int64_t latency);
 void update_current_time();
 void print_timestamp_format(int64_t current_time_ns, int timestamp_format);
 static uint32_t ms_since_midnight_utc(int64_t time_val);
+void handle_traceroute_hop(HOST_ENTRY *h, const char *ip_str, int reached_destination, int64_t this_reply);
 
 /************************************************************
 
@@ -642,6 +649,7 @@ int main(int argc, char **argv)
         { "rdns", 'd', OPTPARSE_NONE },
         { "timestamp", 'D', OPTPARSE_NONE },
         { "timestamp-format", '0', OPTPARSE_REQUIRED },
+        { "traceroute", '0', OPTPARSE_NONE },
         { "elapsed", 'e', OPTPARSE_NONE },
         { "file", 'f', OPTPARSE_REQUIRED },
         { "generate", 'g', OPTPARSE_NONE },
@@ -698,6 +706,8 @@ int main(int argc, char **argv)
                 }else{
                   usage(1);
                 }
+            } else if (strcmp(optparse_state.optlongname, "traceroute") == 0) {
+                traceroute_flag = 1;
             } else if (strstr(optparse_state.optlongname, "check-source") != NULL) {
                 check_source_flag = 1;
             } else if (strstr(optparse_state.optlongname, "icmp-timestamp") != NULL) {
@@ -1092,6 +1102,26 @@ int main(int argc, char **argv)
         exit(1);
     }
 
+    if (traceroute_flag && (count_flag || loop_flag || netdata_flag || quiet_flag || stats_flag || timestamp_flag || json_flag)) {
+        fprintf(stderr, "%s: can't combine --traceroute with -c, -C, -l, -N, -q, -Q, -s, -D or -J\n", prog);
+        exit(1);
+    }
+
+    if (traceroute_flag) {
+#ifdef __linux__
+        if (using_sock_dgram4) {
+            fprintf(stderr, "%s: traceroute mode requires raw sockets (run as root)\n", prog);
+            exit(1);
+        }
+#endif
+        if (ttl == 0) {
+            ttl = TRACEROUTE_DEFAULT_MAX_TTL; /* Default traceroute limit */
+        } else if (ttl > TRACEROUTE_DEFAULT_MAX_TTL) {
+            fprintf(stderr, "%s: traceroute ttl max is 30, clamping.\n", prog);
+            ttl = TRACEROUTE_DEFAULT_MAX_TTL;
+        }
+    }
+
     if (interval < (float)MIN_INTERVAL_MS * 1000000 && getuid()) {
         fprintf(stderr, "%s: -i must be >= %g\n", prog, (float)MIN_INTERVAL_MS);
         exit(1);
@@ -1138,6 +1168,9 @@ int main(int argc, char **argv)
 
     trials = (count > retry + 1) ? count : retry + 1;
 
+    if (traceroute_flag)
+        trials = ttl; /* Ensure enough space for up to 'ttl' hops */
+
     /* auto-tune default timeout for count/loop modes
      * see also github #32 */
     if (loop_flag || count_flag) {
@@ -1270,7 +1303,7 @@ int main(int argc, char **argv)
     if (count_flag) {
         event_storage_count = count;
     }
-    else if (loop_flag) {
+    else if (loop_flag || traceroute_flag) {
         if (perhost_interval > timeout) {
             event_storage_count = 1;
         }
@@ -1403,6 +1436,14 @@ int main(int argc, char **argv)
         exit(num_noaddress ? 2 : 1);
     }
 
+    if(traceroute_flag) {
+      /* Preventing race conditions: Only one host allowed */
+      if (num_hosts > 1) {
+          fprintf(stderr, "%s: traceroute mode only supports one target at a time\n", prog);
+          exit(1);
+      }
+    }
+
     if (socket4 >= 0 && (src_addr_set || socktype4 == SOCK_DGRAM)) {
         socket_set_src_addr_ipv4(socket4, &src_addr, (socktype4 == SOCK_DGRAM) ? &ident4 : NULL);
     }
@@ -1461,6 +1502,26 @@ int main(int argc, char **argv)
 
     seqmap_init(seqmap_timeout);
 
+    /* Traceroute header output */
+    if (traceroute_flag) {
+        int i;
+        for (i = 0; i < num_hosts; i++) {
+            HOST_ENTRY *h = table[i];
+            char ip_str[INET6_ADDRSTRLEN];
+            int total_len = ping_data_size + SIZE_ICMP_HDR;
+
+            /* Resolve IP string and calculate header length */
+            getnameinfo((struct sockaddr *)&h->saddr, h->saddr_len, ip_str, sizeof(ip_str), NULL, 0, NI_NUMERICHOST);
+
+            if (h->saddr.ss_family == AF_INET6)
+                total_len += 40; /* IPv6 Header fix 40 bytes */
+            else
+                total_len += SIZE_IP_HDR; /* IPv4 Header min 20 bytes */
+            
+            printf("fping traceroute to %s (%s), %d hops max, %d byte packets\n", h->name, ip_str, (int)ttl, total_len);
+        }
+    }
+
     /* main loop */
     main_loop();
 
@@ -1791,6 +1852,14 @@ void main_loop()
 
             stats_add(h, event->ping_index, 0, -1);
 
+            if (traceroute_flag) {
+                printf("%s: hop %d no reply\n", h->host, h->trace_ttl);
+                h->trace_ttl++;
+                if (h->trace_ttl > (int)ttl) h->trace_ttl = (int)ttl;
+                /* Continue to the next hop, no retry for this hop */
+                continue;
+            }
+
             if (per_recv_flag) {
                 print_timeout(h, event->ping_index);
             }
@@ -1825,11 +1894,33 @@ void main_loop()
 
             dbg_printf("%s [%d]: ping event\n", h->host, event->ping_index);
 
+            /* Traceroute */
+            if (traceroute_flag) {
+                if (h->trace_ttl == TRACEROUTE_DONE_TTL) {
+                    continue;
+                }
+
+                int ttl_set = h->trace_ttl;
+                if (ttl_set > (int)ttl) ttl_set = (int)ttl;
+                if (socket4 >= 0) {
+                    if (setsockopt(socket4, IPPROTO_IP, IP_TTL, &ttl_set, sizeof(ttl_set)))
+                        perror("setsockopt IP_TTL");
+                }
+#ifdef IPV6
+                if (socket6 >= 0) {
+                    /* Set hop limit for IPv6 */
+                    if (setsockopt(socket6, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl_set, sizeof(ttl_set))) {
+                        perror("setsockopt IPV6_UNICAST_HOPS");
+                    }
+                }
+#endif
+            }
+
             /* Send the ping */
             send_ping(h, event->ping_index);
 
-            /* Loop and count mode: schedule next ping */
-            if (loop_flag || (count_flag && event->ping_index + 1 < count)) {
+            /* Loop, count and traceroute mode: schedule next ping */
+            if (loop_flag || (count_flag && event->ping_index + 1 < count) || (traceroute_flag && h->trace_ttl < (int)ttl)) {
                 host_add_ping_event(h, event->ping_index + 1, event->ev_time + perhost_interval);
             }
         }
@@ -2986,6 +3077,31 @@ int decode_icmp_ipv4(
 
     icp = (struct icmp *)(reply_buf + hlen);
 
+    if (traceroute_flag && icp->icmp_type == ICMP_TIMXCEED) {
+        struct ip *inner_ip;
+        int inner_hlen;
+        struct icmp *inner_icmp;
+
+        if (reply_buf_len >= hlen + ICMP_MINLEN + sizeof(struct ip) + ICMP_MINLEN) {
+            inner_ip = (struct ip *) (reply_buf + hlen + ICMP_MINLEN);
+            inner_hlen = inner_ip->ip_hl << 2;
+
+            if (inner_hlen < sizeof(struct ip)) {
+                /* Invalid inner IP header length */
+                return -1;
+            }
+
+            if (reply_buf_len >= hlen + ICMP_MINLEN + inner_hlen + ICMP_MINLEN) {
+                inner_icmp = (struct icmp *) ((char *)inner_ip + inner_hlen);
+                if (inner_icmp->icmp_id == ident4) {
+                    *id = inner_icmp->icmp_id;
+                    *seq = ntohs(inner_icmp->icmp_seq);
+                    return hlen;
+                }
+            }
+        }
+    }
+
     if ((icmp_request_typ == 0 && icp->icmp_type != ICMP_ECHOREPLY) ||
         (icmp_request_typ == 13 && icp->icmp_type != ICMP_TSTAMPREPLY)) {
         /* Handle other ICMP packets */
@@ -3097,6 +3213,27 @@ int decode_icmp_ipv6(
 
     icp = (struct icmp6_hdr *)reply_buf;
 
+    /* Traceroute Logic for IPv6 Time Exceeded */
+    if (traceroute_flag && icp->icmp6_type == ICMP6_TIME_EXCEEDED) {
+        struct ip6_hdr *inner_ip6;
+        struct icmp6_hdr *inner_icmp6;
+
+        if (reply_buf_len >= sizeof(struct icmp6_hdr) + sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr)) {
+            inner_ip6 = (struct ip6_hdr *)(reply_buf + sizeof(struct icmp6_hdr));
+
+            /* Check whether the inner packet is ICMPv6 */
+            if (inner_ip6->ip6_nxt == IPPROTO_ICMPV6) {
+                inner_icmp6 = (struct icmp6_hdr *)(reply_buf + sizeof(struct icmp6_hdr) + sizeof(struct ip6_hdr));
+
+                if (inner_icmp6->icmp6_id == ident6) {
+                    *id = inner_icmp6->icmp6_id;
+                    *seq = ntohs(inner_icmp6->icmp6_seq);
+                    return 1;
+                }
+            }
+        }
+    }
+
     if (icp->icmp6_type != ICMP6_ECHO_REPLY) {
         /* Handle other ICMPv6 packets */
         struct ip6_hdr *sent_ipv6;
@@ -3201,6 +3338,7 @@ int wait_for_reply(int64_t wait_time)
     static char buffer[RECV_BUFSIZE];
     struct sockaddr_storage response_addr;
     int n, avg;
+    int ip_hlen = 0;
     HOST_ENTRY *h;
     int64_t this_reply;
     int this_count;
@@ -3231,7 +3369,7 @@ int wait_for_reply(int64_t wait_time)
 
     /* Process ICMP packet and retrieve id/seq */
     if (response_addr.ss_family == AF_INET) {
-        int ip_hlen = decode_icmp_ipv4(
+        ip_hlen = decode_icmp_ipv4(
             (struct sockaddr *)&response_addr,
             sizeof(response_addr),
             buffer,
@@ -3316,6 +3454,35 @@ int wait_for_reply(int64_t wait_time)
         return 1;
     }
 
+    if (traceroute_flag && response_addr.ss_family == AF_INET) {
+        struct icmp *icp = (struct icmp *)(buffer + ip_hlen);
+        char ip_str[INET_ADDRSTRLEN];
+        getnameinfo((struct sockaddr *)&response_addr, sizeof(response_addr), ip_str, sizeof(ip_str), NULL, 0, NI_NUMERICHOST);
+
+        if (icp->icmp_type == ICMP_TIMXCEED) {
+            handle_traceroute_hop(h, ip_str, 0, this_reply);
+        } else { /* ICMP_ECHOREPLY */
+            handle_traceroute_hop(h, ip_str, 1, this_reply);
+        }
+    }
+#ifdef IPV6
+    else if (traceroute_flag && response_addr.ss_family == AF_INET6) {
+        struct icmp6_hdr *icp = (struct icmp6_hdr *)buffer;
+
+        if (icp->icmp6_type == ICMP6_TIME_EXCEEDED || icp->icmp6_type == ICMP6_ECHO_REPLY) {
+            /* With IPv6, buffer is directly the ICMP header payload, since receive_packet uses recvmsg */
+            char ip_str[INET6_ADDRSTRLEN];
+            getnameinfo((struct sockaddr *)&response_addr, sizeof(response_addr), ip_str, sizeof(ip_str), NULL, 0, NI_NUMERICHOST);
+
+            if (icp->icmp6_type == ICMP6_TIME_EXCEEDED) {
+                handle_traceroute_hop(h, ip_str, 0, this_reply);
+            } else { /* ICMP6_ECHO_REPLY */
+                handle_traceroute_hop(h, ip_str, 1, this_reply);
+            }
+        }
+    }
+#endif
+
     /* update stats */
     stats_add(h, this_count, 1, this_reply);
     // TODO: move to stats_add?
@@ -3335,6 +3502,10 @@ int wait_for_reply(int64_t wait_time)
         ev_remove(&event_queue_timeout, timeout_event);
     }
 
+    if (traceroute_flag) {
+      return 1;
+    }
+
     /* print "is alive" */
     if (h->num_recv == 1) {
         num_alive++;
@@ -3527,6 +3698,7 @@ void add_addr(char *name, char *host, struct sockaddr *ipaddr, socklen_t ipaddr_
     p->saddr_len = ipaddr_len;
     p->timeout = timeout;
     p->min_reply = 0;
+    p->trace_ttl = 1;
 
     if (netdata_flag) {
         char *s = p->name;
@@ -3887,6 +4059,40 @@ static uint32_t ms_since_midnight_utc(int64_t time_val)
     return (uint32_t)((time_val / 1000000) % (24 * 60 * 60 * 1000));
 }
 
+/************************************************************
+
+  Function: handle_traceroute_hop
+
+*************************************************************
+
+  Input:
+    h:                    host entry
+    ip_str:               textual IP of reply source
+    reached_destination:  non-zero if destination was reached
+    this_reply:           reply latency in ns
+
+  Desciption:
+
+  A small helper to centralize printing and TTL handling for
+  traceroute replies (both IPv4 and IPv6). This reduces code
+  duplication and keeps behaviour consistent.
+
+*************************************************************/
+
+void handle_traceroute_hop(HOST_ENTRY *h, const char *ip_str, int reached_destination, int64_t this_reply)
+{
+    if (reached_destination) {
+        printf("%s: hop %d reached DESTINATION %s (%s ms)\n", h->host, h->trace_ttl, ip_str, sprint_tm(this_reply));
+        h->trace_ttl = TRACEROUTE_DONE_TTL; /* Goal achieved: artificially increase TTL to stop loop in main_loop */
+    } else {
+        printf("%s: hop %d reached %s (%s ms)\n", h->host, h->trace_ttl, ip_str, sprint_tm(this_reply));
+        h->trace_ttl++;
+        if (h->trace_ttl > (int)ttl) {
+            h->trace_ttl = (int)ttl;
+        }
+    }
+}
+
 /************************************************************
 
   Function: usage
@@ -3937,6 +4143,7 @@ void usage(int is_error)
     fprintf(out, "                      except with -l/-c/-C, where it's the -p period up to 2000 ms)\n");
     fprintf(out, "       --check-source discard replies not from target address\n");
     fprintf(out, "       --icmp-timestamp use ICMP Timestamp instead of ICMP Echo\n");
+    fprintf(out, "       --traceroute   Sends a traceroute based on ICMP echo request (Only one host is allowed)\n");
     fprintf(out, "\n");
     fprintf(out, "Output options:\n");
     fprintf(out, "   -a, --alive        show targets that are alive\n");
