traceroute.c revision 7ebd3a9b323191afa06dcb4f5b868a25f091be17
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that: (1) source code distributions
* retain the above copyright notice and this paragraph in its entirety, (2)
* distributions including binary code include the above copyright notice and
* this paragraph in its entirety in the documentation or other materials
* provided with the distribution, and (3) all advertising materials mentioning
* features or use of this software display the following acknowledgement:
* ``This product includes software developed by the University of California,
* Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
* the University nor the names of its contributors may be used to endorse
* or promote products derived from this software without specific prior
* written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
*
* @(#)$Header: traceroute.c,v 1.49 97/06/13 02:30:23 leres Exp $ (LBL)
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/param.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/sysmacros.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/ip_icmp.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>
#include <netinet/ip6.h>
#include <netinet/icmp6.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <malloc.h>
#include <memory.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <libintl.h>
#include <locale.h>
#include <signal.h>
#include <setjmp.h>
#include <limits.h>
#include <zone.h>
#include <priv_utils.h>
#include <ifaddrlist.h>
#include "traceroute.h"
#define MAX_SEQ 65535 /* max sequence value for ICMP */
#define MAX_TRAFFIC_CLASS 255 /* max traffic class for IPv6 */
#define MAX_FLOW_LABEL 0xFFFFF /* max flow label for IPv6 */
#define MAX_TOS 255 /* max type-of-service for IPv4 */
#define STR_LEN 30
/* store the information about a host */
struct hostinfo {
char *name; /* hostname */
int family; /* address family of the IP addresses */
int num_addr; /* number of IP addresses */
union any_in_addr *addrs; /* list of IP addresses */
};
/* used to store a bunch of protocol specific values */
struct pr_set {
int family; /* AF_INET or AF_INET6 */
char name[STR_LEN]; /* "IPv4" or "IPv6" */
char icmp[STR_LEN]; /* "icmp" or "ipv6-icmp" */
int icmp_minlen;
int addr_len;
int ip_hdr_len;
int packlen;
int sock_size; /* size of sockaddr_in or sockaddr_in6 */
struct sockaddr *to;
struct sockaddr *from;
void *from_sin_addr;
union any_in_addr *gwIPlist;
/* pointers to v4/v6 functions */
struct ip *(*set_buffers_fn) (int);
int (*check_reply_fn)(struct msghdr *, int, int, uchar_t *, uchar_t *);
boolean_t (*print_icmp_other_fn)(uchar_t, uchar_t);
void (*print_addr_fn)(uchar_t *, int, struct sockaddr *);
};
/*
* LBNL bug fixed: in LBNL traceroute 'uchar_t packet[512];'
* Not sufficient to hold the complete packet for ECHO REPLY of a big probe.
* Packet size is reported incorrectly in such a case.
* Also this buffer needs to be 32 bit aligned. In the future the alignment
* requirement will be increased to 64 bit. So, let's use 64 bit alignment now.
*/
static uint64_t packet[(IP_MAXPACKET + 1)/8]; /* received packet */
static struct ip *outip4; /* output buffer to send as an IPv4 datagram */
static struct ip *outip6; /* output buffer to send as an IPv6 datagram */
/* Used to store the ancillary data that comes with the received packets */
static uint64_t ancillary_data[(IP_MAXPACKET + 1)/8];
/* first get the gw names, later you'll resolve them based on the family */
static char *gwlist[MAXMAX_GWS]; /* gateway names list */
static union any_in_addr gwIPlist[MAX_GWS]; /* gateway IPv4 address list */
static union any_in_addr gwIP6list[MAX_GWS6]; /* gateway IPv6 address list */
static int family_input = AF_UNSPEC; /* User supplied protocol family */
static int rcvsock4; /* receive (icmp) socket file descriptor */
static int sndsock4; /* send (udp/icmp) socket file descriptor */
static int rcvsock6; /* receive (icmp6) socket file descriptor */
static int sndsock6; /* send (udp6/icmp6) socket file descriptor */
int gw_count = 0; /* number of gateways */
static struct sockaddr_in whereto; /* Who to try to reach */
static struct sockaddr_in6 whereto6;
static struct sockaddr_in wherefrom; /* Who we are */
static struct sockaddr_in6 wherefrom6;
static int packlen_input = 0; /* user input for packlen */
char *prog;
static char *source_input = NULL; /* this is user arg. source, doesn't change */
static char *source = NULL; /* this gets modified after name lookup */
char *hostname;
static char *device = NULL; /* interface name */
static struct pr_set *pr4; /* protocol info for IPv4 */
static struct pr_set *pr6; /* protocol info for IPv6 */
static struct ifaddrlist *al4; /* list of interfaces */
static struct ifaddrlist *al6; /* list of interfaces */
static uint_t if_index = 0; /* interface index */
static int num_v4 = 0; /* count of IPv4 addresses */
static int num_v6 = 0; /* count of IPv6 addresses */
static int num_ifs4 = 0; /* count of local IPv4 interfaces */
static int num_ifs6 = 0; /* count of local IPv6 interfaces */
static int nprobes = 3; /* number of probes */
static int max_ttl = 30; /* max number of hops */
static int first_ttl = 1; /* initial number of hops */
ushort_t ident; /* used to authenticate replies */
ushort_t port = 32768 + 666; /* start udp dest port # for probe packets */
static int options = 0; /* socket options */
boolean_t verbose = _B_FALSE; /* verbose output */
static int waittime = 5; /* time to wait for response (in seconds) */
static struct timeval delay = {0, 0}; /* delay between consecutive probe */
boolean_t nflag = _B_FALSE; /* print addresses numerically */
static boolean_t showttl = _B_FALSE; /* print the ttl(hop limit) of recvd pkt */
boolean_t useicmp = _B_FALSE; /* use icmp echo instead of udp packets */
boolean_t docksum = _B_TRUE; /* calculate checksums */
static boolean_t collect_stat = _B_FALSE; /* print statistics */
boolean_t settos = _B_FALSE; /* set type-of-service field */
static int max_timeout = 5; /* quit after this consecutive timeouts */
static boolean_t probe_all = _B_FALSE; /* probe all the IFs of the target */
static boolean_t pick_src = _B_FALSE; /* traceroute picks the src address */
/*
* flow and class are specific to IPv6, tos and off are specific to IPv4.
* Each protocol uses the ones that are specific to itself, and ignores
* others.
*/
static uint_t flow = 0; /* IPv6 flow info */
static uint_t class = 0; /* IPv6 class */
uchar_t tos = 0; /* IPv4 type-of-service */
ushort_t off = 0; /* set DF bit */
static jmp_buf env; /* stack environment for longjmp() */
boolean_t raw_req; /* if sndsock for IPv4 must be raw */
/* Forwards */
static uint_t calc_packetlen(int, struct pr_set *);
extern int check_reply(struct msghdr *, int, int, uchar_t *, uchar_t *);
extern int check_reply6(struct msghdr *, int, int, uchar_t *, uchar_t *);
static double deltaT(struct timeval *, struct timeval *);
static char *device_name(struct ifaddrlist *, int, union any_in_addr *,
struct pr_set *);
extern void *find_ancillary_data(struct msghdr *, int, int);
static boolean_t has_addr(struct addrinfo *, union any_in_addr *);
static struct ifaddrlist *find_device(struct ifaddrlist *, int, char *);
static struct ifaddrlist *find_ifaddr(struct ifaddrlist *, int,
union any_in_addr *, int);
static void get_gwaddrs(char **, int, union any_in_addr *,
union any_in_addr *, int *, int *);
static void get_hostinfo(char *, int, struct addrinfo **);
char *inet_name(union any_in_addr *, int);
ushort_t in_cksum(ushort_t *, int);
extern int ip_hdr_length_v6(ip6_t *, int, uint8_t *);
extern char *pr_type(uchar_t);
extern char *pr_type6(uchar_t);
extern void print_addr(uchar_t *, int, struct sockaddr *);
extern void print_addr6(uchar_t *, int, struct sockaddr *);
extern boolean_t print_icmp_other(uchar_t, uchar_t);
extern boolean_t print_icmp_other6(uchar_t, uchar_t);
static void print_stats(int, int, double, double, double, double);
static void print_unknown_host_msg(const char *, const char *);
static void record_stats(double, int *, double *, double *, double *, double *);
static void resolve_nodes(int *, struct addrinfo **);
static void select_src_addr(union any_in_addr *, union any_in_addr *, int);
extern void send_probe(int, struct sockaddr *, struct ip *, int, int,
struct timeval *, int);
extern void send_probe6(int, struct msghdr *, struct ip *, int, int,
struct timeval *, int);
extern void set_ancillary_data(struct msghdr *, int, union any_in_addr *, int,
uint_t);
extern struct ip *set_buffers(int);
extern struct ip *set_buffers6(int);
extern void set_IPv4opt_sourcerouting(int, union any_in_addr *,
union any_in_addr *);
static void set_sin(struct sockaddr *, union any_in_addr *, int);
static int set_src_addr(struct pr_set *, struct ifaddrlist **);
static void setup_protocol(struct pr_set *, int);
static void setup_socket(struct pr_set *, int);
static void sig_handler(int);
static int str2int(const char *, const char *, int, int);
static double str2dbl(const char *, const char *, double, double);
static void trace_it(struct addrinfo *);
static void traceroute(union any_in_addr *, struct msghdr *, struct pr_set *,
int, struct ifaddrlist *);
static void tv_sub(struct timeval *, struct timeval *);
static void usage(void);
static int wait_for_reply(int, struct msghdr *, struct timeval *);
static double xsqrt(double);
/*
* main
*/
int
main(int argc, char **argv)
{
struct addrinfo *ai_dst = NULL; /* destination host */
/*
* "probing_successful" indicates if we could successfully send probes,
* not necessarily received reply from the target (this behavior is from
* the original traceroute). It's _B_FALSE if packlen is invalid, or no
* interfaces found.
*/
boolean_t probing_successful = _B_FALSE;
int longjmp_return; /* return value from longjump */
int i = 0;
char *cp;
int op;
char *ep;
char temp_buf[INET6_ADDRSTRLEN]; /* use for inet_ntop() */
double pause;
/*
* A raw socket will be used for IPv4 if there is sufficient
* privilege.
*/
raw_req = priv_ineffect(PRIV_NET_RAWACCESS);
/*
* We'll need the privilege only when we open the sockets; that's
* when we'll fail if the program has insufficient privileges.
*/
(void) __init_suid_priv(PU_CLEARLIMITSET, PRIV_NET_ICMPACCESS,
raw_req ? PRIV_NET_RAWACCESS : NULL, NULL);
(void) setlinebuf(stdout);
if ((cp = strrchr(argv[0], '/')) != NULL)
prog = cp + 1;
else
prog = argv[0];
opterr = 0;
while ((op = getopt(argc, argv, "adFIlnrSvxA:c:f:g:i:L:m:P:p:Q:q:s:"
"t:w:")) != EOF) {
switch (op) {
case 'A':
if (strcmp(optarg, "inet") == 0) {
family_input = AF_INET;
} else if (strcmp(optarg, "inet6") == 0) {
family_input = AF_INET6;
} else {
Fprintf(stderr,
"%s: unknown address family %s\n",
prog, optarg);
exit(EXIT_FAILURE);
}
break;
case 'a':
probe_all = _B_TRUE;
break;
case 'c':
class = str2int(optarg, "traffic class", 0,
MAX_TRAFFIC_CLASS);
break;
case 'd':
options |= SO_DEBUG;
break;
case 'f':
first_ttl = str2int(optarg, "first ttl", 1, MAXTTL);
break;
case 'F':
off = IP_DF;
break;
case 'g':
if (!raw_req) {
Fprintf(stderr,
"%s: privilege to specify a loose source "
"route gateway is unavailable\n",
prog);
exit(EXIT_FAILURE);
}
if (gw_count >= MAXMAX_GWS) {
Fprintf(stderr,
"%s: Too many gateways\n", prog);
exit(EXIT_FAILURE);
}
gwlist[gw_count] = strdup(optarg);
if (gwlist[gw_count] == NULL) {
Fprintf(stderr, "%s: strdup %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
++gw_count;
break;
case 'l':
showttl = _B_TRUE;
break;
case 'i':
/* this can be IF name or IF index */
if_index = (uint_t)strtol(optarg, &ep, 10);
/* convert IF index <--> IF name */
if (errno != 0 || *ep != '\0') {
device = optarg;
if_index = if_nametoindex((const char *)device);
/*
* In case it fails, check to see if the problem
* is other than "IF not found".
*/
if (if_index == 0 && errno != ENXIO) {
Fprintf(stderr, "%s: if_nametoindex:"
"%s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
} else {
device = (char *)malloc(LIFNAMSIZ + 1);
if (device == NULL) {
Fprintf(stderr, "%s: malloc: %s\n",
prog, strerror(errno));
exit(EXIT_FAILURE);
}
device = if_indextoname(if_index, device);
if (device != NULL) {
device[LIFNAMSIZ] = '\0';
} else if (errno != ENXIO) {
/*
* The problem was other than "index
* not found".
*/
Fprintf(stderr, "%s: if_indextoname:"
"%s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
}
if (device == NULL || if_index == 0) {
Fprintf(stderr, "%s: interface %s "
"doesn't match any actual interfaces\n",
prog, optarg);
exit(EXIT_FAILURE);
}
break;
case 'I':
useicmp = _B_TRUE;
break;
case 'L':
flow = str2int(optarg, "flow label", 0, MAX_FLOW_LABEL);
break;
case 'm':
max_ttl = str2int(optarg, "max ttl(hop limit)", 1,
MAXTTL);
break;
case 'n':
nflag = _B_TRUE;
break;
case 'P':
pause = str2dbl(optarg, "pause", 0, INT_MAX);
delay.tv_sec = (time_t)pause;
delay.tv_usec = (suseconds_t)((pause - delay.tv_sec) *
1000000);
break;
case 'p':
port = str2int(optarg, "port", 1, MAX_PORT);
break;
case 'Q':
max_timeout = str2int(optarg, "max timeout", 1, -1);
break;
case 'q':
nprobes = str2int(optarg, "nprobes", 1, -1);
break;
case 'r':
options |= SO_DONTROUTE;
break;
case 'S':
collect_stat = _B_TRUE;
break;
case 's':
/*
* set the ip source address of the outbound
* probe (e.g., on a multi-homed host).
*/
source_input = optarg;
break;
case 't':
tos = (uchar_t)str2int(optarg, "tos", 0, MAX_TOS);
settos = _B_TRUE;
break;
case 'v':
verbose = _B_TRUE;
break;
case 'x':
docksum = _B_FALSE;
break;
case 'w':
waittime = str2int(optarg, "wait time", 2, -1);
break;
default:
usage();
break;
}
}
/*
* If it's probe_all, SIGQUIT makes traceroute exit(). But we set the
* address to jump back to in traceroute(). Until then, we'll need to
* temporarily specify one.
*/
if (probe_all) {
if ((longjmp_return = setjmp(env)) != 0) {
if (longjmp_return == SIGQUIT) {
Printf("(exiting)\n");
exit(EXIT_SUCCESS);
} else { /* should never happen */
exit(EXIT_FAILURE);
}
}
(void) signal(SIGQUIT, sig_handler);
}
if ((gw_count > 0) && (options & SO_DONTROUTE)) {
Fprintf(stderr, "%s: loose source route gateways (-g)"
" cannot be specified when probe packets are sent"
" directly to a host on an attached network (-r)\n",
prog);
exit(EXIT_FAILURE);
}
i = argc - optind;
if (i == 1 || i == 2) {
hostname = argv[optind];
if (i == 2) {
/* accept any length now, we'll check it later */
packlen_input = str2int(argv[optind + 1],
"packet length", 0, -1);
}
} else {
usage();
}
if (first_ttl > max_ttl) {
Fprintf(stderr,
"%s: first ttl(hop limit) (%d) may not be greater"
" than max ttl(hop limit) (%d)\n",
prog, first_ttl, max_ttl);
exit(EXIT_FAILURE);
}
/* resolve hostnames */
resolve_nodes(&family_input, &ai_dst);
if (ai_dst == NULL) {
exit(EXIT_FAILURE);
}
/*
* If it's probe_all, SIGINT makes traceroute skip to probing next IP
* address of the target. The new interrupt handler is assigned in
* traceroute() function. Until then let's ignore the signal.
*/
if (probe_all)
(void) signal(SIGINT, SIG_IGN);
ident = (getpid() & 0xffff) | 0x8000;
/*
* We KNOW that probe_all == TRUE if family is AF_UNSPEC,
* since family is set to the specific AF found unless it's
* probe_all. So if family == AF_UNSPEC, we need to init pr4 and pr6.
*/
switch (family_input) {
case AF_UNSPEC:
pr4 = (struct pr_set *)malloc(sizeof (struct pr_set));
if (pr4 == NULL) {
Fprintf(stderr,
"%s: malloc %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
pr6 = (struct pr_set *)malloc(sizeof (struct pr_set));
if (pr6 == NULL) {
Fprintf(stderr,
"%s: malloc %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
setup_protocol(pr6, AF_INET6);
setup_protocol(pr4, AF_INET);
outip6 = (*pr6->set_buffers_fn)(pr6->packlen);
setup_socket(pr6, pr6->packlen);
outip4 = (*pr4->set_buffers_fn)(pr4->packlen);
setup_socket(pr4, pr4->packlen);
num_ifs6 = set_src_addr(pr6, &al6);
num_ifs4 = set_src_addr(pr4, &al4);
break;
case AF_INET6:
pr6 = (struct pr_set *)malloc(sizeof (struct pr_set));
if (pr6 == NULL) {
Fprintf(stderr,
"%s: malloc %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
setup_protocol(pr6, AF_INET6);
outip6 = (*pr6->set_buffers_fn)(pr6->packlen);
setup_socket(pr6, pr6->packlen);
num_ifs6 = set_src_addr(pr6, &al6);
break;
case AF_INET:
pr4 = (struct pr_set *)malloc(sizeof (struct pr_set));
if (pr4 == NULL) {
Fprintf(stderr,
"%s: malloc %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
setup_protocol(pr4, AF_INET);
outip4 = (*pr4->set_buffers_fn)(pr4->packlen);
setup_socket(pr4, pr4->packlen);
num_ifs4 = set_src_addr(pr4, &al4);
break;
default:
Fprintf(stderr, "%s: unknow address family.\n", prog);
exit(EXIT_FAILURE);
}
if (num_v4 + num_v6 > 1 && !probe_all) {
if (ai_dst->ai_family == AF_INET) {
Fprintf(stderr,
"%s: Warning: %s has multiple addresses;"
" using %s\n", prog, hostname,
inet_ntop(AF_INET,
/* LINTED E_BAD_PTR_CAST_ALIGN */
(void *)&((struct sockaddr_in *)
ai_dst->ai_addr)->sin_addr,
temp_buf, sizeof (temp_buf)));
} else {
Fprintf(stderr,
"%s: Warning: %s has multiple addresses;"
" using %s\n", prog, hostname,
inet_ntop(AF_INET6,
/* LINTED E_BAD_PTR_CAST_ALIGN */
(void *)&((struct sockaddr_in6 *)
ai_dst->ai_addr)->sin6_addr,
temp_buf, sizeof (temp_buf)));
}
}
if (num_ifs4 + num_ifs6 > 0) {
trace_it(ai_dst);
probing_successful = _B_TRUE;
}
(void) close(rcvsock4);
(void) close(sndsock4);
(void) close(rcvsock6);
(void) close(sndsock6);
/*
* if we could probe any of the IP addresses of the target, that means
* this was a successful operation
*/
if (probing_successful)
return (EXIT_SUCCESS);
else
return (EXIT_FAILURE);
}
/*
* print "unknown host" message
*/
static void
print_unknown_host_msg(const char *protocol, const char *host)
{
Fprintf(stderr, "%s: unknown%s host %s\n", prog, protocol, host);
}
/*
* resolve destination host and gateways
*/
static void
resolve_nodes(int *family, struct addrinfo **ai_dstp)
{
struct addrinfo *ai_dst = NULL;
struct addrinfo *aip = NULL;
int num_resolved_gw = 0;
int num_resolved_gw6 = 0;
get_hostinfo(hostname, *family, &ai_dst);
if (ai_dst == NULL) {
print_unknown_host_msg("", hostname);
exit(EXIT_FAILURE);
}
/* Get a count of the v4 & v6 addresses */
for (aip = ai_dst; aip != NULL; aip = aip->ai_next) {
switch (aip->ai_family) {
case AF_INET:
num_v4++;
break;
case AF_INET6:
num_v6++;
break;
}
}
if (*family == AF_UNSPEC && !probe_all) {
*family = ai_dst->ai_family;
}
/* resolve gateways */
if (gw_count > 0) {
get_gwaddrs(gwlist, *family, gwIPlist, gwIP6list,
&num_resolved_gw, &num_resolved_gw6);
/* we couldn't resolve a gateway as an IPv6 host */
if (num_resolved_gw6 != gw_count && num_v6 != 0) {
if (*family == AF_INET6 || *family == AF_UNSPEC)
print_unknown_host_msg(" IPv6",
gwlist[num_resolved_gw6]);
num_v6 = 0;
}
/* we couldn't resolve a gateway as an IPv4 host */
if (num_resolved_gw != gw_count && num_v4 != 0) {
if (*family == AF_INET || *family == AF_UNSPEC)
print_unknown_host_msg(" IPv4",
gwlist[num_resolved_gw]);
num_v4 = 0;
}
}
*ai_dstp = (num_v4 + num_v6 > 0) ? ai_dst : NULL;
}
/*
* Given IP address or hostname, return v4 and v6 hostinfo lists.
* Assumes that hostinfo ** ptrs are non-null.
*/
static void
get_hostinfo(char *host, int family, struct addrinfo **aipp)
{
struct addrinfo hints, *ai;
struct in6_addr addr6;
struct in_addr addr;
char temp_buf[INET6_ADDRSTRLEN]; /* use for inet_ntop() */
int rc;
/*
* Take care of v4-mapped addresses. It should run same as v4, after
* chopping off the prefix, leaving the IPv4 address
*/
if ((inet_pton(AF_INET6, host, &addr6) > 0) &&
IN6_IS_ADDR_V4MAPPED(&addr6)) {
/* peel off the "mapping" stuff, leaving 32 bit IPv4 address */
IN6_V4MAPPED_TO_INADDR(&addr6, &addr);
/* convert it back to a string */
(void) inet_ntop(AF_INET, (void *)&addr, temp_buf,
sizeof (temp_buf));
/* now the host is an IPv4 address */
(void) strcpy(host, temp_buf);
/*
* If it's a mapped address, we convert it into IPv4
* address because traceroute will send and receive IPv4
* packets for that address. Therefore, it's a failure case to
* ask get_hostinfo() to treat a mapped address as an IPv6
* address.
*/
if (family == AF_INET6) {
return;
}
}
(void) memset(&hints, 0, sizeof (hints));
hints.ai_family = family;
hints.ai_flags = AI_ADDRCONFIG | AI_CANONNAME;
rc = getaddrinfo(host, NULL, &hints, &ai);
if (rc != 0) {
if (rc != EAI_NONAME)
Fprintf(stderr, "%s: getaddrinfo: %s\n", prog,
gai_strerror(rc));
*aipp = NULL;
return;
}
*aipp = ai;
}
/*
* Calculate the packet length to be used, and check against the valid range.
* Returns -1 if range check fails.
*/
static uint_t
calc_packetlen(int plen_input, struct pr_set *pr)
{
int minpacket; /* min ip packet size */
int optlen; /* length of ip options */
int plen;
/*
* LBNL bug fixed: miscalculation of optlen
*/
if (gw_count > 0) {
/*
* IPv4:
* ----
* 5 (NO OPs) + 3 (code, len, ptr) + gateways
* IP options field can hold up to 9 gateways. But the API
* allows you to specify only 8, because the last one is the
* destination host. When this packet is sent, on the wire
* you see one gateway replaced by 4 NO OPs. The other 1 NO
* OP is for alignment
*
* IPv6:
* ----
* Well, formula is different, but the result is same.
* 8 byte fixed part for Type 0 Routing header, followed by
* gateway addresses
*/
optlen = 8 + gw_count * pr->addr_len;
} else {
optlen = 0;
}
/* take care of the packet length calculations and checks */
minpacket = pr->ip_hdr_len + sizeof (struct outdata) + optlen;
if (useicmp)
minpacket += pr->icmp_minlen; /* minimum ICMP header size */
else
minpacket += sizeof (struct udphdr);
plen = plen_input;
if (plen == 0) {
plen = minpacket; /* minimum sized packet */
} else if (minpacket > plen || plen > IP_MAXPACKET) {
Fprintf(stderr, "%s: %s packet size must be >= %d and <= %d\n",
prog, pr->name, minpacket, IP_MAXPACKET);
return (0);
}
return (plen);
}
/*
* Sets the source address by resolving -i and -s arguments, or if -i and -s
* don't dictate any, it sets the pick_src to make sure traceroute uses the
* kernel's pick of the source address.
* Returns number of interfaces configured on the source host, 0 on error or
* there's no interface which is up amd not a loopback.
*/
static int
set_src_addr(struct pr_set *pr, struct ifaddrlist **alp)
{
union any_in_addr *ap;
struct ifaddrlist *al = NULL;
struct ifaddrlist *tmp1_al = NULL;
struct ifaddrlist *tmp2_al = NULL;
/* LINTED E_BAD_PTR_CAST_ALIGN */
struct sockaddr_in *sin_from = (struct sockaddr_in *)pr->from;
/* LINTED E_BAD_PTR_CAST_ALIGN */
struct sockaddr_in6 *sin6_from = (struct sockaddr_in6 *)pr->from;
struct addrinfo *aip;
char errbuf[ERRBUFSIZE];
char temp_buf[INET6_ADDRSTRLEN]; /* use for inet_ntop() */
int num_ifs; /* all the interfaces */
int num_src_ifs; /* exclude loopback and down */
int i;
source = source_input;
/* get the interface address list */
num_ifs = ifaddrlist(&al, pr->family, errbuf);
if (num_ifs < 0) {
Fprintf(stderr, "%s: ifaddrlist: %s\n", prog, errbuf);
exit(EXIT_FAILURE);
}
num_src_ifs = 0;
for (i = 0; i < num_ifs; i++) {
if (!(al[i].flags & IFF_LOOPBACK) && (al[i].flags & IFF_UP))
num_src_ifs++;
}
if (num_src_ifs == 0) {
Fprintf(stderr, "%s: can't find any %s network interfaces\n",
prog, pr->name);
return (0);
}
/* verify the device */
if (device != NULL) {
tmp1_al = find_device(al, num_ifs, device);
if (tmp1_al == NULL) {
Fprintf(stderr, "%s: %s (index %d) is an invalid %s"
" interface\n", prog, device, if_index, pr->name);
free(al);
return (0);
}
}
/* verify the source address */
if (source != NULL) {
get_hostinfo(source, pr->family, &aip);
if (aip == NULL) {
Fprintf(stderr,
"%s: %s is an invalid %s source address\n",
prog, source, pr->name);
free(al);
return (0);
}
source = aip->ai_canonname;
if (pr->family == AF_INET)
ap = (union any_in_addr *)
/* LINTED E_BAD_PTR_CAST_ALIGN */
&((struct sockaddr_in *)
aip->ai_addr)->sin_addr;
else
ap = (union any_in_addr *)
/* LINTED E_BAD_PTR_CAST_ALIGN */
&((struct sockaddr_in6 *)
aip->ai_addr)->sin6_addr;
/*
* LBNL bug fixed: used to accept any src address
*/
tmp2_al = find_ifaddr(al, num_ifs, ap, pr->family);
if (tmp2_al == NULL) {
Fprintf(stderr,
"%s: %s is not a local %s address\n",
prog, inet_ntop(pr->family, ap,
temp_buf, sizeof (temp_buf)),
pr->name);
free(al);
freeaddrinfo(aip);
return (0);
}
}
pick_src = _B_FALSE;
if (source == NULL) { /* no -s used */
if (device == NULL) { /* no -i used, no -s used */
pick_src = _B_TRUE;
} else { /* -i used, no -s used */
/*
* -i used, but not -s, and it's IPv4: set the source
* address to whatever the interface has configured on
* it.
*/
if (pr->family == AF_INET)
set_sin(pr->from, &(tmp1_al->addr), pr->family);
else
pick_src = _B_TRUE;
}
} else { /* -s used */
if (device == NULL) { /* no -i used, -s used */
set_sin(pr->from, ap, pr->family);
if (aip->ai_next != NULL) {
Fprintf(stderr,
"%s: Warning: %s has multiple "
"addresses; using %s\n",
prog, source,
inet_ntop(pr->family,
(const void *)pr->from_sin_addr,
temp_buf, sizeof (temp_buf)));
}
} else { /* -i and -s used */
/*
* Make sure the source specified matches the
* interface address. You only care about this for IPv4
* IPv6 can handle IF not matching src address
*/
if (pr->family == AF_INET) {
if (!has_addr(aip, &tmp1_al->addr)) {
Fprintf(stderr,
"%s: %s is not on interface %s\n",
prog, source, device);
exit(EXIT_FAILURE);
}
/*
* make sure we use the one matching the
* interface's address
*/
*ap = tmp1_al->addr;
}
set_sin(pr->from, ap, pr->family);
}
}
/*
* Binding at this point will set the source address to be used
* for both IPv4 (when raw IP datagrams are not required) and
* IPv6. If the address being bound to is zero, then the kernel
* will end up choosing the source address when the datagram is
* sent.
*
* For raw IPv4 datagrams, the source address is initialized
* within traceroute() along with the outbound destination
* address.
*/
if (pr->family == AF_INET && !raw_req) {
sin_from->sin_family = AF_INET;
sin_from->sin_port = htons(ident);
if (bind(sndsock4, (struct sockaddr *)pr->from,
sizeof (struct sockaddr_in)) < 0) {
Fprintf(stderr, "%s: bind: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
} else if (pr->family == AF_INET6) {
sin6_from->sin6_family = AF_INET6;
sin6_from->sin6_port = htons(ident);
if (bind(sndsock6, (struct sockaddr *)pr->from,
sizeof (struct sockaddr_in6)) < 0) {
Fprintf(stderr, "%s: bind: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
whereto6.sin6_flowinfo = htonl((class << 20) | flow);
}
*alp = al;
return (num_ifs);
}
/*
* Returns the complete ifaddrlist structure matching the desired interface
* address. Ignores interfaces which are either down or loopback.
*/
static struct ifaddrlist *
find_ifaddr(struct ifaddrlist *al, int len, union any_in_addr *addr,
int family)
{
struct ifaddrlist *tmp_al = al;
int i;
size_t addr_len = (family == AF_INET) ? sizeof (struct in_addr) :
sizeof (struct in6_addr);
for (i = 0; i < len; i++, tmp_al++) {
if ((!(tmp_al->flags & IFF_LOOPBACK) &&
(tmp_al->flags & IFF_UP)) &&
(memcmp(&tmp_al->addr, addr, addr_len) == 0))
break;
}
if (i < len) {
return (tmp_al);
} else {
return (NULL);
}
}
/*
* Returns the complete ifaddrlist structure matching the desired interface name
* Ignores interfaces which are either down or loopback.
*/
static struct ifaddrlist *
find_device(struct ifaddrlist *al, int len, char *device)
{
struct ifaddrlist *tmp_al = al;
int i;
for (i = 0; i < len; i++, tmp_al++) {
if ((!(tmp_al->flags & IFF_LOOPBACK) &&
(tmp_al->flags & IFF_UP)) &&
(strcmp(tmp_al->device, device) == 0))
break;
}
if (i < len) {
return (tmp_al);
} else {
return (NULL);
}
}
/*
* returns _B_TRUE if given hostinfo contains the given address
*/
static boolean_t
has_addr(struct addrinfo *ai, union any_in_addr *addr)
{
struct addrinfo *ai_tmp = NULL;
union any_in_addr *ap;
for (ai_tmp = ai; ai_tmp != NULL; ai_tmp = ai_tmp->ai_next) {
if (ai_tmp->ai_family == AF_INET6)
continue;
ap = (union any_in_addr *)
/* LINTED E_BAD_PTR_CAST_ALIGN */
&((struct sockaddr_in *)ai_tmp->ai_addr)->sin_addr;
if (memcmp(ap, addr, sizeof (struct in_addr)) == 0)
break;
}
if (ai_tmp != NULL) {
return (_B_TRUE);
} else {
return (_B_FALSE);
}
}
/*
* Resolve the gateway names, splitting results into v4 and v6 lists.
* Gateway addresses are added to the appropriate passed-in array; the
* number of resolved gateways for each af is returned in resolved[6].
* Assumes that passed-in arrays are large enough for MAX_GWS[6] addrs
* and resolved[6] ptrs are non-null; ignores array and counter if the
* address family param makes them irrelevant.
*/
static void
get_gwaddrs(char **gwlist, int family, union any_in_addr *gwIPlist,
union any_in_addr *gwIPlist6, int *resolved, int *resolved6)
{
int i;
boolean_t check_v4 = _B_TRUE, check_v6 = _B_TRUE;
struct addrinfo *ai = NULL;
struct addrinfo *aip = NULL;
*resolved = *resolved6 = 0;
switch (family) {
case AF_UNSPEC:
break;
case AF_INET:
check_v6 = _B_FALSE;
break;
case AF_INET6:
check_v4 = _B_FALSE;
break;
default:
return;
}
if (check_v4 && gw_count >= MAX_GWS) {
check_v4 = _B_FALSE;
Fprintf(stderr, "%s: too many IPv4 gateways\n", prog);
num_v4 = 0;
}
if (check_v6 && gw_count >= MAX_GWS6) {
check_v6 = _B_FALSE;
Fprintf(stderr, "%s: too many IPv6 gateways\n", prog);
num_v6 = 0;
}
for (i = 0; i < gw_count; i++) {
if (!check_v4 && !check_v6)
return;
get_hostinfo(gwlist[i], family, &ai);
if (ai == NULL)
return;
if (check_v4 && num_v4 != 0) {
check_v4 = _B_FALSE;
for (aip = ai; aip != NULL; aip = aip->ai_next) {
if (aip->ai_family == AF_INET) {
/* LINTED E_BAD_PTR_CAST_ALIGN */
bcopy(&((struct sockaddr_in *)
aip->ai_addr)->sin_addr,
&gwIPlist[i].addr,
aip->ai_addrlen);
(*resolved)++;
check_v4 = _B_TRUE;
break;
}
}
} else if (check_v4) {
check_v4 = _B_FALSE;
}
if (check_v6 && num_v6 != 0) {
check_v6 = _B_FALSE;
for (aip = ai; aip != NULL; aip = aip->ai_next) {
if (aip->ai_family == AF_INET6) {
/* LINTED E_BAD_PTR_CAST_ALIGN */
bcopy(&((struct sockaddr_in6 *)
aip->ai_addr)->sin6_addr,
&gwIPlist6[i].addr6,
aip->ai_addrlen);
(*resolved6)++;
check_v6 = _B_TRUE;
break;
}
}
} else if (check_v6) {
check_v6 = _B_FALSE;
}
}
freeaddrinfo(ai);
}
/*
* set protocol specific values here
*/
static void
setup_protocol(struct pr_set *pr, int family)
{
/*
* Set the global variables for each AF. This is going to save us lots
* of "if (family == AF_INET)... else .."
*/
pr->family = family;
if (family == AF_INET) {
if (!docksum) {
Fprintf(stderr,
"%s: Warning: checksums disabled\n", prog);
}
(void) strcpy(pr->name, "IPv4");
(void) strcpy(pr->icmp, "icmp");
pr->icmp_minlen = ICMP_MINLEN;
pr->addr_len = sizeof (struct in_addr);
pr->ip_hdr_len = sizeof (struct ip);
pr->sock_size = sizeof (struct sockaddr_in);
pr->to = (struct sockaddr *)&whereto;
pr->from = (struct sockaddr *)&wherefrom;
pr->from_sin_addr = (void *)&wherefrom.sin_addr;
pr->gwIPlist = gwIPlist;
pr->set_buffers_fn = set_buffers;
pr->check_reply_fn = check_reply;
pr->print_icmp_other_fn = print_icmp_other;
pr->print_addr_fn = print_addr;
pr->packlen = calc_packetlen(packlen_input, pr);
} else {
(void) strcpy(pr->name, "IPv6");
(void) strcpy(pr->icmp, "ipv6-icmp");
pr->icmp_minlen = ICMP6_MINLEN;
pr->addr_len = sizeof (struct in6_addr);
pr->ip_hdr_len = sizeof (struct ip6_hdr);
pr->sock_size = sizeof (struct sockaddr_in6);
pr->to = (struct sockaddr *)&whereto6;
pr->from = (struct sockaddr *)&wherefrom6;
pr->from_sin_addr = (void *)&wherefrom6.sin6_addr;
pr->gwIPlist = gwIP6list;
pr->set_buffers_fn = set_buffers6;
pr->check_reply_fn = check_reply6;
pr->print_icmp_other_fn = print_icmp_other6;
pr->print_addr_fn = print_addr6;
pr->packlen = calc_packetlen(packlen_input, pr);
}
if (pr->packlen == 0)
exit(EXIT_FAILURE);
}
/*
* setup the sockets for the given protocol's address family
*/
static void
setup_socket(struct pr_set *pr, int packet_len)
{
int on = 1;
struct protoent *pe;
int type;
int proto;
int int_op;
int rsock;
int ssock;
if ((pe = getprotobyname(pr->icmp)) == NULL) {
Fprintf(stderr, "%s: unknown protocol %s\n", prog, pr->icmp);
exit(EXIT_FAILURE);
}
/* privilege bracketing */
(void) __priv_bracket(PRIV_ON);
if ((rsock = socket(pr->family, SOCK_RAW, pe->p_proto)) < 0) {
Fprintf(stderr, "%s: icmp socket: %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
if (options & SO_DEBUG) {
if (setsockopt(rsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
sizeof (on)) < 0) {
Fprintf(stderr, "%s: SO_DEBUG: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
}
if (options & SO_DONTROUTE) {
if (setsockopt(rsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
sizeof (on)) < 0) {
Fprintf(stderr, "%s: SO_DONTROUTE: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
}
if (pr->family == AF_INET6) {
/* Enable receipt of destination address info */
if (setsockopt(rsock, IPPROTO_IPV6, IPV6_RECVPKTINFO,
(char *)&on, sizeof (on)) < 0) {
Fprintf(stderr, "%s: IPV6_RECVPKTINFO: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
/* Enable receipt of hoplimit info */
if (setsockopt(rsock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
(char *)&on, sizeof (on)) < 0) {
Fprintf(stderr, "%s: IPV6_RECVHOPLIMIT: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
}
/*
* Initialize the socket type and protocol based on the address
* family, whether or not a raw IP socket is required (for IPv4)
* or whether ICMP will be used instead of UDP.
*
* For historical reasons, the datagrams sent out by
* traceroute(1M) do not have the "don't fragment" flag set. For
* this reason as well as the ability to set the Loose Source and
* Record Route (LSRR) option, a raw IP socket will be used for
* IPv4 when run in the global zone. Otherwise, the actual
* datagram that will be sent will be a regular UDP or ICMP echo
* request packet. However for convenience and for future options
* when other IP header information may be specified using
* traceroute, the buffer including the raw IP and UDP or ICMP
* header is always filled in. When the probe is actually sent,
* the size of the request and the start of the packet is set
* according to the type of datagram to send.
*/
if (pr->family == AF_INET && raw_req) {
type = SOCK_RAW;
proto = IPPROTO_RAW;
} else if (useicmp) {
type = SOCK_RAW;
if (pr->family == AF_INET)
proto = IPPROTO_ICMP;
else
proto = IPPROTO_ICMPV6;
} else {
type = SOCK_DGRAM;
proto = IPPROTO_UDP;
}
ssock = socket(pr->family, type, proto);
if (ssock < 0) {
if (proto == IPPROTO_RAW) {
Fprintf(stderr, "%s: raw socket: %s\n", prog,
strerror(errno));
} else if (proto == IPPROTO_UDP) {
Fprintf(stderr, "%s: udp socket: %s\n", prog,
strerror(errno));
} else {
Fprintf(stderr, "%s: icmp socket: %s\n", prog,
strerror(errno));
}
exit(EXIT_FAILURE);
}
if (setsockopt(ssock, SOL_SOCKET, SO_SNDBUF, (char *)&packet_len,
sizeof (packet_len)) < 0) {
Fprintf(stderr, "%s: SO_SNDBUF: %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
if (pr->family == AF_INET && raw_req) {
if (setsockopt(ssock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
sizeof (on)) < 0) {
Fprintf(stderr, "%s: IP_HDRINCL: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
}
if (options & SO_DEBUG) {
if (setsockopt(ssock, SOL_SOCKET, SO_DEBUG, (char *)&on,
sizeof (on)) < 0) {
Fprintf(stderr, "%s: SO_DEBUG: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
}
if (options & SO_DONTROUTE) {
if (setsockopt(ssock, SOL_SOCKET, SO_DONTROUTE,
(char *)&on, sizeof (on)) < 0) {
Fprintf(stderr, "%s: SO_DONTROUTE: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
}
/*
* If a raw IPv4 packet is going to be sent, the Type of Service
* field in the packet will be initialized in set_buffers().
* Otherwise, it is initialized here using the IPPROTO_IP level
* socket option.
*/
if (settos && !raw_req) {
int_op = tos;
if (setsockopt(ssock, IPPROTO_IP, IP_TOS, (char *)&int_op,
sizeof (int_op)) < 0) {
Fprintf(stderr, "%s: IP_TOS: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
}
if (pr->family == AF_INET) {
rcvsock4 = rsock;
sndsock4 = ssock;
} else {
rcvsock6 = rsock;
sndsock6 = ssock;
}
/* Revert to non-privileged user after configuring sockets */
(void) __priv_bracket(PRIV_OFF);
}
/*
* If we are "probing all", this function calls traceroute() for each IP address
* of the target, otherwise calls only once. Returns _B_FALSE if traceroute()
* fails.
*/
static void
trace_it(struct addrinfo *ai_dst)
{
struct msghdr msg6;
int num_dst_IPaddrs;
struct addrinfo *aip;
int i;
if (!probe_all)
num_dst_IPaddrs = 1;
else
num_dst_IPaddrs = num_v4 + num_v6;
/*
* Initialize the msg6 structure using the hoplimit for the first
* probe packet, gateway addresses and the outgoing interface index.
*/
if (ai_dst->ai_family == AF_INET6 || (probe_all && num_v6)) {
msg6.msg_control = NULL;
msg6.msg_controllen = 0;
set_ancillary_data(&msg6, first_ttl, pr6->gwIPlist, gw_count,
if_index);
}
/* run traceroute for all the IP addresses of the multihomed dest */
for (aip = ai_dst, i = 0; i < num_dst_IPaddrs && aip != NULL; i++) {
union any_in_addr *addrp;
if (aip->ai_family == AF_INET) {
addrp = (union any_in_addr *)
/* LINTED E_BAD_PTR_CAST_ALIGN */
&((struct sockaddr_in *)
aip->ai_addr)->sin_addr;
set_sin((struct sockaddr *)pr4->to, addrp,
aip->ai_family);
traceroute(addrp, &msg6, pr4, num_ifs4, al4);
} else {
addrp = (union any_in_addr *)
/* LINTED E_BAD_PTR_CAST_ALIGN */
&((struct sockaddr_in6 *)
aip->ai_addr)->sin6_addr;
set_sin((struct sockaddr *)pr6->to, addrp,
aip->ai_family);
traceroute(addrp, &msg6, pr6, num_ifs6, al6);
}
aip = aip->ai_next;
if (i < (num_dst_IPaddrs - 1))
(void) putchar('\n');
}
}
/*
* set the IP address in a sockaddr struct
*/
static void
set_sin(struct sockaddr *sock, union any_in_addr *addr, int family)
{
sock->sa_family = family;
if (family == AF_INET)
/* LINTED E_BAD_PTR_CAST_ALIGN */
((struct sockaddr_in *)sock)->sin_addr = addr->addr;
else
/* LINTED E_BAD_PTR_CAST_ALIGN */
((struct sockaddr_in6 *)sock)->sin6_addr = addr->addr6;
}
/*
* returns the IF name on which the given IP address is configured
*/
static char *
device_name(struct ifaddrlist *al, int len, union any_in_addr *ip_addr,
struct pr_set *pr)
{
int i;
struct ifaddrlist *tmp_al;
tmp_al = al;
for (i = 0; i < len; i++, tmp_al++) {
if (memcmp(&tmp_al->addr, ip_addr, pr->addr_len) == 0) {
return (tmp_al->device);
}
}
return (NULL);
}
/*
* Trace the route to the host with given IP address.
*/
static void
traceroute(union any_in_addr *ip_addr, struct msghdr *msg6, struct pr_set *pr,
int num_ifs, struct ifaddrlist *al)
{
int ttl;
int probe;
uchar_t type; /* icmp type */
uchar_t code; /* icmp code */
int reply;
int seq = 0;
char temp_buf[INET6_ADDRSTRLEN]; /* use for inet_ntop() */
int longjmp_return; /* return value from longjump */
struct ip *ip = (struct ip *)packet;
boolean_t got_there = _B_FALSE; /* we hit the destination */
static boolean_t first_pkt = _B_TRUE;
int hoplimit; /* hoplimit for IPv6 packets */
struct in6_addr addr6;
int num_src_ifs; /* excludes down and loopback */
struct msghdr in_msg;
struct iovec iov;
int *intp;
int sndsock;
int rcvsock;
msg6->msg_name = pr->to;
msg6->msg_namelen = sizeof (struct sockaddr_in6);
sndsock = (pr->family == AF_INET) ? sndsock4 : sndsock6;
rcvsock = (pr->family == AF_INET) ? rcvsock4 : rcvsock6;
/* carry out the source address selection */
if (pick_src) {
union any_in_addr src_addr;
char *dev_name;
int i;
/*
* If there's a gateway, a routing header as a consequence, our
* kernel picks the source address based on the first hop
* address, rather than final destination address.
*/
if (gw_count > 0) {
(void) select_src_addr(pr->gwIPlist, &src_addr,
pr->family);
} else {
(void) select_src_addr(ip_addr, &src_addr, pr->family);
}
set_sin(pr->from, &src_addr, pr->family);
/* filter out down and loopback interfaces */
num_src_ifs = 0;
for (i = 0; i < num_ifs; i++) {
if (!(al[i].flags & IFF_LOOPBACK) &&
(al[i].flags & IFF_UP))
num_src_ifs++;
}
if (num_src_ifs > 1) {
dev_name = device_name(al, num_ifs, &src_addr, pr);
if (dev_name == NULL)
dev_name = "?";
Fprintf(stderr,
"%s: Warning: Multiple interfaces found;"
" using %s @ %s\n",
prog, inet_ntop(pr->family,
(const void *)pr->from_sin_addr,
temp_buf, sizeof (temp_buf)),
dev_name);
}
}
if (pr->family == AF_INET) {
outip4->ip_src = *(struct in_addr *)pr->from_sin_addr;
outip4->ip_dst = ip_addr->addr;
}
/*
* If the hostname is an IPv6 literal address, let's not print it twice.
*/
if (pr->family == AF_INET6 &&
inet_pton(AF_INET6, hostname, &addr6) > 0) {
Fprintf(stderr, "%s to %s", prog, hostname);
} else {
Fprintf(stderr, "%s to %s (%s)", prog, hostname,
inet_ntop(pr->family, (const void *)ip_addr, temp_buf,
sizeof (temp_buf)));
}
if (source)
Fprintf(stderr, " from %s", source);
Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl,
pr->packlen);
(void) fflush(stderr);
/*
* Setup the source routing for IPv4. For IPv6, we did the required
* setup in the caller function, trace_it(), because it's independent
* from the IP address of target.
*/
if (pr->family == AF_INET && gw_count > 0)
set_IPv4opt_sourcerouting(sndsock, ip_addr, pr->gwIPlist);
if (probe_all) {
/* interrupt handler sig_handler() jumps back to here */
if ((longjmp_return = setjmp(env)) != 0) {
switch (longjmp_return) {
case SIGINT:
Printf("(skipping)\n");
return;
case SIGQUIT:
Printf("(exiting)\n");
exit(EXIT_SUCCESS);
default: /* should never happen */
exit(EXIT_FAILURE);
}
}
(void) signal(SIGINT, sig_handler);
}
for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
union any_in_addr lastaddr;
int timeouts = 0;
double rtt; /* for statistics */
int nreceived = 0;
double rttmin, rttmax;
double rttsum, rttssq;
int unreachable;
got_there = _B_FALSE;
unreachable = 0;
/*
* The following line clears both IPv4 and IPv6 address stored
* in the union.
*/
lastaddr.addr6 = in6addr_any;
if ((ttl == (first_ttl + 1)) && (options & SO_DONTROUTE)) {
Fprintf(stderr,
"%s: host %s is not on a directly-attached"
" network\n", prog, hostname);
break;
}
Printf("%2d ", ttl);
(void) fflush(stdout);
for (probe = 0; (probe < nprobes) && (timeouts < max_timeout);
++probe) {
int cc;
struct timeval t1, t2;
/*
* Put a delay before sending this probe packet. Don't
* delay it if it's the very first packet.
*/
if (!first_pkt) {
if (delay.tv_sec > 0)
(void) sleep((uint_t)delay.tv_sec);
if (delay.tv_usec > 0)
(void) usleep(delay.tv_usec);
} else {
first_pkt = _B_FALSE;
}
(void) gettimeofday(&t1, NULL);
if (pr->family == AF_INET) {
send_probe(sndsock, pr->to, outip4, seq, ttl,
&t1, pr->packlen);
} else {
send_probe6(sndsock, msg6, outip6, seq, ttl,
&t1, pr->packlen);
}
/* prepare msghdr for recvmsg() */
in_msg.msg_name = pr->from;
in_msg.msg_namelen = pr->sock_size;
iov.iov_base = (char *)packet;
iov.iov_len = sizeof (packet);
in_msg.msg_iov = &iov;
in_msg.msg_iovlen = 1;
in_msg.msg_control = ancillary_data;
in_msg.msg_controllen = sizeof (ancillary_data);
while ((cc = wait_for_reply(rcvsock, &in_msg,
&t1)) != 0) {
(void) gettimeofday(&t2, NULL);
reply = (*pr->check_reply_fn) (&in_msg, cc, seq,
&type, &code);
in_msg.msg_controllen =
sizeof (ancillary_data);
/* Skip short packet */
if (reply == REPLY_SHORT_PKT) {
continue;
}
timeouts = 0;
/*
* if reply comes from a different host, print
* the hostname
*/
if (memcmp(pr->from_sin_addr, &lastaddr,
pr->addr_len) != 0) {
(*pr->print_addr_fn) ((uchar_t *)packet,
cc, pr->from);
/* store the address response */
(void) memcpy(&lastaddr,
pr->from_sin_addr, pr->addr_len);
}
rtt = deltaT(&t1, &t2);
if (collect_stat) {
record_stats(rtt, &nreceived, &rttmin,
&rttmax, &rttsum, &rttssq);
} else {
Printf(" %.3f ms", rtt);
}
if (pr->family == AF_INET6) {
intp =
(int *)find_ancillary_data(&in_msg,
IPPROTO_IPV6, IPV6_HOPLIMIT);
if (intp == NULL) {
Fprintf(stderr,
"%s: can't find "
"IPV6_HOPLIMIT ancillary "
"data\n", prog);
exit(EXIT_FAILURE);
}
hoplimit = *intp;
}
if (reply == REPLY_GOT_TARGET) {
got_there = _B_TRUE;
if (((pr->family == AF_INET) &&
(ip->ip_ttl <= 1)) ||
((pr->family == AF_INET6) &&
(hoplimit <= 1)))
Printf(" !");
}
if (!collect_stat && showttl) {
if (pr->family == AF_INET) {
Printf(" (ttl=%d)",
(int)ip->ip_ttl);
} else if (hoplimit != -1) {
Printf(" (hop limit=%d)",
hoplimit);
}
}
if (reply == REPLY_GOT_OTHER) {
if ((*pr->print_icmp_other_fn)
(type, code)) {
unreachable++;
}
}
/* special case */
if (pr->family == AF_INET &&
type == ICMP_UNREACH &&
code == ICMP_UNREACH_PROTOCOL)
got_there = _B_TRUE;
break;
}
seq = (seq + 1) % (MAX_SEQ + 1);
if (cc == 0) {
Printf(" *");
timeouts++;
}
(void) fflush(stdout);
}
if (collect_stat) {
print_stats(probe, nreceived, rttmin, rttmax, rttsum,
rttssq);
}
(void) putchar('\n');
/* either we hit the target or received too many unreachables */
if (got_there ||
(unreachable > 0 && unreachable >= nprobes - 1))
break;
}
/* Ignore the SIGINT between traceroute() runs */
if (probe_all)
(void) signal(SIGINT, SIG_IGN);
}
/*
* for a given destination address and address family, it finds out what
* source address kernel is going to pick
*/
static void
select_src_addr(union any_in_addr *dst_addr, union any_in_addr *src_addr,
int family)
{
int tmp_fd;
struct sockaddr *sock;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
size_t sock_len;
sock = (struct sockaddr *)malloc(sizeof (struct sockaddr_in6));
if (sock == NULL) {
Fprintf(stderr, "%s: malloc %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
(void) bzero(sock, sizeof (struct sockaddr_in6));
if (family == AF_INET) {
/* LINTED E_BAD_PTR_CAST_ALIGN */
sin = (struct sockaddr_in *)sock;
sin->sin_family = AF_INET;
sin->sin_addr = dst_addr->addr;
sin->sin_port = IPPORT_ECHO; /* port shouldn't be 0 */
sock_len = sizeof (struct sockaddr_in);
} else {
/* LINTED E_BAD_PTR_CAST_ALIGN */
sin6 = (struct sockaddr_in6 *)sock;
sin6->sin6_family = AF_INET6;
sin6->sin6_addr = dst_addr->addr6;
sin6->sin6_port = IPPORT_ECHO; /* port shouldn't be 0 */
sock_len = sizeof (struct sockaddr_in6);
}
/* open a UDP socket */
if ((tmp_fd = socket(family, SOCK_DGRAM, 0)) < 0) {
Fprintf(stderr, "%s: udp socket: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
/* connect it */
if (connect(tmp_fd, sock, sock_len) < 0) {
/*
* If there's no route to the destination, this connect() call
* fails. We just return all-zero (wildcard) as the source
* address, so that user can get to see "no route to dest"
* message, as it'll try to send the probe packet out and will
* receive ICMP unreachable.
*/
if (family == AF_INET)
src_addr->addr.s_addr = INADDR_ANY;
else
src_addr->addr6 = in6addr_any;
free(sock);
return;
}
/* get the local sock info */
if (getsockname(tmp_fd, sock, &sock_len) < 0) {
Fprintf(stderr, "%s: getsockname: %s\n", prog,
strerror(errno));
exit(EXIT_FAILURE);
}
if (family == AF_INET) {
/* LINTED E_BAD_PTR_CAST_ALIGN */
sin = (struct sockaddr_in *)sock;
src_addr->addr = sin->sin_addr;
} else {
/* LINTED E_BAD_PTR_CAST_ALIGN */
sin6 = (struct sockaddr_in6 *)sock;
src_addr->addr6 = sin6->sin6_addr;
}
free(sock);
(void) close(tmp_fd);
}
/*
* Checksum routine for Internet Protocol family headers (C Version)
*/
ushort_t
in_cksum(ushort_t *addr, int len)
{
int nleft = len;
ushort_t *w = addr;
ushort_t answer;
int sum = 0;
/*
* Our algorithm is simple, using a 32 bit accumulator (sum),
* we add sequential 16 bit words to it, and at the end, fold
* back all the carry bits from the top 16 bits into the lower
* 16 bits.
*/
while (nleft > 1) {
sum += *w++;
nleft -= 2;
}
/* mop up an odd byte, if necessary */
if (nleft == 1)
sum += *(uchar_t *)w;
/* add back carry outs from top 16 bits to low 16 bits */
sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
sum += (sum >> 16); /* add carry */
answer = ~sum; /* truncate to 16 bits */
return (answer);
}
/*
* Wait until a reply arrives or timeout occurs. If packet arrived, read it
* return the size of the packet read.
*/
static int
wait_for_reply(int sock, struct msghdr *msg, struct timeval *tp)
{
fd_set fds;
struct timeval now, wait;
int cc = 0;
int result;
(void) FD_ZERO(&fds);
FD_SET(sock, &fds);
wait.tv_sec = tp->tv_sec + waittime;
wait.tv_usec = tp->tv_usec;
(void) gettimeofday(&now, NULL);
tv_sub(&wait, &now);
if (wait.tv_sec < 0 || wait.tv_usec < 0)
return (0);
result = select(sock + 1, &fds, (fd_set *)NULL, (fd_set *)NULL, &wait);
if (result == -1) {
if (errno != EINTR) {
Fprintf(stderr, "%s: select: %s\n", prog,
strerror(errno));
}
} else if (result > 0)
cc = recvmsg(sock, msg, 0);
return (cc);
}
/*
* Construct an Internet address representation. If the nflag has been supplied,
* give numeric value, otherwise try for symbolic name.
*/
char *
inet_name(union any_in_addr *in, int family)
{
char *cp;
static boolean_t first = _B_TRUE;
static char domain[NI_MAXHOST + 1];
static char line[NI_MAXHOST + 1]; /* assuming */
/* (NI_MAXHOST + 1) >= INET6_ADDRSTRLEN */
char hbuf[NI_MAXHOST];
socklen_t slen;
struct sockaddr_in sin;
struct sockaddr_in6 sin6;
struct sockaddr *sa;
int flags;
switch (family) {
case AF_INET:
slen = sizeof (struct sockaddr_in);
sin.sin_addr = in->addr;
sin.sin_port = 0;
sa = (struct sockaddr *)&sin;
break;
case AF_INET6:
slen = sizeof (struct sockaddr_in6);
sin6.sin6_addr = in->addr6;
sin6.sin6_port = 0;
sa = (struct sockaddr *)&sin6;
break;
deafult:
(void) snprintf(line, sizeof (line),
"<invalid address family>");
return (line);
}
sa->sa_family = family;
if (first && !nflag) {
/* find out the domain name */
first = _B_FALSE;
if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
(cp = strchr(domain, '.')) != NULL) {
(void) strncpy(domain, cp + 1, sizeof (domain) - 1);
domain[sizeof (domain) - 1] = '\0';
} else {
domain[0] = '\0';
}
}
flags = (nflag) ? NI_NUMERICHOST : NI_NAMEREQD;
if (getnameinfo(sa, slen, hbuf, sizeof (hbuf), NULL, 0, flags) != 0) {
if (inet_ntop(family, (const void *)&in->addr6,
hbuf, sizeof (hbuf)) == NULL)
hbuf[0] = 0;
} else if (!nflag && (cp = strchr(hbuf, '.')) != NULL &&
strcmp(cp + 1, domain) == 0) {
*cp = '\0';
}
(void) strlcpy(line, hbuf, sizeof (line));
return (line);
}
/*
* return the difference (in msec) between two time values
*/
static double
deltaT(struct timeval *t1p, struct timeval *t2p)
{
double dt;
dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
(double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
return (dt);
}
/*
* Subtract 2 timeval structs: out = out - in.
* Out is assumed to be >= in.
*/
static void
tv_sub(struct timeval *out, struct timeval *in)
{
if ((out->tv_usec -= in->tv_usec) < 0) {
--out->tv_sec;
out->tv_usec += 1000000;
}
out->tv_sec -= in->tv_sec;
}
/*
* record statistics
*/
static void
record_stats(double rtt, int *nreceived, double *rttmin, double *rttmax,
double *rttsum, double *rttssq)
{
if (*nreceived == 0) {
*rttmin = rtt;
*rttmax = rtt;
*rttsum = rtt;
*rttssq = rtt * rtt;
} else {
if (rtt < *rttmin)
*rttmin = rtt;
if (rtt > *rttmax)
*rttmax = rtt;
*rttsum += rtt;
*rttssq += rtt * rtt;
}
(*nreceived)++;
}
/*
* display statistics
*/
static void
print_stats(int ntransmitted, int nreceived, double rttmin, double rttmax,
double rttsum, double rttssq)
{
double rttavg; /* average round-trip time */
double rttstd; /* rtt standard deviation */
if (ntransmitted > 0 && ntransmitted >= nreceived) {
int missed = ntransmitted - nreceived;
double loss = 100 * (double)missed / (double)ntransmitted;
if (nreceived > 0) {
rttavg = rttsum / nreceived;
rttstd = rttssq - (rttavg * rttsum);
rttstd = xsqrt(rttstd / nreceived);
Printf(" %.3f", rttmin);
Printf("/%.3f", rttavg);
Printf("/%.3f", rttmax);
Printf(" (%.3f) ms ", rttstd);
}
Printf(" %d/%d pkts", nreceived, ntransmitted);
if (nreceived == 0)
Printf(" (100%% loss)");
else
Printf(" (%.2g%% loss)", loss);
}
}
/*
* square root function
*/
double
xsqrt(double y)
{
double t, x;
if (y <= 0) {
return (0.0);
}
x = (y < 1.0) ? 1.0 : y;
do {
t = x;
x = (t + (y/t))/2.0;
} while (0 < x && x < t);
return (x);
}
/*
* String to double with optional min and max.
*/
static double
str2dbl(const char *str, const char *what, double mi, double ma)
{
double val;
char *ep;
errno = 0;
val = strtod(str, &ep);
if (errno != 0 || *ep != '\0') {
Fprintf(stderr, "%s: \"%s\" bad value for %s \n",
prog, str, what);
exit(EXIT_FAILURE);
}
if (val < mi && mi >= 0) {
Fprintf(stderr, "%s: %s must be >= %f\n", prog, what, mi);
exit(EXIT_FAILURE);
}
if (val > ma && ma >= 0) {
Fprintf(stderr, "%s: %s must be <= %f\n", prog, what, ma);
exit(EXIT_FAILURE);
}
return (val);
}
/*
* String to int with optional min and max. Handles decimal and hex.
*/
static int
str2int(const char *str, const char *what, int mi, int ma)
{
const char *cp;
int val;
char *ep;
errno = 0;
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
cp = str + 2;
val = (int)strtol(cp, &ep, 16);
} else {
val = (int)strtol(str, &ep, 10);
}
if (errno != 0 || *ep != '\0') {
Fprintf(stderr, "%s: \"%s\" bad value for %s \n",
prog, str, what);
exit(EXIT_FAILURE);
}
if (val < mi && mi >= 0) {
if (mi == 0) {
Fprintf(stderr, "%s: %s must be >= %d\n",
prog, what, mi);
} else {
Fprintf(stderr, "%s: %s must be > %d\n",
prog, what, mi - 1);
}
exit(EXIT_FAILURE);
}
if (val > ma && ma >= 0) {
Fprintf(stderr, "%s: %s must be <= %d\n", prog, what, ma);
exit(EXIT_FAILURE);
}
return (val);
}
/*
* This is the interrupt handler for SIGINT and SIGQUIT. It's completely handled
* where it jumps to.
*/
static void
sig_handler(int sig)
{
longjmp(env, sig);
}
/*
* display the usage of traceroute
*/
static void
usage(void)
{
Fprintf(stderr, "Usage: %s [-adFIlnSvx] [-A address_family] "
"[-c traffic_class] \n"
"\t[-f first_hop] [-g gateway [-g gateway ...]| -r] [-i iface]\n"
"\t[-L flow_label] [-m max_hop] [-P pause_sec] [-p port] [-Q max_timeout]\n"
"\t[-q nqueries] [-s src_addr] [-t tos] [-w wait_time] host [packetlen]\n",
prog);
exit(EXIT_FAILURE);
}