pair<std::int16_t, std::int16_t>
FetchCursor()
{
using pr_type = pair<std::int16_t, std::int16_t>;
::touchPosition tp;
::touchRead(&tp);
// NOTE: (-1, -1) is %YSLib::Point::Invalid.
return YB_LIKELY(tp.px != 0 && tp.py != 0) ? pr_type(tp.px - 1, tp.py - 1)
: pr_type(-1, -1);
}
static inline int
packet_ok(u_char *buf, int cc, struct sockaddr_in *from, int seq)
{
struct icmp *icp;
u_char type, code;
int hlen;
struct ip *ip;
ip = (struct ip *) buf;
hlen = ip->ip_hl << 2;
if (cc < hlen + ICMP_MINLEN) {
#ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
if (verbose)
printf("packet too short (%d bytes) from %s\n", cc,
inet_ntoa(from->sin_addr));
#endif
return (0);
}
cc -= hlen;
icp = (struct icmp *)(buf + hlen);
type = icp->icmp_type; code = icp->icmp_code;
if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
type == ICMP_UNREACH) {
struct ip *hip;
struct udphdr *up;
hip = &icp->icmp_ip;
hlen = hip->ip_hl << 2;
up = (struct udphdr *)((u_char *)hip + hlen);
if (hlen + 12 <= cc && hip->ip_p == IPPROTO_UDP &&
up->source == htons(ident) &&
up->dest == htons(port+seq))
return (type == ICMP_TIMXCEED? -1 : code+1);
}
#ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
if (verbose) {
int i;
u_long *lp = (u_long *)&icp->icmp_ip;
printf("\n%d bytes from %s to %s: icmp type %d (%s) code %d\n",
cc, inet_ntoa(from->sin_addr), inet_ntoa(ip->ip_dst),
type, pr_type(type), icp->icmp_code);
for (i = 4; i < cc ; i += sizeof(long))
printf("%2d: x%8.8lx\n", i, *lp++);
}
#endif
return(0);
}
int
packet_ok(struct msghdr *mhdr, int cc, int seq)
{
struct icmp6_hdr *icp;
struct sockaddr_in6 *from = (struct sockaddr_in6 *)mhdr->msg_name;
u_char type, code;
char *buf = (char *)mhdr->msg_iov[0].iov_base;
struct cmsghdr *cm;
int *hlimp;
char hbuf[NI_MAXHOST];
if (cc < sizeof(struct icmp6_hdr)) {
if (verbose) {
if (getnameinfo((struct sockaddr *)from, from->sin6_len,
hbuf, sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0)
strlcpy(hbuf, "invalid", sizeof(hbuf));
printf("data too short (%d bytes) from %s\n", cc, hbuf);
}
return(0);
}
icp = (struct icmp6_hdr *)buf;
/* get optional information via advanced API */
rcvpktinfo = NULL;
hlimp = NULL;
for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
if (cm->cmsg_level == IPPROTO_IPV6 &&
cm->cmsg_type == IPV6_PKTINFO &&
cm->cmsg_len ==
CMSG_LEN(sizeof(struct in6_pktinfo)))
rcvpktinfo = (struct in6_pktinfo *)(CMSG_DATA(cm));
if (cm->cmsg_level == IPPROTO_IPV6 &&
cm->cmsg_type == IPV6_HOPLIMIT &&
cm->cmsg_len == CMSG_LEN(sizeof(int)))
hlimp = (int *)CMSG_DATA(cm);
}
if (rcvpktinfo == NULL || hlimp == NULL) {
warnx("failed to get received hop limit or packet info");
#if 0
return(0);
#else
rcvhlim = 0; /*XXX*/
#endif
}
else
rcvhlim = *hlimp;
type = icp->icmp6_type;
code = icp->icmp6_code;
if ((type == ICMP6_TIME_EXCEEDED && code == ICMP6_TIME_EXCEED_TRANSIT)
|| type == ICMP6_DST_UNREACH) {
struct ip6_hdr *hip;
struct udphdr *up;
hip = (struct ip6_hdr *)(icp + 1);
if ((up = get_udphdr(hip, (u_char *)(buf + cc))) == NULL) {
if (verbose)
warnx("failed to get upper layer header");
return(0);
}
if (useicmp &&
((struct icmp6_hdr *)up)->icmp6_id == ident &&
((struct icmp6_hdr *)up)->icmp6_seq == htons(seq))
return (type == ICMP6_TIME_EXCEEDED ? -1 : code + 1);
else if (!useicmp &&
up->uh_sport == htons(srcport) &&
up->uh_dport == htons(port + seq))
return (type == ICMP6_TIME_EXCEEDED ? -1 : code + 1);
} else if (useicmp && type == ICMP6_ECHO_REPLY) {
if (icp->icmp6_id == ident &&
icp->icmp6_seq == htons(seq))
return (ICMP6_DST_UNREACH_NOPORT + 1);
}
if (verbose) {
char sbuf[NI_MAXHOST+1], dbuf[INET6_ADDRSTRLEN];
u_int8_t *p;
int i;
if (getnameinfo((struct sockaddr *)from, from->sin6_len,
sbuf, sizeof(sbuf), NULL, 0, NI_NUMERICHOST) != 0)
strlcpy(sbuf, "invalid", sizeof(sbuf));
printf("\n%d bytes from %s to %s", cc, sbuf,
rcvpktinfo ? inet_ntop(AF_INET6, &rcvpktinfo->ipi6_addr,
dbuf, sizeof(dbuf)) : "?");
printf(": icmp type %d (%s) code %d\n", type, pr_type(type),
icp->icmp6_code);
p = (u_int8_t *)(icp + 1);
#define WIDTH 16
for (i = 0; i < cc; i++) {
if (i % WIDTH == 0)
printf("%04x:", i);
if (i % 4 == 0)
printf(" ");
printf("%02x", p[i]);
if (i % WIDTH == WIDTH - 1)
printf("\n");
}
if (cc % WIDTH != 0)
printf("\n");
}
return(0);
}
static int
packet_ok(int read_len, len_and_sockaddr *from_lsa,
struct sockaddr *to,
int seq)
{
const struct icmp6_hdr *icp;
unsigned char type, code;
if (from_lsa->u.sa.sa_family == AF_INET)
return packet4_ok(read_len, &from_lsa->u.sin, seq);
icp = (struct icmp6_hdr *) recv_pkt;
type = icp->icmp6_type;
code = icp->icmp6_code;
if ((type == ICMP6_TIME_EXCEEDED && code == ICMP6_TIME_EXCEED_TRANSIT)
|| type == ICMP6_DST_UNREACH
) {
struct ip6_hdr *hip;
struct udphdr *up;
int nexthdr;
hip = (struct ip6_hdr *)(icp + 1);
up = (struct udphdr *) (hip + 1);
nexthdr = hip->ip6_nxt;
if (nexthdr == IPPROTO_FRAGMENT) {
nexthdr = *(unsigned char*)up;
up++;
}
if (nexthdr == IPPROTO_UDP) {
struct outdata6_t *pkt;
pkt = (struct outdata6_t *) (up + 1);
if (ntohl(pkt->ident6) == ident
&& ntohl(pkt->seq6) == seq
) {
return (type == ICMP6_TIME_EXCEEDED ? -1 : (code<<8)+1);
}
}
}
# if ENABLE_FEATURE_TRACEROUTE_VERBOSE
if (verbose) {
unsigned char *p;
char pa1[MAXHOSTNAMELEN];
char pa2[MAXHOSTNAMELEN];
int i;
p = (unsigned char *) (icp + 1);
printf("\n%d bytes from %s to "
"%s: icmp type %d (%s) code %d\n",
read_len,
inet_ntop(AF_INET6, &from_lsa->u.sin6.sin6_addr, pa1, sizeof(pa1)),
inet_ntop(AF_INET6, &((struct sockaddr_in6*)to)->sin6_addr, pa2, sizeof(pa2)),
type, pr_type(type), icp->icmp6_code);
read_len -= sizeof(struct icmp6_hdr);
for (i = 0; i < read_len; i++) {
if (i % 16 == 0)
printf("%04x:", i);
if (i % 4 == 0)
bb_putchar(' ');
printf("%02x", p[i]);
if ((i % 16 == 15) && (i + 1 < read_len))
bb_putchar('\n');
}
bb_putchar('\n');
}
# endif
return 0;
}
static int
packet4_ok(int read_len, const struct sockaddr_in *from, int seq)
{
const struct icmp *icp;
unsigned char type, code;
int hlen;
const struct ip *ip;
ip = (struct ip *) recv_pkt;
hlen = ip->ip_hl << 2;
if (read_len < hlen + ICMP_MINLEN) {
#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
if (verbose)
printf("packet too short (%d bytes) from %s\n", read_len,
inet_ntoa(from->sin_addr));
#endif
return 0;
}
read_len -= hlen;
icp = (struct icmp *)(recv_pkt + hlen);
type = icp->icmp_type;
code = icp->icmp_code;
/* Path MTU Discovery (RFC1191) */
pmtu = 0;
if (code == ICMP_UNREACH_NEEDFRAG)
pmtu = ntohs(icp->icmp_nextmtu);
if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS)
|| type == ICMP_UNREACH
|| type == ICMP_ECHOREPLY
) {
const struct ip *hip;
const struct udphdr *up;
hip = &icp->icmp_ip;
hlen = hip->ip_hl << 2;
if (option_mask32 & OPT_USE_ICMP) {
struct icmp *hicmp;
/* XXX */
if (type == ICMP_ECHOREPLY
&& icp->icmp_id == htons(ident)
&& icp->icmp_seq == htons(seq)
) {
return ICMP_UNREACH_PORT+1;
}
hicmp = (struct icmp *)((unsigned char *)hip + hlen);
if (hlen + SIZEOF_ICMP_HDR <= read_len
&& hip->ip_p == IPPROTO_ICMP
&& hicmp->icmp_id == htons(ident)
&& hicmp->icmp_seq == htons(seq)
) {
return (type == ICMP_TIMXCEED ? -1 : code + 1);
}
} else {
up = (struct udphdr *)((char *)hip + hlen);
if (hlen + 12 <= read_len
&& hip->ip_p == IPPROTO_UDP
// Off: since we do not form the entire IP packet,
// but defer it to kernel, we can't set source port,
// and thus can't check it here in the reply
/* && up->source == htons(ident) */
&& up->dest == htons(port + seq)
) {
return (type == ICMP_TIMXCEED ? -1 : code + 1);
}
}
}
#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
if (verbose) {
int i;
uint32_t *lp = (uint32_t *)&icp->icmp_ip;
printf("\n%d bytes from %s to "
"%s: icmp type %d (%s) code %d\n",
read_len, inet_ntoa(from->sin_addr),
inet_ntoa(ip->ip_dst),
type, pr_type(type), icp->icmp_code);
for (i = 4; i < read_len; i += sizeof(*lp))
printf("%2d: x%8.8x\n", i, *lp++);
}
#endif
return 0;
}
/*
* Check out the packet to see if it came from us. This logic is necessary
* because ALL readers of the ICMP socket get a copy of ALL ICMP packets
* which arrive ('tis only fair). This permits multiple copies of this
* program to be run without having intermingled output (or statistics!).
*/
void
check_reply(struct addrinfo *ai_dst, struct msghdr *msg, int cc,
ushort_t udp_src_port)
{
struct ip *ip;
struct icmp *icp;
struct udphdr *up;
union any_in_addr dst_addr;
uchar_t *buf;
int32_t *intp;
struct sockaddr_in *from;
struct timeval *tp;
struct timeval tv;
int hlen, hlen1;
int64_t triptime;
boolean_t valid_reply = _B_FALSE;
boolean_t reply_matched_current_target; /* Is the source address of */
/* this reply same as where */
/* we're sending currently? */
boolean_t last_reply_from_targetaddr = _B_FALSE; /* Is this stats, */
/* probe all with npackets>0 */
/* and we received reply for */
/* the last probe sent to */
/* targetaddr */
int cc_left;
char tmp_buf[INET6_ADDRSTRLEN];
static char *unreach[] = {
"Net Unreachable",
"Host Unreachable",
"Protocol Unreachable",
"Port Unreachable",
"Fragmentation needed and DF set",
"Source Route Failed",
/* The following are from RFC1700 */
"Net Unknown",
"Host Unknown",
"Source Host Isolated",
"Dest Net Prohibited",
"Dest Host Prohibited",
"Net Unreachable for TOS",
"Host Unreachable for TOS",
"Communication Administratively Prohibited",
"Host Precedence Violation",
"Precedence Cutoff in Effect"
};
static char *redirect[] = {
"Net",
"Host",
"TOS Net",
"TOS Host"
};
static char *timexceed[] = {
"Time exceeded in transit",
"Time exceeded during reassembly"
};
boolean_t print_newline = _B_FALSE;
int i;
/* decompose msghdr into useful pieces */
buf = (uchar_t *)msg->msg_iov->iov_base;
from = (struct sockaddr_in *)msg->msg_name;
/* LINTED */
intp = (int32_t *)buf;
(void) gettimeofday(&tv, (struct timezone *)NULL);
/* LINTED */
ip = (struct ip *)buf;
hlen = ip->ip_hl << 2;
if ((cc < sizeof (struct ip)) || (cc < hlen + ICMP_MINLEN)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n", cc,
pr_name((char *)&from->sin_addr, AF_INET));
}
return;
}
cc -= hlen;
/* LINTED */
icp = (struct icmp *)(buf + hlen);
if (ip->ip_p == 0) {
/*
* Assume that we are running on a pre-4.3BSD system
* such as SunOS before 4.0
*/
/* LINTED */
icp = (struct icmp *)buf;
}
cc_left = cc - ICMP_MINLEN;
switch (icp->icmp_type) {
case ICMP_UNREACH:
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
/* check if we have enough of the packet to work on */
if ((cc_left < sizeof (struct ip)) ||
(cc_left < hlen1 + sizeof (struct udphdr))) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
/* get the UDP packet */
cc_left -= hlen1 + sizeof (struct udphdr);
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
/* check to see if this is what we sent */
if (icp->icmp_code == ICMP_UNREACH_PORT &&
ip->ip_p == IPPROTO_UDP &&
udp_src_port == up->uh_sport &&
use_udp) {
valid_reply = _B_TRUE;
} else {
valid_reply = _B_FALSE;
}
if (valid_reply) {
/*
* For this valid reply, if we are still sending to
* this target IP address, we'd like to do some
* updates to targetaddr, so hold SIGALRMs.
*/
(void) sighold(SIGALRM);
is_alive = _B_TRUE;
nreceived++;
reply_matched_current_target =
seq_match(current_targetaddr->starting_seq_num,
current_targetaddr->num_sent,
ntohs(up->uh_dport));
if (reply_matched_current_target) {
current_targetaddr->got_reply = _B_TRUE;
nreceived_last_target++;
/*
* Determine if stats, probe-all, and
* npackets != 0, and this is the reply for
* the last probe we sent to current target
* address.
*/
if (stats && probe_all && npackets > 0 &&
((current_targetaddr->starting_seq_num +
current_targetaddr->num_probes - 1) %
(MAX_PORT + 1) == ntohs(up->uh_dport)) &&
(current_targetaddr->num_probes ==
current_targetaddr->num_sent))
last_reply_from_targetaddr = _B_TRUE;
} else {
/*
* If it's just probe_all and we just received
* a reply from a target address we were
* probing and had timed out (now we are probing
* some other target address), we ignore
* this reply.
*/
if (probe_all && !stats) {
valid_reply = _B_FALSE;
/*
* Only if it's verbose, we get a
* message regarding this reply,
* otherwise we are done here.
*/
if (!verbose) {
(void) sigrelse(SIGALRM);
return;
}
}
}
}
/* stats mode doesn't print 'alive' messages */
if (valid_reply && !stats) {
/*
* if we are still sending to the same target address,
* then stop it, because we know it's alive.
*/
if (reply_matched_current_target) {
(void) alarm(0); /* cancel alarm */
(void) sigset(SIGALRM, SIG_IGN);
current_targetaddr->probing_done = _B_TRUE;
}
(void) sigrelse(SIGALRM);
if (!probe_all) {
Printf("%s is alive\n", targethost);
} else {
(void) inet_ntop(AF_INET, (void *)&ip->ip_dst,
tmp_buf, sizeof (tmp_buf));
if (nflag) {
Printf("%s is alive\n", tmp_buf);
} else {
Printf("%s (%s) is alive\n",
targethost, tmp_buf);
}
}
if (reply_matched_current_target) {
/*
* Let's get things going again, but now
* ping will start sending to next target IP
* address.
*/
send_scheduled_probe();
(void) sigset(SIGALRM, sigalrm_handler);
schedule_sigalrm();
}
return;
} else {
/*
* If we are not moving to next targetaddr, let's
* release the SIGALRM now. We don't want to stall in
* the middle of probing a targetaddr if the pr_name()
* call (see below) takes longer.
*/
if (!last_reply_from_targetaddr)
(void) sigrelse(SIGALRM);
/* else, we'll release it later */
}
dst_addr.addr = ip->ip_dst;
if (valid_reply) {
Printf("%d bytes from %s: ", cc,
pr_name((char *)&from->sin_addr, AF_INET));
Printf("udp_port=%d. ", ntohs(up->uh_dport));
print_newline = _B_TRUE;
} else if (is_a_target(ai_dst, &dst_addr) || verbose) {
if (icp->icmp_code >= A_CNT(unreach)) {
Printf("ICMP %d Unreachable from gateway %s\n",
icp->icmp_code,
pr_name((char *)&from->sin_addr, AF_INET));
} else {
Printf("ICMP %s from gateway %s\n",
unreach[icp->icmp_code],
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
if (ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) {
Printf(" port %d ", ntohs(up->uh_dport));
}
print_newline = _B_TRUE;
}
/* if we are timing and the reply has a timeval */
if (valid_reply && datalen >= sizeof (struct timeval) &&
cc_left >= sizeof (struct timeval)) {
/* LINTED */
tp = (struct timeval *)((char *)up +
sizeof (struct udphdr));
(void) tvsub(&tv, tp);
triptime = (int64_t)tv.tv_sec * MICROSEC + tv.tv_usec;
Printf("time=" TIMEFORMAT " ms", triptime/1000.0);
tsum += triptime;
tsum2 += triptime*triptime;
if (triptime < tmin)
tmin = triptime;
if (triptime > tmax)
tmax = triptime;
print_newline = _B_TRUE;
}
if (print_newline)
(void) putchar('\n');
/*
* If it's stats, probe-all, npackets > 0, and we received reply
* for the last probe sent to this target address, then we
* don't need to wait anymore, let's move on to next target
* address, now!
*/
if (last_reply_from_targetaddr) {
(void) alarm(0); /* cancel alarm */
current_targetaddr->probing_done = _B_TRUE;
(void) sigrelse(SIGALRM);
send_scheduled_probe();
schedule_sigalrm();
}
break;
case ICMP_REDIRECT:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
if (icp->icmp_code >= A_CNT(redirect)) {
Printf("ICMP %d redirect from gateway %s\n",
icp->icmp_code,
pr_name((char *)&from->sin_addr, AF_INET));
} else {
Printf("ICMP %s redirect from gateway %s\n",
redirect[icp->icmp_code],
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf(" to %s",
pr_name((char *)&icp->icmp_gwaddr, AF_INET));
Printf(" for %s\n",
pr_name((char *)&ip->ip_dst, AF_INET));
}
break;
case ICMP_ECHOREPLY:
if (ntohs(icp->icmp_id) == ident) {
if (!use_udp && !use_icmp_ts)
valid_reply = _B_TRUE;
else
valid_reply = _B_FALSE;
} else {
return;
}
if (valid_reply) {
/*
* For this valid reply, if we are still sending to
* this target IP address, we'd like to do some
* updates to targetaddr, so hold SIGALRMs.
*/
(void) sighold(SIGALRM);
is_alive = _B_TRUE;
nreceived++;
reply_matched_current_target =
seq_match(current_targetaddr->starting_seq_num,
current_targetaddr->num_sent,
ntohs(icp->icmp_seq));
if (reply_matched_current_target) {
current_targetaddr->got_reply = _B_TRUE;
nreceived_last_target++;
/*
* Determine if stats, probe-all, and
* npackets != 0, and this is the reply for
* the last probe we sent to current target
* address.
*/
if (stats && probe_all && npackets > 0 &&
((current_targetaddr->starting_seq_num +
current_targetaddr->num_probes - 1) %
(MAX_ICMP_SEQ + 1) ==
ntohs(icp->icmp_seq)) &&
(current_targetaddr->num_probes ==
current_targetaddr->num_sent))
last_reply_from_targetaddr = _B_TRUE;
} else {
/*
* If it's just probe_all and we just received
* a reply from a target address we were
* probing and had timed out (now we are probing
* some other target address), we ignore
* this reply.
*/
if (probe_all && !stats) {
valid_reply = _B_FALSE;
/*
* Only if it's verbose, we get a
* message regarding this reply,
* otherwise we are done here.
*/
if (!verbose) {
(void) sigrelse(SIGALRM);
return;
}
}
}
}
if (!stats && valid_reply) {
/*
* if we are still sending to the same target address,
* then stop it, because we know it's alive.
*/
if (reply_matched_current_target) {
(void) alarm(0); /* cancel alarm */
(void) sigset(SIGALRM, SIG_IGN);
current_targetaddr->probing_done = _B_TRUE;
}
(void) sigrelse(SIGALRM);
if (!probe_all) {
Printf("%s is alive\n", targethost);
} else {
/*
* If we are using send_reply, the real
* target address is not the src address of the
* replies. Use icmp_seq to find out where this
* probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(
ntohs(icp->icmp_seq), &dst_addr);
(void) inet_ntop(AF_INET,
(void *)&dst_addr.addr,
tmp_buf, sizeof (tmp_buf));
} else {
(void) inet_ntop(AF_INET,
(void *)&from->sin_addr,
tmp_buf, sizeof (tmp_buf));
}
if (nflag) {
Printf("%s is alive\n", tmp_buf);
} else {
Printf("%s (%s) is alive\n",
targethost, tmp_buf);
}
}
if (reply_matched_current_target) {
/*
* Let's get things going again, but now
* ping will start sending to next target IP
* address.
*/
send_scheduled_probe();
(void) sigset(SIGALRM, sigalrm_handler);
schedule_sigalrm();
}
return;
} else {
/*
* If we are not moving to next targetaddr, let's
* release the SIGALRM now. We don't want to stall in
* the middle of probing a targetaddr if the pr_name()
* call (see below) takes longer.
*/
if (!last_reply_from_targetaddr)
(void) sigrelse(SIGALRM);
/* else, we'll release it later */
}
/*
* If we are using send_reply, the real target address is
* not the src address of the replies. Use icmp_seq to find out
* where this probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(ntohs(icp->icmp_seq), &dst_addr);
Printf("%d bytes from %s: ", cc,
pr_name((char *)&dst_addr.addr, AF_INET));
} else {
Printf("%d bytes from %s: ", cc,
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf("icmp_seq=%d. ", ntohs(icp->icmp_seq));
if (valid_reply && datalen >= sizeof (struct timeval) &&
cc_left >= sizeof (struct timeval)) {
/* LINTED */
tp = (struct timeval *)&icp->icmp_data[0];
(void) tvsub(&tv, tp);
triptime = (int64_t)tv.tv_sec * MICROSEC + tv.tv_usec;
Printf("time=" TIMEFORMAT " ms", triptime/1000.0);
tsum += triptime;
tsum2 += triptime*triptime;
if (triptime < tmin)
tmin = triptime;
if (triptime > tmax)
tmax = triptime;
}
(void) putchar('\n');
/*
* If it's stats, probe-all, npackets > 0, and we received reply
* for the last probe sent to this target address, then we
* don't need to wait anymore, let's move on to next target
* address, now!
*/
if (last_reply_from_targetaddr) {
(void) alarm(0); /* cancel alarm */
current_targetaddr->probing_done = _B_TRUE;
(void) sigrelse(SIGALRM);
send_scheduled_probe();
schedule_sigalrm();
}
break;
case ICMP_SOURCEQUENCH:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
Printf("ICMP Source Quench from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
/*
* if it's a UDP or TCP packet, we need at least first
* 4 bytes of it to see the src/dst ports
*/
if ((ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) &&
(cc_left >= hlen1 + 4)) {
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
Printf(" port %d", ntohs(up->uh_dport));
}
(void) putchar('\n');
}
break;
case ICMP_PARAMPROB:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
switch (icp->icmp_code) {
case ICMP_PARAMPROB_OPTABSENT:
Printf("ICMP Missing a Required Option "
"parameter problem from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" option type = %d", icp->icmp_pptr);
break;
case ICMP_PARAMPROB_BADLENGTH:
Printf("ICMP Bad Length parameter problem "
"from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" in byte %d", icp->icmp_pptr);
if (icp->icmp_pptr <= hlen1) {
Printf(" (value 0x%x)",
*((char *)ip + icp->icmp_pptr));
}
break;
case 0:
default:
Printf("ICMP Parameter Problem from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" in byte %d", icp->icmp_pptr);
if (icp->icmp_pptr <= hlen1) {
Printf(" (value 0x%x)",
*((char *)ip + icp->icmp_pptr));
}
break;
}
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
/*
* if it's a UDP or TCP packet, we need at least first
* 4 bytes of it to see the src/dst ports
*/
if ((ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) &&
(cc_left >= hlen1 + 4)) {
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
Printf(" port %d", ntohs(up->uh_dport));
}
(void) putchar('\n');
}
break;
case ICMP_TIMXCEED:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
if (icp->icmp_code >= A_CNT(timexceed)) {
Printf("ICMP %d time exceeded from %s\n",
icp->icmp_code,
pr_name((char *)&from->sin_addr, AF_INET));
} else {
Printf("ICMP %s from %s\n",
timexceed[icp->icmp_code],
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
if ((ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) &&
(cc_left >= hlen1 + 4)) {
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
Printf(" port %d", ntohs(up->uh_dport));
}
(void) putchar('\n');
}
break;
case ICMP_TSTAMPREPLY:
/* the packet should have enough space to store timestamps */
if (cc_left < sizeof (struct id_ts)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
if (ntohs(icp->icmp_id) == ident) {
if (use_icmp_ts)
valid_reply = _B_TRUE;
else
valid_reply = _B_FALSE;
} else {
return;
}
if (valid_reply) {
/*
* For this valid reply, if we are still sending to
* this target IP address, we'd like to do some
* updates to targetaddr, so hold SIGALRMs.
*/
(void) sighold(SIGALRM);
is_alive = _B_TRUE;
nreceived++;
reply_matched_current_target =
seq_match(current_targetaddr->starting_seq_num,
current_targetaddr->num_sent,
ntohs(icp->icmp_seq));
if (reply_matched_current_target) {
current_targetaddr->got_reply = _B_TRUE;
nreceived_last_target++;
/*
* Determine if stats, probe-all, and
* npackets != 0, and this is the reply for
* the last probe we sent to current target
* address.
*/
if (stats && probe_all && npackets > 0 &&
((current_targetaddr->starting_seq_num +
current_targetaddr->num_probes - 1) %
(MAX_ICMP_SEQ + 1) ==
ntohs(icp->icmp_seq)) &&
(current_targetaddr->num_probes ==
current_targetaddr->num_sent))
last_reply_from_targetaddr = _B_TRUE;
} else {
/*
* If it's just probe_all and we just received
* a reply from a target address we were
* probing and had timed out (now we are probing
* some other target address), we ignore
* this reply.
*/
if (probe_all && !stats) {
valid_reply = _B_FALSE;
/*
* Only if it's verbose, we get a
* message regarding this reply,
* otherwise we are done here.
*/
if (!verbose) {
(void) sigrelse(SIGALRM);
return;
}
}
}
}
if (!stats && valid_reply) {
/*
* if we are still sending to the same target address,
* then stop it, because we know it's alive.
*/
if (reply_matched_current_target) {
(void) alarm(0); /* cancel alarm */
(void) sigset(SIGALRM, SIG_IGN);
current_targetaddr->probing_done = _B_TRUE;
}
(void) sigrelse(SIGALRM);
if (!probe_all) {
Printf("%s is alive\n", targethost);
} else {
/*
* If we are using send_reply, the real
* target address is not the src address of the
* replies. Use icmp_seq to find out where this
* probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(
ntohs(icp->icmp_seq), &dst_addr);
(void) inet_ntop(AF_INET,
(void *)&dst_addr.addr,
tmp_buf, sizeof (tmp_buf));
} else {
(void) inet_ntop(AF_INET,
(void *)&from->sin_addr,
tmp_buf, sizeof (tmp_buf));
}
if (nflag) {
Printf("%s is alive\n", tmp_buf);
} else {
Printf("%s (%s) is alive\n",
targethost, tmp_buf);
}
}
if (reply_matched_current_target) {
/*
* Let's get things going again, but now
* ping will start sending to next target IP
* address.
*/
send_scheduled_probe();
(void) sigset(SIGALRM, sigalrm_handler);
schedule_sigalrm();
}
return;
} else {
/*
* If we are not moving to next targetaddr, let's
* release the SIGALRM now. We don't want to stall in
* the middle of probing a targetaddr if the pr_name()
* call (see below) takes longer.
*/
if (!last_reply_from_targetaddr)
(void) sigrelse(SIGALRM);
/* else, we'll release it later */
}
/*
* If we are using send_reply, the real target address is
* not the src address of the replies. Use icmp_seq to find out
* where this probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(ntohs(icp->icmp_seq), &dst_addr);
Printf("%d bytes from %s: ", cc,
pr_name((char *)&dst_addr.addr, AF_INET));
} else {
Printf("%d bytes from %s: ", cc,
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf("icmp_seq=%d. ", ntohs(icp->icmp_seq));
Printf("orig = %lu, recv = %lu, xmit = %lu ",
(ulong_t)ntohl(icp->icmp_otime),
(ulong_t)ntohl(icp->icmp_rtime),
(ulong_t)ntohl(icp->icmp_ttime));
if (valid_reply) {
/*
* icp->icmp_otime is the time passed since midnight.
* Therefore we need to adjust tv value, which is
* the time passed since Jan 1, 1970.
*/
triptime = (tv.tv_sec % (24LL * 60 * 60)) * MILLISEC +
(tv.tv_usec / (MICROSEC/MILLISEC));
triptime -= ntohl(icp->icmp_otime);
if (triptime < 0)
triptime += 24LL * 60 * 60 * MILLISEC;
Printf("time=%d. ms", (int)triptime);
triptime *= (MICROSEC/MILLISEC);
tsum += triptime;
tsum2 += triptime*triptime;
if (triptime < tmin)
tmin = triptime;
if (triptime > tmax)
tmax = triptime;
}
(void) putchar('\n');
/*
* If it's stats, probe-all, npackets > 0, and we received reply
* for the last probe sent to this target address, then we
* don't need to wait anymore, let's move on to next target
* address, now!
*/
if (last_reply_from_targetaddr) {
(void) alarm(0); /* cancel alarm */
current_targetaddr->probing_done = _B_TRUE;
(void) sigrelse(SIGALRM);
send_scheduled_probe();
schedule_sigalrm();
}
break;
case ICMP_ROUTERADVERT:
case ICMP_ROUTERSOLICIT:
/* Router discovery messages */
return;
case ICMP_ECHO:
case ICMP_TSTAMP:
case ICMP_IREQ:
case ICMP_MASKREQ:
/* These were never passed out from the SunOS 4.X kernel. */
return;
case ICMP_IREQREPLY:
case ICMP_MASKREPLY:
/* Replies for information and address mask requests */
return;
default:
if (verbose) {
Printf("%d bytes from %s:\n", cc,
pr_name((char *)&from->sin_addr, AF_INET));
Printf("icmp_type=%d (%s) ",
icp->icmp_type, pr_type(icp->icmp_type));
Printf("icmp_code=%d\n", icp->icmp_code);
for (i = 0; i < 12; i++) {
Printf("x%2.2x: x%8.8x\n",
i * sizeof (int32_t), *intp++);
}
}
break;
}
buf += sizeof (struct ip);
hlen -= sizeof (struct ip);
/* if verbose and there exists IP options */
if (verbose && hlen > 0)
pr_options((uchar_t *)buf, hlen);
}
