astraceroute.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2011 - 2013 Daniel Borkmann.
   4  * Subject to the GPL, version 2.
   5  *
   6  *   The road must be trod, but it will be very hard. And neither strength nor
   7  *   wisdom will carry us far upon it. This quest may be attempted by the weak
   8  *   with as much hope as the strong. Yet such is oft the course of deeds that
   9  *   move the wheels of the world: small hands do them because they must,
  10  *   while the eyes of the great are elsewhere.
  11  *
  12  *     -- The Lord of the Rings, Elrond, Chapter 'The Council of Elrond'.
  13  */
  14
  15 #define _BSD_SOURCE
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <signal.h>
  19 #include <getopt.h>
  20 #include <ctype.h>
  21 #include <stdint.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <sys/socket.h>
  25 #include <sys/fsuid.h>
  26 #include <fcntl.h>
  27 #include <time.h>
  28 #include <string.h>
  29 #include <asm/byteorder.h>
  30 #include <linux/tcp.h>
  31 #include <netinet/ip.h>
  32 #include <netinet/ip6.h>
  33 #include <netinet/in.h>
  34 #include <errno.h>
  35 #include <netdb.h>
  36 #include <sys/time.h>
  37 #include <arpa/inet.h>
  38 #include <linux/if_ether.h>
  39 #include <linux/icmp.h>
  40 #include <linux/icmpv6.h>
  41
  42 #include "bpf.h"
  43 #include "die.h"
  44 #include "tprintf.h"
  45 #include "pkt_buff.h"
  46 #include "proto.h"
  47 #include "xmalloc.h"
  48 #include "xio.h"
  49 #include "csum.h"
  50 #include "geoip.h"
  51 #include "xutils.h"
  52 #include "ring_rx.h"
  53 #include "built_in.h"
  54
  55 struct ctx {
  56         char *host, *port, *dev, *payload;
  57         int init_ttl, max_ttl, dns_resolv, queries, timeout, totlen, rcvlen;
  58         int syn, ack, ecn, fin, psh, rst, urg, tos, nofrag, proto, show;
  59         int sd_len, dport, latitude;
  60 };
  61
  62 struct proto_ops {
  63         int (*assembler)(uint8_t *packet, size_t len, int ttl, int proto,
  64                          const struct ctx *ctx, const struct sockaddr *dst,
  65                          const struct sockaddr *src);
  66         const struct sock_filter *filter;
  67         unsigned int flen;
  68         unsigned int min_len_tcp, min_len_icmp;
  69         int (*check)(uint8_t *packet, size_t len, int ttl, int id,
  70                      const struct sockaddr *src);
  71         void (*handler)(uint8_t *packet, size_t len, int dns_resolv,
  72                         int latitude);
  73 };
  74
  75 sig_atomic_t sigint = 0;
  76
  77 static int assemble_ipv4(uint8_t *packet, size_t len, int ttl, int proto,
  78                          const struct ctx *ctx, const struct sockaddr *dst,
  79                          const struct sockaddr *src);
  80 static int assemble_ipv6(uint8_t *packet, size_t len, int ttl, int proto,
  81                          const struct ctx *ctx, const struct sockaddr *dst,
  82                          const struct sockaddr *src);
  83 static int check_ipv4(uint8_t *packet, size_t len, int ttl, int id,
  84                       const struct sockaddr *ss);
  85 static void handle_ipv4(uint8_t *packet, size_t len, int dns_resolv,
  86                         int latitude);
  87 static int check_ipv6(uint8_t *packet, size_t len, int ttl, int id,
  88                       const struct sockaddr *ss);
  89 static void handle_ipv6(uint8_t *packet, size_t len, int dns_resolv,
  90                         int latitude);
  91
  92 static const char *short_options = "H:p:nNf:m:i:d:q:x:SAEFPURt:Gl:hv46X:ZuL";
  93 static const struct option long_options[] = {
  94         {"host",        required_argument,      NULL, 'H'},
  95         {"port",        required_argument,      NULL, 'p'},
  96         {"init-ttl",    required_argument,      NULL, 'f'},
  97         {"max-ttl",     required_argument,      NULL, 'm'},
  98         {"dev",         required_argument,      NULL, 'd'},
  99         {"num-probes",  required_argument,      NULL, 'q'},
 100         {"timeout",     required_argument,      NULL, 'x'},
 101         {"tos",         required_argument,      NULL, 't'},
 102         {"payload",     required_argument,      NULL, 'X'},
 103         {"totlen",      required_argument,      NULL, 'l'},
 104         {"numeric",     no_argument,            NULL, 'n'},
 105         {"latitude",    no_argument,            NULL, 'L'},
 106         {"update",      no_argument,            NULL, 'u'},
 107         {"dns",         no_argument,            NULL, 'N'},
 108         {"ipv4",        no_argument,            NULL, '4'},
 109         {"ipv6",        no_argument,            NULL, '6'},
 110         {"syn",         no_argument,            NULL, 'S'},
 111         {"ack",         no_argument,            NULL, 'A'},
 112         {"urg",         no_argument,            NULL, 'U'},
 113         {"fin",         no_argument,            NULL, 'F'},
 114         {"psh",         no_argument,            NULL, 'P'},
 115         {"rst",         no_argument,            NULL, 'R'},
 116         {"ecn-syn",     no_argument,            NULL, 'E'},
 117         {"show-packet", no_argument,            NULL, 'Z'},
 118         {"nofrag",      no_argument,            NULL, 'G'},
 119         {"version",     no_argument,            NULL, 'v'},
 120         {"help",        no_argument,            NULL, 'h'},
 121         {NULL, 0, NULL, 0}
 122 };
 123
 124 static const struct sock_filter ipv4_icmp_type_11[] = {
 125         { 0x28, 0, 0, 0x0000000c },     /* ldh [12]             */
 126         { 0x15, 0, 8, 0x00000800 },     /* jneq #0x800, drop    */
 127         { 0x30, 0, 0, 0x00000017 },     /* ldb [23]             */
 128         { 0x15, 0, 6, 0x00000001 },     /* jneq #0x1, drop      */
 129         { 0x28, 0, 0, 0x00000014 },     /* ldh [20]             */
 130         { 0x45, 4, 0, 0x00001fff },     /* jset #0x1fff, drop   */
 131         { 0xb1, 0, 0, 0x0000000e },     /* ldxb 4*([14]&0xf)    */
 132         { 0x50, 0, 0, 0x0000000e },     /* ldb [x + 14]         */
 133         { 0x15, 0, 1, 0x0000000b },     /* jneq #0xb, drop      */
 134         { 0x06, 0, 0, 0xffffffff },     /* ret #-1              */
 135         { 0x06, 0, 0, 0x00000000 },     /* drop: ret #0         */
 136 };
 137
 138 static const struct sock_filter ipv6_icmp6_type_3[] = {
 139         { 0x28, 0, 0, 0x0000000c },     /* ldh [12]             */
 140         { 0x15, 0, 5, 0x000086dd },     /* jneq #0x86dd, drop   */
 141         { 0x30, 0, 0, 0x00000014 },     /* ldb [20]             */
 142         { 0x15, 0, 3, 0x0000003a },     /* jneq #0x3a, drop     */
 143         { 0x30, 0, 0, 0x00000036 },     /* ldb [54]             */
 144         { 0x15, 0, 1, 0x00000003 },     /* jneq #0x3, drop      */
 145         { 0x06, 0, 0, 0xffffffff },     /* ret #-1              */
 146         { 0x06, 0, 0, 0x00000000 },     /* drop: ret #0         */
 147 };
 148
 149 static const struct proto_ops af_ops[] = {
 150         [IPPROTO_IP]    =       {
 151                         .assembler      =       assemble_ipv4,
 152                         .handler        =       handle_ipv4,
 153                         .check          =       check_ipv4,
 154                         .filter         =       ipv4_icmp_type_11,
 155                         .flen           =       array_size(ipv4_icmp_type_11),
 156                         .min_len_tcp    =       sizeof(struct iphdr) + sizeof(struct tcphdr),
 157                         .min_len_icmp   =       sizeof(struct iphdr) + sizeof(struct icmphdr),
 158                 },
 159         [IPPROTO_IPV6]  =       {
 160                         .assembler      =       assemble_ipv6,
 161                         .handler        =       handle_ipv6,
 162                         .check          =       check_ipv6,
 163                         .filter         =       ipv6_icmp6_type_3,
 164                         .flen           =       array_size(ipv6_icmp6_type_3),
 165                         .min_len_tcp    =       sizeof(struct ip6_hdr) + sizeof(struct tcphdr),
 166                         .min_len_icmp   =       sizeof(struct ip6_hdr) + sizeof(struct icmp6hdr),
 167                 },
 168 };
 169
 170 static void signal_handler(int number)
 171 {
 172         switch (number) {
 173         case SIGINT:
 174                 sigint = 1;
 175         default:
 176                 break;
 177         }
 178 }
 179
 180 static void help(void)
 181 {
 182         printf("\nastraceroute %s, autonomous system trace route utility\n", VERSION_STRING);
 183         puts("http://www.netsniff-ng.org\n\n"
 184              "Usage: astraceroute [options]\n"
 185              "Options:\n"
 186              " -H|--host <host>        Host/IPv4/IPv6 to lookup AS route to\n"
 187              " -p|--port <port>        Hosts port to lookup AS route to\n"
 188              " -i|-d|--dev <device>    Networking device, e.g. eth0\n"
 189              " -f|--init-ttl <ttl>     Set initial TTL\n"
 190              " -m|--max-ttl <ttl>      Set maximum TTL (def: 30)\n"
 191              " -q|--num-probes <num>   Number of max probes for each hop (def: 2)\n"
 192              " -x|--timeout <sec>      Probe response timeout in sec (def: 3)\n"
 193              " -X|--payload <string>   Specify a payload string to test DPIs\n"
 194              " -l|--totlen <len>       Specify total packet len\n"
 195              " -4|--ipv4               Use IPv4-only requests\n"
 196              " -6|--ipv6               Use IPv6-only requests\n"
 197              " -n|--numeric            Do not do reverse DNS lookup for hops\n"
 198              " -u|--update             Update GeoIP databases\n"
 199              " -L|--latitude           Show latitude and longtitude\n"
 200              " -N|--dns                Do a reverse DNS lookup for hops\n"
 201              " -S|--syn                Set TCP SYN flag\n"
 202              " -A|--ack                Set TCP ACK flag\n"
 203              " -F|--fin                Set TCP FIN flag\n"
 204              " -P|--psh                Set TCP PSH flag\n"
 205              " -U|--urg                Set TCP URG flag\n"
 206              " -R|--rst                Set TCP RST flag\n"
 207              " -E|--ecn-syn            Send ECN SYN packets (RFC3168)\n"
 208              " -t|--tos <tos>          Set the IP TOS field\n"
 209              " -G|--nofrag             Set do not fragment bit\n"
 210              " -Z|--show-packet        Show returned packet on each hop\n"
 211              " -v|--version            Print version\n"
 212              " -h|--help               Print this help\n\n"
 213              "Examples:\n"
 214              "  IPv4 trace of AS with TCP SYN probe (this will most-likely pass):\n"
 215              "    astraceroute -i eth0 -N -S -H netsniff-ng.org\n"
 216              "  IPv4 trace of AS with TCP ECN SYN probe:\n"
 217              "    astraceroute -i eth0 -N -E -H netsniff-ng.org\n"
 218              "  IPv4 trace of AS with TCP FIN probe:\n"
 219              "    astraceroute -i eth0 -N -F -H netsniff-ng.org\n"
 220              "  IPv4 trace of AS with Xmas probe:\n"
 221              "    astraceroute -i eth0 -N -FPU -H netsniff-ng.org\n"
 222              "  IPv4 trace of AS with Null probe with ASCII payload:\n"
 223              "    astraceroute -i eth0 -N -H netsniff-ng.org -X \"censor-me\" -Z\n"
 224              "  IPv6 trace of AS up to www.6bone.net:\n"
 225              "    astraceroute -6 -i eth0 -S -E -N -H www.6bone.net\n\n"
 226              "Note:\n"
 227              "  If the TCP probe did not give any results, then astraceroute will\n"
 228              "  automatically probe for classic ICMP packets! To gather more\n"
 229              "  information about astraceroute's fetched AS numbers, see e.g.\n"
 230              "  http://bgp.he.net/AS<number>!\n\n"
 231              "Please report bugs to <bugs@netsniff-ng.org>\n"
 232              "Copyright (C) 2011-2013 Daniel Borkmann <dborkma@tik.ee.ethz.ch>\n"
 233              "Swiss federal institute of technology (ETH Zurich)\n"
 234              "License: GNU GPL version 2.0\n"
 235              "This is free software: you are free to change and redistribute it.\n"
 236              "There is NO WARRANTY, to the extent permitted by law.\n");
 237         die();
 238 }
 239
 240 static void version(void)
 241 {
 242         printf("\nastraceroute %s, autonomous system trace route utility\n", VERSION_STRING);
 243         puts("http://www.netsniff-ng.org\n\n"
 244              "Please report bugs to <bugs@netsniff-ng.org>\n"
 245              "Copyright (C) 2011-2013 Daniel Borkmann <dborkma@tik.ee.ethz.ch>\n"
 246              "Swiss federal institute of technology (ETH Zurich)\n"
 247              "License: GNU GPL version 2.0\n"
 248              "This is free software: you are free to change and redistribute it.\n"
 249              "There is NO WARRANTY, to the extent permitted by law.\n");
 250         die();
 251 }
 252
 253 static void __assemble_data(uint8_t *packet, size_t len, const char *payload)
 254 {
 255         int i;
 256
 257         if (payload == NULL) {
 258                 for (i = 0; i < len; ++i)
 259                         packet[i] = (uint8_t) rand();
 260         } else {
 261                 int lmin = min(len, strlen(payload));
 262
 263                 for (i = 0; i < lmin; ++i)
 264                         packet[i] = (uint8_t) payload[i];
 265                 for (i = lmin; i < len; ++i)
 266                         packet[i] = (uint8_t) rand();
 267         }
 268 }
 269
 270 static void __assemble_icmp4(uint8_t *packet, size_t len)
 271 {
 272         struct icmphdr *icmph = (struct icmphdr *) packet;
 273
 274         bug_on(len < sizeof(struct icmphdr));
 275
 276         icmph->type = ICMP_ECHO;
 277         icmph->code = 0;
 278         icmph->checksum = 0;
 279 }
 280
 281 static void __assemble_icmp6(uint8_t *packet, size_t len)
 282 {
 283         struct icmp6hdr *icmp6h = (struct icmp6hdr *) packet;
 284
 285         bug_on(len < sizeof(struct icmp6hdr));
 286
 287         icmp6h->icmp6_type = ICMPV6_ECHO_REQUEST;
 288         icmp6h->icmp6_code = 0;
 289         icmp6h->icmp6_cksum = 0;
 290 }
 291
 292 static void __assemble_tcp(uint8_t *packet, size_t len, int syn, int ack,
 293                            int urg, int fin, int rst, int psh, int ecn,
 294                            int dport)
 295 {
 296         struct tcphdr *tcph = (struct tcphdr *) packet;
 297
 298         bug_on(len < sizeof(struct tcphdr));
 299
 300         tcph->source = htons((uint16_t) rand());
 301         tcph->dest = htons((uint16_t) dport);
 302
 303         tcph->seq = htonl(rand());
 304         tcph->ack_seq = (!!ack ? htonl(rand()) : 0);
 305
 306         tcph->doff = 5;
 307
 308         tcph->syn = !!syn;
 309         tcph->ack = !!ack;
 310         tcph->urg = !!urg;
 311         tcph->fin = !!fin;
 312         tcph->rst = !!rst;
 313         tcph->psh = !!psh;
 314         tcph->ece = !!ecn;
 315         tcph->cwr = !!ecn;
 316
 317         tcph->window = htons((uint16_t) (100 + (rand() % 65435)));
 318         tcph->urg_ptr = (!!urg ? htons((uint16_t) rand()) :  0);
 319         tcph->check = 0;
 320 }
 321
 322 static int assemble_ipv4(uint8_t *packet, size_t len, int ttl, int proto,
 323                          const struct ctx *ctx, const struct sockaddr *dst,
 324                          const struct sockaddr *src)
 325 {
 326         uint8_t *data;
 327         size_t data_len, off_next = 0;
 328         struct iphdr *iph = (struct iphdr *) packet;
 329
 330         bug_on(!src || !dst);
 331         bug_on(src->sa_family != PF_INET || dst->sa_family != PF_INET);
 332         bug_on(len < sizeof(*iph) + min(sizeof(struct tcphdr),
 333                                         sizeof(struct icmphdr)));
 334
 335         iph->ihl = 5;
 336         iph->version = 4;
 337         iph->tos = (uint8_t) ctx->tos;
 338
 339         iph->tot_len = htons((uint16_t) len);
 340         iph->id = htons((uint16_t) rand());
 341
 342         iph->frag_off = ctx->nofrag ? IP_DF : 0;
 343         iph->ttl = (uint8_t) ttl;
 344
 345         iph->saddr = ((const struct sockaddr_in *) src)->sin_addr.s_addr;
 346         iph->daddr = ((const struct sockaddr_in *) dst)->sin_addr.s_addr;
 347
 348         iph->protocol = (uint8_t) proto;
 349
 350         data = packet + sizeof(*iph);
 351         data_len = len - sizeof(*iph);
 352
 353         switch (proto) {
 354         case IPPROTO_TCP:
 355                 __assemble_tcp(data, data_len, ctx->syn, ctx->ack, ctx->urg,
 356                                ctx->fin, ctx->rst, ctx->psh, ctx->ecn, ctx->dport);
 357                 off_next = sizeof(struct tcphdr);
 358                 break;
 359         case IPPROTO_ICMP:
 360                 __assemble_icmp4(data, data_len);
 361                 off_next = sizeof(struct icmphdr);
 362                 break;
 363         default:
 364                 bug();
 365         }
 366
 367         data = packet + sizeof(*iph) + off_next;
 368         data_len = len - sizeof(*iph) - off_next;
 369
 370         __assemble_data(data, data_len, ctx->payload);
 371
 372         iph->check = csum((unsigned short *) packet, ntohs(iph->tot_len) >> 1);
 373
 374         return ntohs(iph->id);
 375 }
 376
 377 static int assemble_ipv6(uint8_t *packet, size_t len, int ttl, int proto,
 378                          const struct ctx *ctx, const struct sockaddr *dst,
 379                          const struct sockaddr *src)
 380 {
 381         uint8_t *data;
 382         size_t data_len, off_next = 0;
 383         struct ip6_hdr *ip6h = (struct ip6_hdr *) packet;
 384
 385         bug_on(!src || !dst);
 386         bug_on(src->sa_family != PF_INET6 || dst->sa_family != PF_INET6);
 387         bug_on(len < sizeof(*ip6h) + min(sizeof(struct tcphdr),
 388                                          sizeof(struct icmp6hdr)));
 389
 390         ip6h->ip6_flow = htonl(rand() & 0x000fffff);
 391         ip6h->ip6_vfc = 0x60;
 392
 393         ip6h->ip6_plen = htons((uint16_t) len - sizeof(*ip6h));
 394         ip6h->ip6_nxt = (uint8_t) proto;
 395         ip6h->ip6_hlim = (uint8_t) ttl;
 396
 397         memcpy(&ip6h->ip6_src, &(((const struct sockaddr_in6 *)
 398                src)->sin6_addr), sizeof(ip6h->ip6_src));
 399         memcpy(&ip6h->ip6_dst, &(((const struct sockaddr_in6 *)
 400                dst)->sin6_addr), sizeof(ip6h->ip6_dst));
 401
 402         data = packet + sizeof(*ip6h);
 403         data_len = len - sizeof(*ip6h);
 404
 405         switch (proto) {
 406         case IPPROTO_TCP:
 407                 __assemble_tcp(data, data_len, ctx->syn, ctx->ack, ctx->urg,
 408                                ctx->fin, ctx->rst, ctx->psh, ctx->ecn, ctx->dport);
 409                 off_next = sizeof(struct tcphdr);
 410                 break;
 411         case IPPROTO_ICMP:
 412         case IPPROTO_ICMPV6:
 413                 __assemble_icmp6(data, data_len);
 414                 off_next = sizeof(struct icmp6hdr);
 415                 break;
 416         default:
 417                 bug();
 418         }
 419
 420         data = packet + sizeof(*ip6h) + off_next;
 421         data_len = len - sizeof(*ip6h) - off_next;
 422
 423         __assemble_data(data, data_len, ctx->payload);
 424
 425         return ntohl(ip6h->ip6_flow) & 0x000fffff;
 426 }
 427
 428 static int check_ipv4(uint8_t *packet, size_t len, int ttl, int id,
 429                       const struct sockaddr *ss)
 430 {
 431         struct iphdr *iph = (struct iphdr *) packet;
 432         struct iphdr *iph_inner;
 433         struct icmphdr *icmph;
 434
 435         if (iph->protocol != IPPROTO_ICMP)
 436                 return -EINVAL;
 437         if (iph->daddr != ((const struct sockaddr_in *) ss)->sin_addr.s_addr)
 438                 return -EINVAL;
 439
 440         icmph = (struct icmphdr *) (packet + sizeof(struct iphdr));
 441         if (icmph->type != ICMP_TIME_EXCEEDED)
 442                 return -EINVAL;
 443         if (icmph->code != ICMP_EXC_TTL)
 444                 return -EINVAL;
 445
 446         iph_inner = (struct iphdr *) (packet + sizeof(struct iphdr) +
 447                                       sizeof(struct icmphdr));
 448         if (ntohs(iph_inner->id) != id)
 449                 return -EINVAL;
 450
 451         return len;
 452 }
 453
 454 static void handle_ipv4(uint8_t *packet, size_t len, int dns_resolv, int latitude)
 455 {
 456         char hbuff[256];
 457         struct iphdr *iph = (struct iphdr *) packet;
 458         struct sockaddr_in sd;
 459         struct hostent *hent;
 460         const char *as, *country, *city;
 461
 462         memset(hbuff, 0, sizeof(hbuff));
 463         memset(&sd, 0, sizeof(sd));
 464         sd.sin_family = PF_INET;
 465         sd.sin_addr.s_addr = iph->saddr;
 466
 467         getnameinfo((struct sockaddr *) &sd, sizeof(sd),
 468                     hbuff, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
 469
 470         as = geoip4_as_name(sd);
 471         country = geoip4_country_name(sd);
 472         city = geoip4_city_name(sd);
 473
 474         if (dns_resolv) {
 475                 hent = gethostbyaddr(&sd.sin_addr, sizeof(sd.sin_addr), PF_INET);
 476                 if (hent)
 477                         printf(" %s (%s)", hent->h_name, hbuff);
 478                 else
 479                         printf(" %s", hbuff);
 480         } else {
 481                 printf(" %s", hbuff);
 482         }
 483         if (as)
 484                 printf(" in %s", as);
 485         if (country) {
 486                 printf(" in %s", country);
 487                 if (city)
 488                         printf(", %s", city);
 489         }
 490         if (latitude)
 491                 printf(" (%f/%f)", geoip4_latitude(sd), geoip4_longitude(sd));
 492 }
 493
 494 static int check_ipv6(uint8_t *packet, size_t len, int ttl, int id,
 495                       const struct sockaddr *ss)
 496 {
 497         struct ip6_hdr *ip6h = (struct ip6_hdr *) packet;
 498         struct ip6_hdr *ip6h_inner;
 499         struct icmp6hdr *icmp6h;
 500
 501         if (ip6h->ip6_nxt != 0x3a)
 502                 return -EINVAL;
 503         if (memcmp(&ip6h->ip6_dst, &(((const struct sockaddr_in6 *)
 504                    ss)->sin6_addr), sizeof(ip6h->ip6_dst)))
 505                 return -EINVAL;
 506
 507         icmp6h = (struct icmp6hdr *) (packet + sizeof(*ip6h));
 508         if (icmp6h->icmp6_type != ICMPV6_TIME_EXCEED)
 509                 return -EINVAL;
 510         if (icmp6h->icmp6_code != ICMPV6_EXC_HOPLIMIT)
 511                 return -EINVAL;
 512
 513         ip6h_inner = (struct ip6_hdr *) (packet + sizeof(*ip6h) + sizeof(*icmp6h));
 514         if ((ntohl(ip6h_inner->ip6_flow) & 0x000fffff) != id)
 515                 return -EINVAL;
 516
 517         return len;
 518 }
 519
 520 static void handle_ipv6(uint8_t *packet, size_t len, int dns_resolv, int latitude)
 521 {
 522         char hbuff[256];
 523         struct ip6_hdr *ip6h = (struct ip6_hdr *) packet;
 524         struct sockaddr_in6 sd;
 525         struct hostent *hent;
 526         const char *as, *country, *city;
 527
 528         memset(hbuff, 0, sizeof(hbuff));
 529         memset(&sd, 0, sizeof(sd));
 530         sd.sin6_family = PF_INET6;
 531         memcpy(&sd.sin6_addr, &ip6h->ip6_src, sizeof(ip6h->ip6_src));
 532
 533         getnameinfo((struct sockaddr *) &sd, sizeof(sd),
 534                     hbuff, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
 535
 536         as = geoip6_as_name(sd);
 537         country = geoip6_country_name(sd);
 538         city = geoip6_city_name(sd);
 539
 540         if (dns_resolv) {
 541                 hent = gethostbyaddr(&sd.sin6_addr, sizeof(sd.sin6_addr), PF_INET6);
 542                 if (hent)
 543                         printf(" %s (%s)", hent->h_name, hbuff);
 544                 else
 545                         printf(" %s", hbuff);
 546         } else {
 547                 printf(" %s", hbuff);
 548         }
 549         if (as)
 550                 printf(" in %s", as);
 551         if (country) {
 552                 printf(" in %s", country);
 553                 if (city)
 554                         printf(", %s", city);
 555         }
 556         if (latitude)
 557                 printf(" (%f/%f)", geoip6_latitude(sd), geoip6_longitude(sd));
 558 }
 559
 560 static void show_trace_info(struct ctx *ctx, const struct sockaddr_storage *ss,
 561                             const struct sockaddr_storage *sd)
 562 {
 563         char hbuffs[256], hbuffd[256];
 564
 565         memset(hbuffd, 0, sizeof(hbuffd));
 566         getnameinfo((struct sockaddr *) sd, sizeof(*sd),
 567                     hbuffd, sizeof(hbuffd), NULL, 0, NI_NUMERICHOST);
 568
 569         memset(hbuffs, 0, sizeof(hbuffs));
 570         getnameinfo((struct sockaddr *) ss, sizeof(*ss),
 571                     hbuffs, sizeof(hbuffs), NULL, 0, NI_NUMERICHOST);
 572
 573         printf("AS path IPv%d TCP trace from %s to %s:%s (%s) with len %d "
 574                "Bytes, %u max hops\n", ctx->proto == IPPROTO_IP ? 4 : 6,
 575                hbuffs, hbuffd, ctx->port, ctx->host, ctx->totlen, ctx->max_ttl);
 576
 577         printf("Using flags SYN:%d,ACK:%d,ECN:%d,FIN:%d,PSH:%d,RST:%d,URG:%d\n",
 578                ctx->syn, ctx->ack, ctx->ecn, ctx->fin, ctx->psh, ctx->rst, ctx->urg);
 579
 580         if (ctx->payload)
 581                 printf("With payload: \'%s\'\n", ctx->payload);
 582 }
 583
 584 static int get_remote_fd(struct ctx *ctx, struct sockaddr_storage *ss,
 585                          struct sockaddr_storage *sd)
 586 {
 587         int fd = -1, ret, one = 1;
 588         struct addrinfo hints, *ahead, *ai;
 589
 590         memset(&hints, 0, sizeof(hints));
 591         hints.ai_family = PF_UNSPEC;
 592         hints.ai_socktype = SOCK_STREAM;
 593         hints.ai_protocol = IPPROTO_TCP;
 594         hints.ai_flags = AI_NUMERICSERV;
 595
 596         ret = getaddrinfo(ctx->host, ctx->port, &hints, &ahead);
 597         if (ret < 0)
 598                 panic("Cannot get address info!\n");
 599
 600         for (ai = ahead; ai != NULL && fd < 0; ai = ai->ai_next) {
 601                 if (!((ai->ai_family == PF_INET6 && ctx->proto == IPPROTO_IPV6) ||
 602                       (ai->ai_family == PF_INET  && ctx->proto == IPPROTO_IP)))
 603                         continue;
 604
 605                 fd = socket(ai->ai_family, SOCK_RAW, IPPROTO_RAW);
 606                 if (fd < 0)
 607                         continue;
 608
 609                 memset(ss, 0, sizeof(*ss));
 610                 ret = device_address(ctx->dev, ai->ai_family, ss);
 611                 if (ret < 0)
 612                         panic("Cannot get own device address!\n");
 613
 614                 ret = bind(fd, (struct sockaddr *) ss, sizeof(*ss));
 615                 if (ret < 0)
 616                         panic("Cannot bind socket!\n");
 617
 618                 memset(sd, 0, sizeof(*sd));
 619                 memcpy(sd, ai->ai_addr, ai->ai_addrlen);
 620
 621                 ctx->sd_len = ai->ai_addrlen;
 622                 ctx->dport = strtoul(ctx->port, NULL, 10);
 623
 624                 ret = setsockopt(fd, ctx->proto, IP_HDRINCL, &one, sizeof(one));
 625                 if (ret < 0)
 626                         panic("Kernel does not support IP_HDRINCL!\n");
 627
 628                 if (ai->ai_family == PF_INET6) {
 629                         struct sockaddr_in6 *sd6 = (struct sockaddr_in6 *) sd;
 630
 631                         sd6->sin6_port = 0;
 632                 }
 633
 634                 break;
 635         }
 636
 637         freeaddrinfo(ahead);
 638
 639         if (fd < 0)
 640                 panic("Cannot create socket! Does remote "
 641                       "support IPv%d?!\n",
 642                       ctx->proto == IPPROTO_IP ? 4 : 6);
 643
 644         return fd;
 645 }
 646
 647 static void inject_filter(struct ctx *ctx, int fd)
 648 {
 649         struct sock_fprog bpf_ops;
 650
 651         enable_kernel_bpf_jit_compiler();
 652
 653         memset(&bpf_ops, 0, sizeof(bpf_ops));
 654         bpf_ops.filter = (struct sock_filter *) af_ops[ctx->proto].filter;
 655         bpf_ops.len = af_ops[ctx->proto].flen;
 656
 657         bpf_attach_to_sock(fd, &bpf_ops);
 658 }
 659
 660 static int __process_node(struct ctx *ctx, int fd, int fd_cap, int ttl,
 661                           int inner_proto, uint8_t *pkt_snd, uint8_t *pkt_rcv,
 662                           const struct sockaddr_storage *ss,
 663                           const struct sockaddr_storage *sd, struct timeval *diff)
 664 {
 665         int pkt_id, ret, timeout;
 666         struct pollfd pfd;
 667         struct timeval start, end;
 668
 669         prepare_polling(fd_cap, &pfd);
 670
 671         memset(pkt_snd, 0, ctx->totlen);
 672         pkt_id = af_ops[ctx->proto].assembler(pkt_snd, ctx->totlen, ttl,
 673                                               inner_proto, ctx,
 674                                               (const struct sockaddr *) sd,
 675                                               (const struct sockaddr *) ss);
 676
 677         ret = sendto(fd, pkt_snd, ctx->totlen, 0, (struct sockaddr *) sd,
 678                      ctx->sd_len);
 679         if (ret < 0)
 680                 panic("sendto failed: %s\n", strerror(errno));
 681
 682         bug_on(gettimeofday(&start, NULL));
 683
 684         timeout = (ctx->timeout > 0 ? ctx->timeout : 2) * 1000;
 685
 686         ret = poll(&pfd, 1, timeout);
 687         if (ret > 0 && pfd.revents & POLLIN && sigint == 0) {
 688                 bug_on(gettimeofday(&end, NULL));
 689                 if (diff)
 690                         timersub(&end, &start, diff);
 691
 692                 ret = recvfrom(fd_cap, pkt_rcv, ctx->rcvlen, 0, NULL, NULL);
 693                 if (ret < sizeof(struct ethhdr) + af_ops[ctx->proto].min_len_icmp)
 694                         return -EIO;
 695
 696                 return af_ops[ctx->proto].check(pkt_rcv + sizeof(struct ethhdr),
 697                                                 ret - sizeof(struct ethhdr), ttl,
 698                                                 pkt_id, (const struct sockaddr *) ss);
 699         } else {
 700                 return -EIO;
 701         }
 702
 703         return 0;
 704 }
 705
 706 static void timerdiv(const unsigned long divisor, const struct timeval *tv,
 707                      struct timeval *result)
 708 {
 709         uint64_t x = ((uint64_t) tv->tv_sec * 1000 * 1000 + tv->tv_usec) / divisor;
 710
 711         result->tv_sec = x / 1000 / 1000;
 712         result->tv_usec = x % (1000 * 1000);
 713 }
 714
 715 static int timevalcmp(const void *t1, const void *t2)
 716 {
 717         if (timercmp((struct timeval *) t1, (struct timeval *) t2, <))
 718                 return -1;
 719         if (timercmp((struct timeval *) t1, (struct timeval *) t2, >))
 720                 return  1;
 721
 722         return 0;
 723 }
 724
 725 static int __process_time(struct ctx *ctx, int fd, int fd_cap, int ttl,
 726                           int inner_proto, uint8_t *pkt_snd, uint8_t *pkt_rcv,
 727                           const struct sockaddr_storage *ss,
 728                           const struct sockaddr_storage *sd)
 729 {
 730         int good = 0, i, j = 0, ret = -EIO, idx, ret_good = -EIO;
 731         struct timeval probes[9], *tmp, sum, res;
 732         uint8_t *trash = xmalloc(ctx->rcvlen);
 733         char *cwait[] = { "-", "\\", "|", "/" };
 734         const char *proto_short[] = {
 735                 [IPPROTO_TCP]           =       "t",
 736                 [IPPROTO_ICMP]          =       "i",
 737                 [IPPROTO_ICMPV6]        =       "i",
 738         };
 739
 740         memset(probes, 0, sizeof(probes));
 741         for (i = 0; i < array_size(probes) && sigint == 0; ++i) {
 742                 ret = __process_node(ctx, fd, fd_cap, ttl, inner_proto,
 743                                      pkt_snd, good == 0 ? pkt_rcv : trash,
 744                                      ss, sd, &probes[i]);
 745                 if (ret > 0) {
 746                         if (good == 0)
 747                                 ret_good = ret;
 748                         good++;
 749                 }
 750
 751                 if (good == 0 && ctx->queries == i)
 752                         break;
 753
 754                 usleep(50000);
 755
 756                 printf("\r%2d: %s", ttl, cwait[j++]);
 757                 fflush(stdout);
 758                 if (j >= array_size(cwait))
 759                         j = 0;
 760         }
 761
 762         if (good == 0) {
 763                 xfree(trash);
 764                 return -EIO;
 765         }
 766
 767         tmp = xmalloc(sizeof(struct timeval) * good);
 768         for (i = j = 0; i < array_size(probes); ++i) {
 769                 if (probes[i].tv_sec == 0 && probes[i].tv_usec == 0)
 770                         continue;
 771                 tmp[j].tv_sec = probes[i].tv_sec;
 772                 tmp[j].tv_usec = probes[i].tv_usec;
 773                 j++;
 774         }
 775
 776         qsort(tmp, j, sizeof(struct timeval), timevalcmp);
 777
 778         printf("\r%2d: %s[", ttl, proto_short[inner_proto]);
 779         idx = j / 2;
 780         switch (j % 2) {
 781         case 0:
 782                 timeradd(&tmp[idx], &tmp[idx - 1], &sum);
 783                 timerdiv(2, &sum, &res);
 784                 if (res.tv_sec > 0)
 785                         printf("%lu sec ", res.tv_sec);
 786                 printf("%7lu us", res.tv_usec);
 787                 break;
 788         case 1:
 789                 if (tmp[idx].tv_sec > 0)
 790                         printf("%lu sec ", tmp[idx].tv_sec);
 791                 printf("%7lu us", tmp[idx].tv_usec);
 792                 break;
 793         default:
 794                 bug();
 795         }
 796         printf("]");
 797
 798         xfree(tmp);
 799         xfree(trash);
 800
 801         return ret_good;
 802 }
 803
 804 static int __probe_remote(struct ctx *ctx, int fd, int fd_cap, int ttl,
 805                           uint8_t *pkt_snd, uint8_t *pkt_rcv,
 806                           const struct sockaddr_storage *ss,
 807                           const struct sockaddr_storage *sd,
 808                           int inner_proto)
 809 {
 810         int ret = -EIO, tries = ctx->queries;
 811
 812         while (tries-- > 0 && sigint == 0) {
 813                 ret = __process_time(ctx, fd, fd_cap, ttl, inner_proto,
 814                                      pkt_snd, pkt_rcv, ss, sd);
 815                 if (ret < 0)
 816                         continue;
 817
 818                 af_ops[ctx->proto].handler(pkt_rcv + sizeof(struct ethhdr),
 819                                            ret - sizeof(struct ethhdr),
 820                                            ctx->dns_resolv, ctx->latitude);
 821                 if (ctx->show) {
 822                         struct pkt_buff *pkt;
 823
 824                         printf("\n");
 825                         pkt = pkt_alloc(pkt_rcv, ret);
 826                         hex_ascii(pkt);
 827                         tprintf_flush();
 828                         pkt_free(pkt);
 829                 }
 830
 831                 break;
 832         }
 833
 834         return ret;
 835 }
 836
 837 static int __process_ttl(struct ctx *ctx, int fd, int fd_cap, int ttl,
 838                          uint8_t *pkt_snd, uint8_t *pkt_rcv,
 839                          const struct sockaddr_storage *ss,
 840                          const struct sockaddr_storage *sd)
 841 {
 842         int ret = -EIO, i;
 843         const int inner_protos[] = {
 844                 IPPROTO_TCP,
 845                 IPPROTO_ICMP,
 846         };
 847
 848         printf("%2d: ", ttl);
 849         fflush(stdout);
 850
 851         for (i = 0; i < array_size(inner_protos) && sigint == 0; ++i) {
 852                 ret = __probe_remote(ctx, fd, fd_cap, ttl, pkt_snd, pkt_rcv, ss, sd,
 853                                      inner_protos[i]);
 854                 if (ret > 0)
 855                         break;
 856         }
 857
 858         if (ret <= 0)
 859                 printf("\r%2d: ?[ no answer]", ttl);
 860         if (ctx->show == 0)
 861                 printf("\n");
 862         if (ctx->show && ret <= 0)
 863                 printf("\n\n");
 864
 865         fflush(stdout);
 866         return 0;
 867 }
 868
 869 static int main_trace(struct ctx *ctx)
 870 {
 871         int fd, fd_cap, ifindex, ttl;
 872         struct ring dummy_ring;
 873         struct sockaddr_storage ss, sd;
 874         uint8_t *pkt_snd, *pkt_rcv;
 875
 876         fd = get_remote_fd(ctx, &ss, &sd);
 877         fd_cap = pf_socket();
 878
 879         inject_filter(ctx, fd_cap);
 880
 881         ifindex = device_ifindex(ctx->dev);
 882         bind_rx_ring(fd_cap, &dummy_ring, ifindex);
 883
 884         if (ctx->totlen < af_ops[ctx->proto].min_len_tcp) {
 885                 ctx->totlen = af_ops[ctx->proto].min_len_tcp;
 886                 if (ctx->payload)
 887                         ctx->totlen += strlen(ctx->payload);
 888         }
 889
 890         ctx->rcvlen = device_mtu(ctx->dev) - sizeof(struct ethhdr);
 891         if (ctx->totlen >= ctx->rcvlen)
 892                 panic("Packet len exceeds device MTU!\n");
 893
 894         pkt_snd = xmalloc(ctx->totlen);
 895         pkt_rcv = xmalloc(ctx->rcvlen);
 896
 897         show_trace_info(ctx, &ss, &sd);
 898
 899         for (ttl = ctx->init_ttl; ttl <= ctx->max_ttl && sigint == 0; ++ttl)
 900                 __process_ttl(ctx, fd, fd_cap, ttl, pkt_snd, pkt_rcv,
 901                               &ss, &sd);
 902
 903         xfree(pkt_snd);
 904         xfree(pkt_rcv);
 905
 906         close(fd_cap);
 907         close(fd);
 908
 909         return 0;
 910 }
 911
 912 int main(int argc, char **argv)
 913 {
 914         int c, opt_index, ret;
 915         struct ctx ctx;
 916
 917         setfsuid(getuid());
 918         setfsgid(getgid());
 919
 920         srand(time(NULL));
 921
 922         memset(&ctx, 0, sizeof(ctx));
 923         ctx.init_ttl = 1;
 924         ctx.max_ttl = 30;
 925         ctx.queries = 2;
 926         ctx.timeout = 2;
 927         ctx.proto = IPPROTO_IP;
 928         ctx.payload = NULL;
 929         ctx.dev = xstrdup("eth0");
 930         ctx.port = xstrdup("80");
 931
 932         while ((c = getopt_long(argc, argv, short_options, long_options,
 933                 &opt_index)) != EOF) {
 934                 switch (c) {
 935                 case 'h':
 936                         help();
 937                         break;
 938                 case 'v':
 939                         version();
 940                         break;
 941                 case 'u':
 942                         update_geoip();
 943                         die();
 944                         break;
 945                 case 'H':
 946                         ctx.host = xstrdup(optarg);
 947                         break;
 948                 case 'p':
 949                         if (ctx.port)
 950                                 xfree(ctx.port);
 951                         ctx.port = xstrdup(optarg);
 952                         break;
 953                 case 'n':
 954                         ctx.dns_resolv = 0;
 955                         break;
 956                 case '4':
 957                         ctx.proto = IPPROTO_IP;
 958                         break;
 959                 case '6':
 960                         ctx.proto = IPPROTO_IPV6;
 961                         break;
 962                 case 'Z':
 963                         ctx.show = 1;
 964                         break;
 965                 case 'N':
 966                         ctx.dns_resolv = 1;
 967                         break;
 968                 case 'f':
 969                         ctx.init_ttl = atoi(optarg);
 970                         if (ctx.init_ttl <= 0)
 971                                 help();
 972                         break;
 973                 case 'm':
 974                         ctx.max_ttl = atoi(optarg);
 975                         if (ctx.max_ttl <= 0)
 976                                 help();
 977                         break;
 978                 case 'i':
 979                 case 'd':
 980                         free(ctx.dev);
 981                         ctx.dev = xstrdup(optarg);
 982                         break;
 983                 case 'q':
 984                         ctx.queries = atoi(optarg);
 985                         if (ctx.queries <= 0)
 986                                 help();
 987                         break;
 988                 case 'x':
 989                         ctx.timeout = atoi(optarg);
 990                         if (ctx.timeout <= 0)
 991                                 help();
 992                         break;
 993                 case 'L':
 994                         ctx.latitude = 1;
 995                         break;
 996                 case 'S':
 997                         ctx.syn = 1;
 998                         break;
 999                 case 'A':
1000                         ctx.ack = 1;
1001                         break;
1002                 case 'F':
1003                         ctx.fin = 1;
1004                         break;
1005                 case 'U':
1006                         ctx.urg = 1;
1007                         break;
1008                 case 'P':
1009                         ctx.psh = 1;
1010                         break;
1011                 case 'R':
1012                         ctx.rst = 1;
1013                         break;
1014                 case 'E':
1015                         ctx.syn = 1;
1016                         ctx.ecn = 1;
1017                         break;
1018                 case 't':
1019                         ctx.tos = atoi(optarg);
1020                         if (ctx.tos < 0)
1021                                 help();
1022                         break;
1023                 case 'G':
1024                         ctx.nofrag = 1;
1025                         break;
1026                 case 'X':
1027                         ctx.payload = xstrdup(optarg);
1028                         break;
1029                 case 'l':
1030                         ctx.totlen = atoi(optarg);
1031                         if (ctx.totlen <= 0)
1032                                 help();
1033                         break;
1034                 case '?':
1035                         switch (optopt) {
1036                         case 'H':
1037                         case 'p':
1038                         case 'f':
1039                         case 'm':
1040                         case 'i':
1041                         case 'd':
1042                         case 'q':
1043                         case 'x':
1044                         case 'X':
1045                         case 't':
1046                         case 'l':
1047                                 panic("Option -%c requires an argument!\n",
1048                                       optopt);
1049                         default:
1050                                 if (isprint(optopt))
1051                                         printf("Unknown option character `0x%X\'!\n", optopt);
1052                                 die();
1053                 }
1054                 default:
1055                         break;
1056                 }
1057         }
1058
1059         if (argc < 3 || !ctx.host || !ctx.port || ctx.init_ttl > ctx.max_ttl ||
1060             ctx.init_ttl > MAXTTL || ctx.max_ttl > MAXTTL)
1061                 help();
1062
1063         if (!device_up_and_running(ctx.dev))
1064                 panic("Networking device not up and running!\n");
1065         if (device_mtu(ctx.dev) <= ctx.totlen)
1066                 panic("Packet larger than device MTU!\n");
1067
1068         register_signal(SIGHUP, signal_handler);
1069         register_signal(SIGINT, signal_handler);
1070
1071         tprintf_init();
1072         init_geoip(1);
1073
1074         ret = main_trace(&ctx);
1075
1076         destroy_geoip();
1077         tprintf_cleanup();
1078
1079         free(ctx.dev);
1080         free(ctx.host);
1081         free(ctx.port);
1082         free(ctx.payload);
1083
1084         return ret;
1085 }