2 * netsniff-ng - the packet sniffing beast
3 * Copyright 2011 - 2013 Daniel Borkmann.
4 * Subject to the GPL, version 2.
14 #include <sys/types.h>
16 #include <sys/socket.h>
17 #include <sys/fsuid.h>
21 #include <asm/byteorder.h>
22 #include <linux/tcp.h>
23 #include <netinet/ip.h>
24 #include <netinet/ip6.h>
25 #include <netinet/in.h>
29 #include <arpa/inet.h>
30 #include <linux/if_ether.h>
31 #include <linux/icmp.h>
32 #include <linux/icmpv6.h>
51 char *host
, *port
, *dev
, *payload
;
52 int init_ttl
, max_ttl
, dns_resolv
, queries
, timeout
, totlen
, rcvlen
;
53 int syn
, ack
, ecn
, fin
, psh
, rst
, urg
, tos
, nofrag
, proto
, show
;
54 int sd_len
, dport
, latitude
;
58 int (*assembler
)(uint8_t *packet
, size_t len
, int ttl
, int proto
,
59 const struct ctx
*ctx
, const struct sockaddr
*dst
,
60 const struct sockaddr
*src
);
61 const struct sock_filter
*filter
;
63 unsigned int min_len_tcp
, min_len_icmp
;
64 int (*check
)(uint8_t *packet
, size_t len
, int ttl
, int id
,
65 const struct sockaddr
*src
);
66 void (*handler
)(uint8_t *packet
, size_t len
, int dns_resolv
,
70 static sig_atomic_t sigint
= 0;
72 static int assemble_ipv4(uint8_t *packet
, size_t len
, int ttl
, int proto
,
73 const struct ctx
*ctx
, const struct sockaddr
*dst
,
74 const struct sockaddr
*src
);
75 static int assemble_ipv6(uint8_t *packet
, size_t len
, int ttl
, int proto
,
76 const struct ctx
*ctx
, const struct sockaddr
*dst
,
77 const struct sockaddr
*src
);
78 static int check_ipv4(uint8_t *packet
, size_t len
, int ttl
, int id
,
79 const struct sockaddr
*ss
);
80 static void handle_ipv4(uint8_t *packet
, size_t len
, int dns_resolv
,
82 static int check_ipv6(uint8_t *packet
, size_t len
, int ttl
, int id
,
83 const struct sockaddr
*ss
);
84 static void handle_ipv6(uint8_t *packet
, size_t len
, int dns_resolv
,
87 static const char *short_options
= "H:p:nNf:m:i:d:q:x:SAEFPURt:Gl:hv46X:ZuL";
88 static const struct option long_options
[] = {
89 {"host", required_argument
, NULL
, 'H'},
90 {"port", required_argument
, NULL
, 'p'},
91 {"init-ttl", required_argument
, NULL
, 'f'},
92 {"max-ttl", required_argument
, NULL
, 'm'},
93 {"dev", required_argument
, NULL
, 'd'},
94 {"num-probes", required_argument
, NULL
, 'q'},
95 {"timeout", required_argument
, NULL
, 'x'},
96 {"tos", required_argument
, NULL
, 't'},
97 {"payload", required_argument
, NULL
, 'X'},
98 {"totlen", required_argument
, NULL
, 'l'},
99 {"numeric", no_argument
, NULL
, 'n'},
100 {"latitude", no_argument
, NULL
, 'L'},
101 {"update", no_argument
, NULL
, 'u'},
102 {"dns", no_argument
, NULL
, 'N'},
103 {"ipv4", no_argument
, NULL
, '4'},
104 {"ipv6", no_argument
, NULL
, '6'},
105 {"syn", no_argument
, NULL
, 'S'},
106 {"ack", no_argument
, NULL
, 'A'},
107 {"urg", no_argument
, NULL
, 'U'},
108 {"fin", no_argument
, NULL
, 'F'},
109 {"psh", no_argument
, NULL
, 'P'},
110 {"rst", no_argument
, NULL
, 'R'},
111 {"ecn-syn", no_argument
, NULL
, 'E'},
112 {"show-packet", no_argument
, NULL
, 'Z'},
113 {"nofrag", no_argument
, NULL
, 'G'},
114 {"version", no_argument
, NULL
, 'v'},
115 {"help", no_argument
, NULL
, 'h'},
119 static const struct sock_filter ipv4_icmp_type_11
[] = {
120 { 0x28, 0, 0, 0x0000000c }, /* ldh [12] */
121 { 0x15, 0, 8, 0x00000800 }, /* jneq #0x800, drop */
122 { 0x30, 0, 0, 0x00000017 }, /* ldb [23] */
123 { 0x15, 0, 6, 0x00000001 }, /* jneq #0x1, drop */
124 { 0x28, 0, 0, 0x00000014 }, /* ldh [20] */
125 { 0x45, 4, 0, 0x00001fff }, /* jset #0x1fff, drop */
126 { 0xb1, 0, 0, 0x0000000e }, /* ldxb 4*([14]&0xf) */
127 { 0x50, 0, 0, 0x0000000e }, /* ldb [x + 14] */
128 { 0x15, 0, 1, 0x0000000b }, /* jneq #0xb, drop */
129 { 0x06, 0, 0, 0xffffffff }, /* ret #-1 */
130 { 0x06, 0, 0, 0x00000000 }, /* drop: ret #0 */
133 static const struct sock_filter ipv6_icmp6_type_3
[] = {
134 { 0x28, 0, 0, 0x0000000c }, /* ldh [12] */
135 { 0x15, 0, 5, 0x000086dd }, /* jneq #0x86dd, drop */
136 { 0x30, 0, 0, 0x00000014 }, /* ldb [20] */
137 { 0x15, 0, 3, 0x0000003a }, /* jneq #0x3a, drop */
138 { 0x30, 0, 0, 0x00000036 }, /* ldb [54] */
139 { 0x15, 0, 1, 0x00000003 }, /* jneq #0x3, drop */
140 { 0x06, 0, 0, 0xffffffff }, /* ret #-1 */
141 { 0x06, 0, 0, 0x00000000 }, /* drop: ret #0 */
144 static const struct proto_ops af_ops
[] = {
146 .assembler
= assemble_ipv4
,
147 .handler
= handle_ipv4
,
149 .filter
= ipv4_icmp_type_11
,
150 .flen
= array_size(ipv4_icmp_type_11
),
151 .min_len_tcp
= sizeof(struct iphdr
) + sizeof(struct tcphdr
),
152 .min_len_icmp
= sizeof(struct iphdr
) + sizeof(struct icmphdr
),
155 .assembler
= assemble_ipv6
,
156 .handler
= handle_ipv6
,
158 .filter
= ipv6_icmp6_type_3
,
159 .flen
= array_size(ipv6_icmp6_type_3
),
160 .min_len_tcp
= sizeof(struct ip6_hdr
) + sizeof(struct tcphdr
),
161 .min_len_icmp
= sizeof(struct ip6_hdr
) + sizeof(struct icmp6hdr
),
165 static void signal_handler(int number
)
175 static void __noreturn
help(void)
177 printf("\nastraceroute %s, autonomous system trace route utility\n", VERSION_STRING
);
178 puts("http://www.netsniff-ng.org\n\n"
179 "Usage: astraceroute [options]\n"
181 " -H|--host <host> Host/IPv4/IPv6 to lookup AS route to\n"
182 " -p|--port <port> Hosts port to lookup AS route to\n"
183 " -i|-d|--dev <device> Networking device, e.g. eth0\n"
184 " -f|--init-ttl <ttl> Set initial TTL\n"
185 " -m|--max-ttl <ttl> Set maximum TTL (def: 30)\n"
186 " -q|--num-probes <num> Number of max probes for each hop (def: 2)\n"
187 " -x|--timeout <sec> Probe response timeout in sec (def: 3)\n"
188 " -X|--payload <string> Specify a payload string to test DPIs\n"
189 " -l|--totlen <len> Specify total packet len\n"
190 " -4|--ipv4 Use IPv4-only requests\n"
191 " -6|--ipv6 Use IPv6-only requests\n"
192 " -n|--numeric Do not do reverse DNS lookup for hops\n"
193 " -u|--update Update GeoIP databases\n"
194 " -L|--latitude Show latitude and longtitude\n"
195 " -N|--dns Do a reverse DNS lookup for hops\n"
196 " -S|--syn Set TCP SYN flag\n"
197 " -A|--ack Set TCP ACK flag\n"
198 " -F|--fin Set TCP FIN flag\n"
199 " -P|--psh Set TCP PSH flag\n"
200 " -U|--urg Set TCP URG flag\n"
201 " -R|--rst Set TCP RST flag\n"
202 " -E|--ecn-syn Send ECN SYN packets (RFC3168)\n"
203 " -t|--tos <tos> Set the IP TOS field\n"
204 " -G|--nofrag Set do not fragment bit\n"
205 " -Z|--show-packet Show returned packet on each hop\n"
206 " -v|--version Print version and exit\n"
207 " -h|--help Print this help and exit\n\n"
209 " IPv4 trace of AS with TCP SYN probe (this will most-likely pass):\n"
210 " astraceroute -i eth0 -N -S -H netsniff-ng.org\n"
211 " IPv4 trace of AS with TCP ECN SYN probe:\n"
212 " astraceroute -i eth0 -N -E -H netsniff-ng.org\n"
213 " IPv4 trace of AS with TCP FIN probe:\n"
214 " astraceroute -i eth0 -N -F -H netsniff-ng.org\n"
215 " IPv4 trace of AS with Xmas probe:\n"
216 " astraceroute -i eth0 -N -FPU -H netsniff-ng.org\n"
217 " IPv4 trace of AS with Null probe with ASCII payload:\n"
218 " astraceroute -i eth0 -N -H netsniff-ng.org -X \"censor-me\" -Z\n"
219 " IPv6 trace of AS up to www.6bone.net:\n"
220 " astraceroute -6 -i eth0 -S -E -N -H www.6bone.net\n\n"
222 " If the TCP probe did not give any results, then astraceroute will\n"
223 " automatically probe for classic ICMP packets! To gather more\n"
224 " information about astraceroute's fetched AS numbers, see e.g.\n"
225 " http://bgp.he.net/AS<number>!\n\n"
226 "Please report bugs to <bugs@netsniff-ng.org>\n"
227 "Copyright (C) 2011-2013 Daniel Borkmann <dborkma@tik.ee.ethz.ch>\n"
228 "Swiss federal institute of technology (ETH Zurich)\n"
229 "License: GNU GPL version 2.0\n"
230 "This is free software: you are free to change and redistribute it.\n"
231 "There is NO WARRANTY, to the extent permitted by law.\n");
235 static void __noreturn
version(void)
237 printf("\nastraceroute %s, autonomous system trace route utility\n", VERSION_LONG
);
238 puts("http://www.netsniff-ng.org\n\n"
239 "Please report bugs to <bugs@netsniff-ng.org>\n"
240 "Copyright (C) 2011-2013 Daniel Borkmann <dborkma@tik.ee.ethz.ch>\n"
241 "Swiss federal institute of technology (ETH Zurich)\n"
242 "License: GNU GPL version 2.0\n"
243 "This is free software: you are free to change and redistribute it.\n"
244 "There is NO WARRANTY, to the extent permitted by law.\n");
248 static void __assemble_data(uint8_t *packet
, size_t len
, const char *payload
)
252 if (payload
== NULL
) {
253 for (i
= 0; i
< len
; ++i
)
254 packet
[i
] = (uint8_t) rand();
256 int lmin
= min(len
, strlen(payload
));
258 for (i
= 0; i
< lmin
; ++i
)
259 packet
[i
] = (uint8_t) payload
[i
];
260 for (i
= lmin
; i
< len
; ++i
)
261 packet
[i
] = (uint8_t) rand();
265 static void __assemble_icmp4(uint8_t *packet
, size_t len
)
267 struct icmphdr
*icmph
= (struct icmphdr
*) packet
;
269 bug_on(len
< sizeof(struct icmphdr
));
271 icmph
->type
= ICMP_ECHO
;
276 static void __assemble_icmp6(uint8_t *packet
, size_t len
)
278 struct icmp6hdr
*icmp6h
= (struct icmp6hdr
*) packet
;
280 bug_on(len
< sizeof(struct icmp6hdr
));
282 icmp6h
->icmp6_type
= ICMPV6_ECHO_REQUEST
;
283 icmp6h
->icmp6_code
= 0;
284 icmp6h
->icmp6_cksum
= 0;
287 static void __assemble_tcp(uint8_t *packet
, size_t len
, int syn
, int ack
,
288 int urg
, int fin
, int rst
, int psh
, int ecn
,
291 struct tcphdr
*tcph
= (struct tcphdr
*) packet
;
293 bug_on(len
< sizeof(struct tcphdr
));
295 tcph
->source
= htons((uint16_t) rand());
296 tcph
->dest
= htons((uint16_t) dport
);
298 tcph
->seq
= htonl(rand());
299 tcph
->ack_seq
= (!!ack
? htonl(rand()) : 0);
312 tcph
->window
= htons((uint16_t) (100 + (rand() % 65435)));
313 tcph
->urg_ptr
= (!!urg
? htons((uint16_t) rand()) : 0);
317 static int assemble_ipv4(uint8_t *packet
, size_t len
, int ttl
, int proto
,
318 const struct ctx
*ctx
, const struct sockaddr
*dst
,
319 const struct sockaddr
*src
)
322 size_t data_len
, off_next
= 0;
323 struct iphdr
*iph
= (struct iphdr
*) packet
;
325 bug_on(!src
|| !dst
);
326 bug_on(src
->sa_family
!= PF_INET
|| dst
->sa_family
!= PF_INET
);
327 bug_on(len
< sizeof(*iph
) + min(sizeof(struct tcphdr
),
328 sizeof(struct icmphdr
)));
332 iph
->tos
= (uint8_t) ctx
->tos
;
334 iph
->tot_len
= htons((uint16_t) len
);
335 iph
->id
= htons((uint16_t) rand());
337 iph
->frag_off
= ctx
->nofrag
? IP_DF
: 0;
338 iph
->ttl
= (uint8_t) ttl
;
340 iph
->saddr
= ((const struct sockaddr_in
*) src
)->sin_addr
.s_addr
;
341 iph
->daddr
= ((const struct sockaddr_in
*) dst
)->sin_addr
.s_addr
;
343 iph
->protocol
= (uint8_t) proto
;
345 data
= packet
+ sizeof(*iph
);
346 data_len
= len
- sizeof(*iph
);
350 __assemble_tcp(data
, data_len
, ctx
->syn
, ctx
->ack
, ctx
->urg
,
351 ctx
->fin
, ctx
->rst
, ctx
->psh
, ctx
->ecn
, ctx
->dport
);
352 off_next
= sizeof(struct tcphdr
);
355 __assemble_icmp4(data
, data_len
);
356 off_next
= sizeof(struct icmphdr
);
362 data
= packet
+ sizeof(*iph
) + off_next
;
363 data_len
= len
- sizeof(*iph
) - off_next
;
365 __assemble_data(data
, data_len
, ctx
->payload
);
367 iph
->check
= csum((unsigned short *) packet
, ntohs(iph
->tot_len
) >> 1);
369 return ntohs(iph
->id
);
372 static int assemble_ipv6(uint8_t *packet
, size_t len
, int ttl
, int proto
,
373 const struct ctx
*ctx
, const struct sockaddr
*dst
,
374 const struct sockaddr
*src
)
377 size_t data_len
, off_next
= 0;
378 struct ip6_hdr
*ip6h
= (struct ip6_hdr
*) packet
;
380 bug_on(!src
|| !dst
);
381 bug_on(src
->sa_family
!= PF_INET6
|| dst
->sa_family
!= PF_INET6
);
382 bug_on(len
< sizeof(*ip6h
) + min(sizeof(struct tcphdr
),
383 sizeof(struct icmp6hdr
)));
385 ip6h
->ip6_flow
= htonl(rand() & 0x000fffff);
386 ip6h
->ip6_vfc
= 0x60;
388 ip6h
->ip6_plen
= htons((uint16_t) len
- sizeof(*ip6h
));
389 ip6h
->ip6_nxt
= (uint8_t) proto
;
390 ip6h
->ip6_hlim
= (uint8_t) ttl
;
392 memcpy(&ip6h
->ip6_src
, &(((const struct sockaddr_in6
*)
393 src
)->sin6_addr
), sizeof(ip6h
->ip6_src
));
394 memcpy(&ip6h
->ip6_dst
, &(((const struct sockaddr_in6
*)
395 dst
)->sin6_addr
), sizeof(ip6h
->ip6_dst
));
397 data
= packet
+ sizeof(*ip6h
);
398 data_len
= len
- sizeof(*ip6h
);
402 __assemble_tcp(data
, data_len
, ctx
->syn
, ctx
->ack
, ctx
->urg
,
403 ctx
->fin
, ctx
->rst
, ctx
->psh
, ctx
->ecn
, ctx
->dport
);
404 off_next
= sizeof(struct tcphdr
);
408 __assemble_icmp6(data
, data_len
);
409 off_next
= sizeof(struct icmp6hdr
);
415 data
= packet
+ sizeof(*ip6h
) + off_next
;
416 data_len
= len
- sizeof(*ip6h
) - off_next
;
418 __assemble_data(data
, data_len
, ctx
->payload
);
420 return ntohl(ip6h
->ip6_flow
) & 0x000fffff;
423 static int check_ipv4(uint8_t *packet
, size_t len
, int ttl
, int id
,
424 const struct sockaddr
*ss
)
426 struct iphdr
*iph
= (struct iphdr
*) packet
;
427 struct iphdr
*iph_inner
;
428 struct icmphdr
*icmph
;
430 if (iph
->protocol
!= IPPROTO_ICMP
)
432 if (iph
->daddr
!= ((const struct sockaddr_in
*) ss
)->sin_addr
.s_addr
)
435 icmph
= (struct icmphdr
*) (packet
+ sizeof(struct iphdr
));
436 if (icmph
->type
!= ICMP_TIME_EXCEEDED
)
438 if (icmph
->code
!= ICMP_EXC_TTL
)
441 iph_inner
= (struct iphdr
*) (packet
+ sizeof(struct iphdr
) +
442 sizeof(struct icmphdr
));
443 if (ntohs(iph_inner
->id
) != id
)
449 static void handle_ipv4(uint8_t *packet
, size_t len
, int dns_resolv
, int latitude
)
451 char hbuff
[NI_MAXHOST
];
452 struct iphdr
*iph
= (struct iphdr
*) packet
;
453 struct sockaddr_in sd
;
454 struct hostent
*hent
;
455 const char *as
, *country
, *city
;
457 memset(hbuff
, 0, sizeof(hbuff
));
458 memset(&sd
, 0, sizeof(sd
));
459 sd
.sin_family
= PF_INET
;
460 sd
.sin_addr
.s_addr
= iph
->saddr
;
462 getnameinfo((struct sockaddr
*) &sd
, sizeof(sd
),
463 hbuff
, sizeof(hbuff
), NULL
, 0, NI_NUMERICHOST
);
465 as
= geoip4_as_name(sd
);
466 country
= geoip4_country_name(sd
);
467 city
= geoip4_city_name(sd
);
470 hent
= gethostbyaddr(&sd
.sin_addr
, sizeof(sd
.sin_addr
), PF_INET
);
472 printf(" %s (%s)", hent
->h_name
, hbuff
);
474 printf(" %s", hbuff
);
476 printf(" %s", hbuff
);
479 printf(" in %s", as
);
481 printf(" in %s", country
);
483 printf(", %s", city
);
486 printf(" (%f/%f)", geoip4_latitude(sd
), geoip4_longitude(sd
));
489 static int check_ipv6(uint8_t *packet
, size_t len
, int ttl
, int id
,
490 const struct sockaddr
*ss
)
492 struct ip6_hdr
*ip6h
= (struct ip6_hdr
*) packet
;
493 struct ip6_hdr
*ip6h_inner
;
494 struct icmp6hdr
*icmp6h
;
496 if (ip6h
->ip6_nxt
!= 0x3a)
498 if (memcmp(&ip6h
->ip6_dst
, &(((const struct sockaddr_in6
*)
499 ss
)->sin6_addr
), sizeof(ip6h
->ip6_dst
)))
502 icmp6h
= (struct icmp6hdr
*) (packet
+ sizeof(*ip6h
));
503 if (icmp6h
->icmp6_type
!= ICMPV6_TIME_EXCEED
)
505 if (icmp6h
->icmp6_code
!= ICMPV6_EXC_HOPLIMIT
)
508 ip6h_inner
= (struct ip6_hdr
*) (packet
+ sizeof(*ip6h
) + sizeof(*icmp6h
));
509 if ((ntohl(ip6h_inner
->ip6_flow
) & 0x000fffff) != id
)
515 static void handle_ipv6(uint8_t *packet
, size_t len
, int dns_resolv
, int latitude
)
517 char hbuff
[NI_MAXHOST
];
518 struct ip6_hdr
*ip6h
= (struct ip6_hdr
*) packet
;
519 struct sockaddr_in6 sd
;
520 struct hostent
*hent
;
521 const char *as
, *country
, *city
;
523 memset(hbuff
, 0, sizeof(hbuff
));
524 memset(&sd
, 0, sizeof(sd
));
525 sd
.sin6_family
= PF_INET6
;
526 memcpy(&sd
.sin6_addr
, &ip6h
->ip6_src
, sizeof(ip6h
->ip6_src
));
528 getnameinfo((struct sockaddr
*) &sd
, sizeof(sd
),
529 hbuff
, sizeof(hbuff
), NULL
, 0, NI_NUMERICHOST
);
531 as
= geoip6_as_name(sd
);
532 country
= geoip6_country_name(sd
);
533 city
= geoip6_city_name(sd
);
536 hent
= gethostbyaddr(&sd
.sin6_addr
, sizeof(sd
.sin6_addr
), PF_INET6
);
538 printf(" %s (%s)", hent
->h_name
, hbuff
);
540 printf(" %s", hbuff
);
542 printf(" %s", hbuff
);
545 printf(" in %s", as
);
547 printf(" in %s", country
);
549 printf(", %s", city
);
552 printf(" (%f/%f)", geoip6_latitude(sd
), geoip6_longitude(sd
));
555 static void show_trace_info(struct ctx
*ctx
, const struct sockaddr_storage
*ss
,
556 const struct sockaddr_storage
*sd
)
558 char hbuffs
[256], hbuffd
[256];
560 memset(hbuffd
, 0, sizeof(hbuffd
));
561 getnameinfo((struct sockaddr
*) sd
, sizeof(*sd
),
562 hbuffd
, sizeof(hbuffd
), NULL
, 0, NI_NUMERICHOST
);
564 memset(hbuffs
, 0, sizeof(hbuffs
));
565 getnameinfo((struct sockaddr
*) ss
, sizeof(*ss
),
566 hbuffs
, sizeof(hbuffs
), NULL
, 0, NI_NUMERICHOST
);
568 printf("AS path IPv%d TCP trace from %s to %s:%s (%s) with len %d "
569 "Bytes, %u max hops\n", ctx
->proto
== IPPROTO_IP
? 4 : 6,
570 hbuffs
, hbuffd
, ctx
->port
, ctx
->host
, ctx
->totlen
, ctx
->max_ttl
);
572 printf("Using flags SYN:%d,ACK:%d,ECN:%d,FIN:%d,PSH:%d,RST:%d,URG:%d\n",
573 ctx
->syn
, ctx
->ack
, ctx
->ecn
, ctx
->fin
, ctx
->psh
, ctx
->rst
, ctx
->urg
);
576 printf("With payload: \'%s\'\n", ctx
->payload
);
579 static int get_remote_fd(struct ctx
*ctx
, struct sockaddr_storage
*ss
,
580 struct sockaddr_storage
*sd
)
582 int fd
= -1, ret
, one
= 1;
583 struct addrinfo hints
, *ahead
, *ai
;
585 memset(&hints
, 0, sizeof(hints
));
586 hints
.ai_family
= PF_UNSPEC
;
587 hints
.ai_socktype
= SOCK_STREAM
;
588 hints
.ai_protocol
= IPPROTO_TCP
;
589 hints
.ai_flags
= AI_NUMERICSERV
;
591 ret
= getaddrinfo(ctx
->host
, ctx
->port
, &hints
, &ahead
);
593 panic("Cannot get address info!\n");
595 for (ai
= ahead
; ai
!= NULL
&& fd
< 0; ai
= ai
->ai_next
) {
596 if (!((ai
->ai_family
== PF_INET6
&& ctx
->proto
== IPPROTO_IPV6
) ||
597 (ai
->ai_family
== PF_INET
&& ctx
->proto
== IPPROTO_IP
)))
600 fd
= socket(ai
->ai_family
, SOCK_RAW
, IPPROTO_RAW
);
604 memset(ss
, 0, sizeof(*ss
));
605 ret
= device_address(ctx
->dev
, ai
->ai_family
, ss
);
607 panic("Cannot get own device address!\n");
609 ret
= bind(fd
, (struct sockaddr
*) ss
, sizeof(*ss
));
611 panic("Cannot bind socket!\n");
613 memset(sd
, 0, sizeof(*sd
));
614 memcpy(sd
, ai
->ai_addr
, ai
->ai_addrlen
);
616 ctx
->sd_len
= ai
->ai_addrlen
;
617 ctx
->dport
= strtoul(ctx
->port
, NULL
, 10);
619 ret
= setsockopt(fd
, ctx
->proto
, IP_HDRINCL
, &one
, sizeof(one
));
621 panic("Kernel does not support IP_HDRINCL!\n");
623 if (ai
->ai_family
== PF_INET6
) {
624 struct sockaddr_in6
*sd6
= (struct sockaddr_in6
*) sd
;
635 panic("Cannot create socket! Does remote "
637 ctx
->proto
== IPPROTO_IP
? 4 : 6);
642 static void inject_filter(struct ctx
*ctx
, int fd
)
644 struct sock_fprog bpf_ops
;
646 enable_kernel_bpf_jit_compiler();
648 memset(&bpf_ops
, 0, sizeof(bpf_ops
));
649 bpf_ops
.filter
= (struct sock_filter
*) af_ops
[ctx
->proto
].filter
;
650 bpf_ops
.len
= af_ops
[ctx
->proto
].flen
;
652 bpf_attach_to_sock(fd
, &bpf_ops
);
655 static int __process_node(struct ctx
*ctx
, int fd
, int fd_cap
, int ttl
,
656 int inner_proto
, uint8_t *pkt_snd
, uint8_t *pkt_rcv
,
657 const struct sockaddr_storage
*ss
,
658 const struct sockaddr_storage
*sd
, struct timeval
*diff
)
660 int pkt_id
, ret
, timeout
;
662 struct timeval start
, end
;
664 prepare_polling(fd_cap
, &pfd
);
666 memset(pkt_snd
, 0, ctx
->totlen
);
667 pkt_id
= af_ops
[ctx
->proto
].assembler(pkt_snd
, ctx
->totlen
, ttl
,
669 (const struct sockaddr
*) sd
,
670 (const struct sockaddr
*) ss
);
672 ret
= sendto(fd
, pkt_snd
, ctx
->totlen
, 0, (struct sockaddr
*) sd
,
675 panic("sendto failed: %s\n", strerror(errno
));
677 bug_on(gettimeofday(&start
, NULL
));
679 timeout
= (ctx
->timeout
> 0 ? ctx
->timeout
: 2) * 1000;
681 ret
= poll(&pfd
, 1, timeout
);
682 if (ret
> 0 && pfd
.revents
& POLLIN
&& sigint
== 0) {
683 bug_on(gettimeofday(&end
, NULL
));
685 timersub(&end
, &start
, diff
);
687 ret
= recvfrom(fd_cap
, pkt_rcv
, ctx
->rcvlen
, 0, NULL
, NULL
);
688 if (ret
< sizeof(struct ethhdr
) + af_ops
[ctx
->proto
].min_len_icmp
)
691 return af_ops
[ctx
->proto
].check(pkt_rcv
+ sizeof(struct ethhdr
),
692 ret
- sizeof(struct ethhdr
), ttl
,
693 pkt_id
, (const struct sockaddr
*) ss
);
701 static void timerdiv(const unsigned long divisor
, const struct timeval
*tv
,
702 struct timeval
*result
)
704 uint64_t x
= ((uint64_t) tv
->tv_sec
* 1000 * 1000 + tv
->tv_usec
) / divisor
;
706 result
->tv_sec
= x
/ 1000 / 1000;
707 result
->tv_usec
= x
% (1000 * 1000);
710 static int timevalcmp(const void *t1
, const void *t2
)
712 if (timercmp((struct timeval
*) t1
, (struct timeval
*) t2
, <))
714 if (timercmp((struct timeval
*) t1
, (struct timeval
*) t2
, >))
720 static int __process_time(struct ctx
*ctx
, int fd
, int fd_cap
, int ttl
,
721 int inner_proto
, uint8_t *pkt_snd
, uint8_t *pkt_rcv
,
722 const struct sockaddr_storage
*ss
,
723 const struct sockaddr_storage
*sd
)
725 int good
= 0, i
, j
= 0, ret
= -EIO
, idx
, ret_good
= -EIO
;
726 struct timeval probes
[9], *tmp
, sum
, res
;
727 uint8_t *trash
= xmalloc(ctx
->rcvlen
);
728 char *cwait
[] = { "-", "\\", "|", "/" };
729 const char *proto_short
[] = {
731 [IPPROTO_ICMP
] = "i",
732 [IPPROTO_ICMPV6
] = "i",
735 memset(probes
, 0, sizeof(probes
));
736 for (i
= 0; i
< array_size(probes
) && sigint
== 0; ++i
) {
737 ret
= __process_node(ctx
, fd
, fd_cap
, ttl
, inner_proto
,
738 pkt_snd
, good
== 0 ? pkt_rcv
: trash
,
746 if (good
== 0 && ctx
->queries
== i
)
751 printf("\r%2d: %s", ttl
, cwait
[j
++]);
753 if (j
>= array_size(cwait
))
762 tmp
= xmalloc(sizeof(struct timeval
) * good
);
763 for (i
= j
= 0; i
< array_size(probes
); ++i
) {
764 if (probes
[i
].tv_sec
== 0 && probes
[i
].tv_usec
== 0)
766 tmp
[j
].tv_sec
= probes
[i
].tv_sec
;
767 tmp
[j
].tv_usec
= probes
[i
].tv_usec
;
771 qsort(tmp
, j
, sizeof(struct timeval
), timevalcmp
);
773 printf("\r%2d: %s[", ttl
, proto_short
[inner_proto
]);
777 timeradd(&tmp
[idx
], &tmp
[idx
- 1], &sum
);
778 timerdiv(2, &sum
, &res
);
780 printf("%lu sec ", res
.tv_sec
);
781 printf("%7lu us", res
.tv_usec
);
784 if (tmp
[idx
].tv_sec
> 0)
785 printf("%lu sec ", tmp
[idx
].tv_sec
);
786 printf("%7lu us", tmp
[idx
].tv_usec
);
797 static int __probe_remote(struct ctx
*ctx
, int fd
, int fd_cap
, int ttl
,
798 uint8_t *pkt_snd
, uint8_t *pkt_rcv
,
799 const struct sockaddr_storage
*ss
,
800 const struct sockaddr_storage
*sd
,
803 int ret
= -EIO
, tries
= ctx
->queries
;
805 while (tries
-- > 0 && sigint
== 0) {
806 ret
= __process_time(ctx
, fd
, fd_cap
, ttl
, inner_proto
,
807 pkt_snd
, pkt_rcv
, ss
, sd
);
811 af_ops
[ctx
->proto
].handler(pkt_rcv
+ sizeof(struct ethhdr
),
812 ret
- sizeof(struct ethhdr
),
813 ctx
->dns_resolv
, ctx
->latitude
);
815 struct pkt_buff
*pkt
;
818 pkt
= pkt_alloc(pkt_rcv
, ret
);
830 static int __process_ttl(struct ctx
*ctx
, int fd
, int fd_cap
, int ttl
,
831 uint8_t *pkt_snd
, uint8_t *pkt_rcv
,
832 const struct sockaddr_storage
*ss
,
833 const struct sockaddr_storage
*sd
)
836 const int inner_protos
[] = {
841 printf("%2d: ", ttl
);
844 for (i
= 0; i
< array_size(inner_protos
) && sigint
== 0; ++i
) {
845 ret
= __probe_remote(ctx
, fd
, fd_cap
, ttl
, pkt_snd
, pkt_rcv
, ss
, sd
,
852 printf("\r%2d: ?[ no answer]", ttl
);
855 if (ctx
->show
&& ret
<= 0)
862 static int main_trace(struct ctx
*ctx
)
864 int fd
, fd_cap
, ifindex
, ttl
;
865 struct ring dummy_ring
;
866 struct sockaddr_storage ss
, sd
;
867 uint8_t *pkt_snd
, *pkt_rcv
;
869 fd
= get_remote_fd(ctx
, &ss
, &sd
);
870 fd_cap
= pf_socket();
872 inject_filter(ctx
, fd_cap
);
874 ifindex
= device_ifindex(ctx
->dev
);
875 bind_rx_ring(fd_cap
, &dummy_ring
, ifindex
);
877 if (ctx
->totlen
< af_ops
[ctx
->proto
].min_len_tcp
) {
878 ctx
->totlen
= af_ops
[ctx
->proto
].min_len_tcp
;
880 ctx
->totlen
+= strlen(ctx
->payload
);
883 ctx
->rcvlen
= device_mtu(ctx
->dev
) - sizeof(struct ethhdr
);
884 if (ctx
->totlen
>= ctx
->rcvlen
)
885 panic("Packet len exceeds device MTU!\n");
887 pkt_snd
= xmalloc(ctx
->totlen
);
888 pkt_rcv
= xmalloc(ctx
->rcvlen
);
890 show_trace_info(ctx
, &ss
, &sd
);
892 for (ttl
= ctx
->init_ttl
; ttl
<= ctx
->max_ttl
&& sigint
== 0; ++ttl
)
893 __process_ttl(ctx
, fd
, fd_cap
, ttl
, pkt_snd
, pkt_rcv
,
905 int main(int argc
, char **argv
)
907 int c
, opt_index
, ret
;
915 memset(&ctx
, 0, sizeof(ctx
));
920 ctx
.proto
= IPPROTO_IP
;
922 ctx
.dev
= xstrdup("eth0");
923 ctx
.port
= xstrdup("80");
925 while ((c
= getopt_long(argc
, argv
, short_options
, long_options
,
926 &opt_index
)) != EOF
) {
939 ctx
.host
= xstrdup(optarg
);
944 ctx
.port
= xstrdup(optarg
);
950 ctx
.proto
= IPPROTO_IP
;
953 ctx
.proto
= IPPROTO_IPV6
;
962 ctx
.init_ttl
= atoi(optarg
);
963 if (ctx
.init_ttl
<= 0)
967 ctx
.max_ttl
= atoi(optarg
);
968 if (ctx
.max_ttl
<= 0)
974 ctx
.dev
= xstrdup(optarg
);
977 ctx
.queries
= atoi(optarg
);
978 if (ctx
.queries
<= 0)
982 ctx
.timeout
= atoi(optarg
);
983 if (ctx
.timeout
<= 0)
1012 ctx
.tos
= atoi(optarg
);
1020 ctx
.payload
= xstrdup(optarg
);
1023 ctx
.totlen
= atoi(optarg
);
1024 if (ctx
.totlen
<= 0)
1040 panic("Option -%c requires an argument!\n",
1043 if (isprint(optopt
))
1044 printf("Unknown option character `0x%X\'!\n", optopt
);
1052 if (argc
< 3 || !ctx
.host
|| !ctx
.port
|| ctx
.init_ttl
> ctx
.max_ttl
||
1053 ctx
.init_ttl
> MAXTTL
|| ctx
.max_ttl
> MAXTTL
)
1056 if (!device_up_and_running(ctx
.dev
))
1057 panic("Networking device not up and running!\n");
1058 if (device_mtu(ctx
.dev
) <= ctx
.totlen
)
1059 panic("Packet larger than device MTU!\n");
1061 register_signal(SIGHUP
, signal_handler
);
1062 register_signal(SIGINT
, signal_handler
);
1067 ret
= main_trace(&ctx
);