|
0
|
1 /*
|
|
|
2 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
|
|
|
3 * Use is subject to license terms.
|
|
|
4 */
|
|
|
5
|
|
|
6 /*
|
|
|
7 * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997
|
|
|
8 * The Regents of the University of California. All rights reserved.
|
|
|
9 *
|
|
|
10 * Redistribution and use in source and binary forms, with or without
|
|
|
11 * modification, are permitted provided that: (1) source code distributions
|
|
|
12 * retain the above copyright notice and this paragraph in its entirety, (2)
|
|
|
13 * distributions including binary code include the above copyright notice and
|
|
|
14 * this paragraph in its entirety in the documentation or other materials
|
|
|
15 * provided with the distribution, and (3) all advertising materials mentioning
|
|
|
16 * features or use of this software display the following acknowledgement:
|
|
|
17 * ``This product includes software developed by the University of California,
|
|
|
18 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
|
|
|
19 * the University nor the names of its contributors may be used to endorse
|
|
|
20 * or promote products derived from this software without specific prior
|
|
|
21 * written permission.
|
|
|
22 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
|
23 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
|
24 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
25 *
|
|
|
26 *
|
|
|
27 * @(#)$Header: traceroute.c,v 1.49 97/06/13 02:30:23 leres Exp $ (LBL)
|
|
|
28 */
|
|
|
29
|
|
|
30 #pragma ident "@(#)traceroute_aux.c 1.8 06/01/12 SMI"
|
|
|
31
|
|
|
32 #include <sys/socket.h>
|
|
|
33
|
|
|
34 #include <stdio.h>
|
|
|
35 #include <stdlib.h>
|
|
|
36 #include <ctype.h>
|
|
|
37 #include <strings.h>
|
|
|
38 #include <libintl.h>
|
|
|
39 #include <errno.h>
|
|
|
40
|
|
|
41 #include <netinet/in_systm.h>
|
|
|
42 #include <netinet/in.h>
|
|
|
43 #include <netinet/ip.h>
|
|
|
44 #include <netinet/ip_var.h>
|
|
|
45 #include <netinet/ip_icmp.h>
|
|
|
46 #include <netinet/udp.h>
|
|
|
47 #include <netinet/udp_var.h>
|
|
|
48
|
|
|
49 #include <arpa/inet.h>
|
|
|
50 #include <netdb.h>
|
|
|
51
|
|
|
52 #include <libinetutil.h>
|
|
|
53 #include "traceroute.h"
|
|
|
54
|
|
|
55 /*
|
|
|
56 * IPv4 source routing option.
|
|
|
57 * In order to avoid padding for the alignment of IPv4 addresses, ipsr_addrs
|
|
|
58 * is defined as a 2-D array of uint8_t, instead of 1-D array of struct in_addr.
|
|
|
59 */
|
|
|
60 struct ip_sourceroute {
|
|
|
61 uint8_t ipsr_code;
|
|
|
62 uint8_t ipsr_len;
|
|
|
63 uint8_t ipsr_ptr;
|
|
|
64 /* up to 9 IPv4 addresses */
|
|
|
65 uint8_t ipsr_addrs[1][sizeof (struct in_addr)];
|
|
|
66 };
|
|
|
67
|
|
|
68 int check_reply(struct msghdr *, int, int, uchar_t *, uchar_t *);
|
|
|
69 extern ushort_t in_cksum(ushort_t *, int);
|
|
|
70 extern char *inet_name(union any_in_addr *, int);
|
|
|
71 static char *pr_type(uchar_t);
|
|
|
72 void print_addr(uchar_t *, int, struct sockaddr *);
|
|
|
73 boolean_t print_icmp_other(uchar_t, uchar_t);
|
|
|
74 void send_probe(int, struct sockaddr *, struct ip *, int, int,
|
|
|
75 struct timeval *, int);
|
|
|
76 struct ip *set_buffers(int);
|
|
|
77 void set_IPv4opt_sourcerouting(int, union any_in_addr *, union any_in_addr *);
|
|
|
78
|
|
|
79 /*
|
|
|
80 * prepares the buffer to be sent as an IP datagram
|
|
|
81 */
|
|
|
82 struct ip *
|
|
|
83 set_buffers(int plen)
|
|
|
84 {
|
|
|
85 struct ip *outip;
|
|
|
86 uchar_t *outp; /* packet following the IP header (UDP/ICMP) */
|
|
|
87 struct udphdr *outudp;
|
|
|
88 struct icmp *outicmp;
|
|
|
89 int optlen = 0;
|
|
|
90
|
|
|
91 outip = (struct ip *)malloc((size_t)plen);
|
|
|
92 if (outip == NULL) {
|
|
|
93 Fprintf(stderr, "%s: malloc: %s\n", prog, strerror(errno));
|
|
|
94 exit(EXIT_FAILURE);
|
|
|
95 }
|
|
|
96
|
|
|
97 if (gw_count > 0) {
|
|
|
98 /* 8 = 5 (NO OPs) + 3 (code, len, ptr) */
|
|
|
99 optlen = 8 + gw_count * sizeof (struct in_addr);
|
|
|
100 }
|
|
|
101
|
|
|
102 (void) memset((char *)outip, 0, (size_t)plen);
|
|
|
103 outp = (uchar_t *)(outip + 1);
|
|
|
104
|
|
|
105 outip->ip_v = IPVERSION;
|
|
|
106 if (settos)
|
|
|
107 outip->ip_tos = tos;
|
|
|
108
|
|
|
109 /*
|
|
|
110 * LBNL bug fixed: missing '- optlen' before, causing optlen
|
|
|
111 * added twice
|
|
|
112 *
|
|
|
113 * BSD bug: BSD touches the header fields 'len' and 'ip_off'
|
|
|
114 * even when HDRINCL is set. It applies htons() on these
|
|
|
115 * fields. It should send the header untouched when HDRINCL
|
|
|
116 * is set.
|
|
|
117 */
|
|
|
118 outip->ip_len = htons(plen - optlen);
|
|
|
119 outip->ip_off = htons(off);
|
|
|
120 outip->ip_hl = (outp - (uchar_t *)outip) >> 2;
|
|
|
121
|
|
|
122 /* setup ICMP or UDP */
|
|
|
123 if (useicmp) {
|
|
|
124 outip->ip_p = IPPROTO_ICMP;
|
|
|
125
|
|
|
126 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
127 outicmp = (struct icmp *)outp;
|
|
|
128 outicmp->icmp_type = ICMP_ECHO;
|
|
|
129 outicmp->icmp_id = htons(ident);
|
|
|
130 } else {
|
|
|
131 outip->ip_p = IPPROTO_UDP;
|
|
|
132
|
|
|
133 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
134 outudp = (struct udphdr *)outp;
|
|
|
135 outudp->uh_sport = htons(ident);
|
|
|
136 outudp->uh_ulen =
|
|
|
137 htons((ushort_t)(plen - (sizeof (struct ip) + optlen)));
|
|
|
138 }
|
|
|
139
|
|
|
140 return (outip);
|
|
|
141 }
|
|
|
142
|
|
|
143 /*
|
|
|
144 * Setup the source routing for IPv4.
|
|
|
145 */
|
|
|
146 void
|
|
|
147 set_IPv4opt_sourcerouting(int sndsock, union any_in_addr *ip_addr,
|
|
|
148 union any_in_addr *gwIPlist)
|
|
|
149 {
|
|
|
150 struct protoent *pe;
|
|
|
151 struct ip_sourceroute *srp;
|
|
|
152 uchar_t optlist[MAX_IPOPTLEN];
|
|
|
153 int i;
|
|
|
154 int gwV4_count;
|
|
|
155
|
|
|
156 if ((pe = getprotobyname("ip")) == NULL) {
|
|
|
157 Fprintf(stderr, "%s: unknown protocol ip\n", prog);
|
|
|
158 exit(EXIT_FAILURE);
|
|
|
159 }
|
|
|
160
|
|
|
161 gwV4_count = (gw_count < MAX_GWS) ? gw_count : MAX_GWS - 1;
|
|
|
162 /* final hop */
|
|
|
163 gwIPlist[gwV4_count].addr = ip_addr->addr;
|
|
|
164
|
|
|
165 /*
|
|
|
166 * the option length passed to setsockopt() needs to be a multiple of
|
|
|
167 * 32 bits. Therefore we need to use a 1-byte padding (source routing
|
|
|
168 * information takes 4x+3 bytes).
|
|
|
169 */
|
|
|
170 optlist[0] = IPOPT_NOP;
|
|
|
171
|
|
|
172 srp = (struct ip_sourceroute *)&optlist[1];
|
|
|
173 srp->ipsr_code = IPOPT_LSRR;
|
|
|
174 /* 3 = 1 (code) + 1 (len) + 1 (ptr) */
|
|
|
175 srp->ipsr_len = 3 + (gwV4_count + 1) * sizeof (gwIPlist[0].addr);
|
|
|
176 srp->ipsr_ptr = IPOPT_MINOFF;
|
|
|
177
|
|
|
178 for (i = 0; i <= gwV4_count; i++) {
|
|
|
179 (void) bcopy((char *)&gwIPlist[i].addr, &srp->ipsr_addrs[i],
|
|
|
180 sizeof (struct in_addr));
|
|
|
181 }
|
|
|
182
|
|
|
183 if (setsockopt(sndsock, pe->p_proto, IP_OPTIONS, (const char *)optlist,
|
|
|
184 srp->ipsr_len + 1) < 0) {
|
|
|
185 Fprintf(stderr, "%s: IP_OPTIONS: %s\n", prog, strerror(errno));
|
|
|
186 exit(EXIT_FAILURE);
|
|
|
187 }
|
|
|
188 }
|
|
|
189
|
|
|
190 /*
|
|
|
191 * send a probe packet to the destination
|
|
|
192 */
|
|
|
193 void
|
|
|
194 send_probe(int sndsock, struct sockaddr *to, struct ip *outip,
|
|
|
195 int seq, int ttl, struct timeval *tp, int packlen)
|
|
|
196 {
|
|
|
197 int cc;
|
|
|
198 struct udpiphdr *ui;
|
|
|
199 uchar_t *outp; /* packet following the IP header (UDP/ICMP) */
|
|
|
200 struct udphdr *outudp;
|
|
|
201 struct icmp *outicmp;
|
|
|
202 struct outdata *outdata;
|
|
|
203 struct ip tip;
|
|
|
204 int optlen = 0;
|
|
|
205 int send_size;
|
|
|
206
|
|
|
207 /* initialize buffer pointers */
|
|
|
208 outp = (uchar_t *)(outip + 1);
|
|
|
209 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
210 outudp = (struct udphdr *)outp;
|
|
|
211 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
212 outicmp = (struct icmp *)outp;
|
|
|
213 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
214 outdata = (struct outdata *)(outp + ICMP_MINLEN);
|
|
|
215
|
|
|
216 if (gw_count > 0) {
|
|
|
217 /* 8 = 5 (NO OPs) + 3 (code, len, ptr) */
|
|
|
218 optlen = 8 + gw_count * sizeof (struct in_addr);
|
|
|
219 }
|
|
|
220
|
|
|
221 if (raw_req) {
|
|
|
222 send_size = packlen - optlen;
|
|
|
223 } else if (useicmp) {
|
|
|
224 send_size = packlen - optlen - sizeof (struct ip);
|
|
|
225 } else {
|
|
|
226 send_size = packlen - optlen - sizeof (struct ip) -
|
|
|
227 sizeof (struct udphdr);
|
|
|
228 }
|
|
|
229
|
|
|
230 outip->ip_ttl = ttl;
|
|
|
231 outip->ip_id = htons(ident + seq);
|
|
|
232
|
|
|
233 /*
|
|
|
234 * If a raw IPv4 packet is going to be sent, the Time to Live
|
|
|
235 * field in the packet was initialized above. Otherwise, it is
|
|
|
236 * initialized here using the IPPROTO_IP level socket option.
|
|
|
237 */
|
|
|
238 if (!raw_req) {
|
|
|
239 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL, (char *)&ttl,
|
|
|
240 sizeof (ttl)) < 0) {
|
|
|
241 Fprintf(stderr, "%s: IP_TTL: %s\n", prog,
|
|
|
242 strerror(errno));
|
|
|
243 exit(EXIT_FAILURE);
|
|
|
244 }
|
|
|
245 }
|
|
|
246
|
|
|
247 /*
|
|
|
248 * In most cases, the kernel will recalculate the ip checksum.
|
|
|
249 * But we must do it anyway so that the udp checksum comes out
|
|
|
250 * right.
|
|
|
251 */
|
|
|
252 if (docksum) {
|
|
|
253 outip->ip_sum =
|
|
|
254 in_cksum((ushort_t *)outip, sizeof (*outip) + optlen);
|
|
|
255 if (outip->ip_sum == 0)
|
|
|
256 outip->ip_sum = 0xffff;
|
|
|
257 }
|
|
|
258
|
|
|
259 /* Payload */
|
|
|
260 outdata->seq = seq;
|
|
|
261 outdata->ttl = ttl;
|
|
|
262 outdata->tv = *tp;
|
|
|
263
|
|
|
264 if (useicmp) {
|
|
|
265 outicmp->icmp_seq = htons(seq);
|
|
|
266 } else {
|
|
|
267 outudp->uh_dport = htons((port + seq) % (MAX_PORT + 1));
|
|
|
268 }
|
|
|
269
|
|
|
270 if (!raw_req)
|
|
|
271 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
272 ((struct sockaddr_in *)to)->sin_port = outudp->uh_dport;
|
|
|
273
|
|
|
274 /* (We can only do the checksum if we know our ip address) */
|
|
|
275 if (docksum) {
|
|
|
276 if (useicmp) {
|
|
|
277 outicmp->icmp_cksum = 0;
|
|
|
278 outicmp->icmp_cksum = in_cksum((ushort_t *)outicmp,
|
|
|
279 packlen - (sizeof (struct ip) + optlen));
|
|
|
280 if (outicmp->icmp_cksum == 0)
|
|
|
281 outicmp->icmp_cksum = 0xffff;
|
|
|
282 } else {
|
|
|
283 /* Checksum (must save and restore ip header) */
|
|
|
284 tip = *outip;
|
|
|
285 ui = (struct udpiphdr *)outip;
|
|
|
286 ui->ui_next = 0;
|
|
|
287 ui->ui_prev = 0;
|
|
|
288 ui->ui_x1 = 0;
|
|
|
289 ui->ui_len = outudp->uh_ulen;
|
|
|
290 outudp->uh_sum = 0;
|
|
|
291 outudp->uh_sum = in_cksum((ushort_t *)ui, packlen);
|
|
|
292 if (outudp->uh_sum == 0)
|
|
|
293 outudp->uh_sum = 0xffff;
|
|
|
294 *outip = tip;
|
|
|
295 }
|
|
|
296 }
|
|
|
297
|
|
|
298 if (raw_req) {
|
|
|
299 cc = sendto(sndsock, (char *)outip, send_size, 0, to,
|
|
|
300 sizeof (struct sockaddr_in));
|
|
|
301 } else if (useicmp) {
|
|
|
302 cc = sendto(sndsock, (char *)outicmp, send_size, 0, to,
|
|
|
303 sizeof (struct sockaddr_in));
|
|
|
304 } else {
|
|
|
305 cc = sendto(sndsock, (char *)outp, send_size, 0, to,
|
|
|
306 sizeof (struct sockaddr_in));
|
|
|
307 }
|
|
|
308
|
|
|
309 if (cc < 0 || cc != send_size) {
|
|
|
310 if (cc < 0) {
|
|
|
311 Fprintf(stderr, "%s: sendto: %s\n", prog,
|
|
|
312 strerror(errno));
|
|
|
313 }
|
|
|
314 Printf("%s: wrote %s %d chars, ret=%d\n",
|
|
|
315 prog, hostname, send_size, cc);
|
|
|
316 (void) fflush(stdout);
|
|
|
317 }
|
|
|
318 }
|
|
|
319
|
|
|
320 /*
|
|
|
321 * Check out the reply packet to see if it's what we were expecting.
|
|
|
322 * Returns REPLY_GOT_TARGET if the reply comes from the target
|
|
|
323 * REPLY_GOT_GATEWAY if an intermediate gateway sends TIME_EXCEEDED
|
|
|
324 * REPLY_GOT_OTHER for other kinds of unreachables indicating none of
|
|
|
325 * the above two cases
|
|
|
326 *
|
|
|
327 * It also sets the icmp type and icmp code values
|
|
|
328 */
|
|
|
329 int
|
|
|
330 check_reply(struct msghdr *msg, int cc, int seq, uchar_t *type, uchar_t *code)
|
|
|
331 {
|
|
|
332 uchar_t *buf = msg->msg_iov->iov_base;
|
|
|
333 struct sockaddr_in *from_in = (struct sockaddr_in *)msg->msg_name;
|
|
|
334 struct icmp *icp;
|
|
|
335 int hlen;
|
|
|
336 int save_cc = cc;
|
|
|
337 struct ip *ip;
|
|
|
338
|
|
|
339 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
340 ip = (struct ip *)buf;
|
|
|
341 hlen = ip->ip_hl << 2;
|
|
|
342 if (cc < hlen + ICMP_MINLEN) {
|
|
|
343 if (verbose) {
|
|
|
344 Printf("packet too short (%d bytes) from %s\n",
|
|
|
345 cc, inet_ntoa(from_in->sin_addr));
|
|
|
346 }
|
|
|
347 return (REPLY_SHORT_PKT);
|
|
|
348 }
|
|
|
349 cc -= hlen;
|
|
|
350 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
351 icp = (struct icmp *)(buf + hlen);
|
|
|
352
|
|
|
353 *type = icp->icmp_type;
|
|
|
354 *code = icp->icmp_code;
|
|
|
355
|
|
|
356 /*
|
|
|
357 * traceroute interpretes only ICMP_TIMXCEED_INTRANS, ICMP_UNREACH and
|
|
|
358 * ICMP_ECHOREPLY, ignores others
|
|
|
359 */
|
|
|
360 if ((*type == ICMP_TIMXCEED && *code == ICMP_TIMXCEED_INTRANS) ||
|
|
|
361 *type == ICMP_UNREACH || *type == ICMP_ECHOREPLY) {
|
|
|
362 struct ip *hip;
|
|
|
363 struct udphdr *up;
|
|
|
364 struct icmp *hicmp;
|
|
|
365
|
|
|
366 cc -= ICMP_MINLEN;
|
|
|
367 hip = &icp->icmp_ip;
|
|
|
368 hlen = hip->ip_hl << 2;
|
|
|
369 cc -= hlen;
|
|
|
370 if (useicmp) {
|
|
|
371 if (*type == ICMP_ECHOREPLY &&
|
|
|
372 icp->icmp_id == htons(ident) &&
|
|
|
373 icp->icmp_seq == htons(seq))
|
|
|
374 return (REPLY_GOT_TARGET);
|
|
|
375
|
|
|
376 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
377 hicmp = (struct icmp *)((uchar_t *)hip + hlen);
|
|
|
378
|
|
|
379 if (ICMP_MINLEN <= cc &&
|
|
|
380 hip->ip_p == IPPROTO_ICMP &&
|
|
|
381 hicmp->icmp_id == htons(ident) &&
|
|
|
382 hicmp->icmp_seq == htons(seq)) {
|
|
|
383 return ((*type == ICMP_TIMXCEED) ?
|
|
|
384 REPLY_GOT_GATEWAY : REPLY_GOT_OTHER);
|
|
|
385 }
|
|
|
386 } else {
|
|
|
387 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
388 up = (struct udphdr *)((uchar_t *)hip + hlen);
|
|
|
389 /*
|
|
|
390 * at least 4 bytes of UDP header is required for this
|
|
|
391 * check
|
|
|
392 */
|
|
|
393 if (4 <= cc &&
|
|
|
394 hip->ip_p == IPPROTO_UDP &&
|
|
|
395 up->uh_sport == htons(ident) &&
|
|
|
396 up->uh_dport == htons((port + seq) %
|
|
|
397 (MAX_PORT + 1))) {
|
|
|
398 if (*type == ICMP_UNREACH &&
|
|
|
399 *code == ICMP_UNREACH_PORT) {
|
|
|
400 return (REPLY_GOT_TARGET);
|
|
|
401 } else if (*type == ICMP_TIMXCEED) {
|
|
|
402 return (REPLY_GOT_GATEWAY);
|
|
|
403 } else {
|
|
|
404 return (REPLY_GOT_OTHER);
|
|
|
405 }
|
|
|
406 }
|
|
|
407 }
|
|
|
408 }
|
|
|
409
|
|
|
410 if (verbose) {
|
|
|
411 int i, j;
|
|
|
412 uchar_t *lp = (uchar_t *)ip;
|
|
|
413
|
|
|
414 cc = save_cc;
|
|
|
415 Printf("\n%d bytes from %s to ", cc,
|
|
|
416 inet_ntoa(from_in->sin_addr));
|
|
|
417 Printf("%s: icmp type %d (%s) code %d\n",
|
|
|
418 inet_ntoa(ip->ip_dst), *type, pr_type(*type), *code);
|
|
|
419 for (i = 0; i < cc; i += 4) {
|
|
|
420 Printf("%2d: x", i);
|
|
|
421 for (j = 0; ((j < 4) && ((i + j) < cc)); j++)
|
|
|
422 Printf("%2.2x", *lp++);
|
|
|
423 (void) putchar('\n');
|
|
|
424 }
|
|
|
425 }
|
|
|
426
|
|
|
427 return (REPLY_SHORT_PKT);
|
|
|
428 }
|
|
|
429
|
|
|
430 /*
|
|
|
431 * convert an ICMP "type" field to a printable string.
|
|
|
432 */
|
|
|
433 static char *
|
|
|
434 pr_type(uchar_t type)
|
|
|
435 {
|
|
|
436 static struct icmptype_table ttab[] = {
|
|
|
437 {ICMP_ECHOREPLY, "Echo Reply"},
|
|
|
438 {1, "ICMP 1"},
|
|
|
439 {2, "ICMP 2"},
|
|
|
440 {ICMP_UNREACH, "Dest Unreachable"},
|
|
|
441 {ICMP_SOURCEQUENCH, "Source Quench"},
|
|
|
442 {ICMP_REDIRECT, "Redirect"},
|
|
|
443 {6, "ICMP 6"},
|
|
|
444 {7, "ICMP 7"},
|
|
|
445 {ICMP_ECHO, "Echo"},
|
|
|
446 {ICMP_ROUTERADVERT, "Router Advertisement"},
|
|
|
447 {ICMP_ROUTERSOLICIT, "Router Solicitation"},
|
|
|
448 {ICMP_TIMXCEED, "Time Exceeded"},
|
|
|
449 {ICMP_PARAMPROB, "Param Problem"},
|
|
|
450 {ICMP_TSTAMP, "Timestamp"},
|
|
|
451 {ICMP_TSTAMPREPLY, "Timestamp Reply"},
|
|
|
452 {ICMP_IREQ, "Info Request"},
|
|
|
453 {ICMP_IREQREPLY, "Info Reply"},
|
|
|
454 {ICMP_MASKREQ, "Netmask Request"},
|
|
|
455 {ICMP_MASKREPLY, "Netmask Reply"}
|
|
|
456 };
|
|
|
457 int i = 0;
|
|
|
458
|
|
|
459 for (i = 0; i < A_CNT(ttab); i++) {
|
|
|
460 if (ttab[i].type == type)
|
|
|
461 return (ttab[i].message);
|
|
|
462 }
|
|
|
463
|
|
|
464 return ("OUT-OF-RANGE");
|
|
|
465 }
|
|
|
466
|
|
|
467 /*
|
|
|
468 * print the IPv4 src address of the reply packet
|
|
|
469 */
|
|
|
470 void
|
|
|
471 print_addr(uchar_t *buf, int cc, struct sockaddr *from)
|
|
|
472 {
|
|
|
473 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
474 struct sockaddr_in *from_in = (struct sockaddr_in *)from;
|
|
|
475 struct ip *ip;
|
|
|
476 union any_in_addr ip_addr;
|
|
|
477
|
|
|
478 ip_addr.addr = from_in->sin_addr;
|
|
|
479
|
|
|
480 /* LINTED E_BAD_PTR_CAST_ALIGN */
|
|
|
481 ip = (struct ip *)buf;
|
|
|
482
|
|
|
483 if (nflag) {
|
|
|
484 Printf(" %s", inet_ntoa(from_in->sin_addr));
|
|
|
485 } else {
|
|
|
486 Printf(" %s (%s)", inet_name(&ip_addr, AF_INET),
|
|
|
487 inet_ntoa(from_in->sin_addr));
|
|
|
488 }
|
|
|
489
|
|
|
490 if (verbose)
|
|
|
491 Printf(" %d bytes to %s", cc, inet_ntoa(ip->ip_dst));
|
|
|
492 }
|
|
|
493
|
|
|
494 /*
|
|
|
495 * ICMP messages which doesn't mean we got the target, or we got a gateway, are
|
|
|
496 * processed here. It returns _B_TRUE if it's some sort of 'unreachable'.
|
|
|
497 */
|
|
|
498 boolean_t
|
|
|
499 print_icmp_other(uchar_t type, uchar_t code)
|
|
|
500 {
|
|
|
501 boolean_t unreach = _B_FALSE;
|
|
|
502
|
|
|
503 /*
|
|
|
504 * this function only prints '!*' for ICMP unreachable messages,
|
|
|
505 * ignores others.
|
|
|
506 */
|
|
|
507 if (type != ICMP_UNREACH) {
|
|
|
508 return (_B_FALSE);
|
|
|
509 }
|
|
|
510
|
|
|
511 switch (code) {
|
|
|
512 case ICMP_UNREACH_PORT:
|
|
|
513 break;
|
|
|
514
|
|
|
515 case ICMP_UNREACH_NET_UNKNOWN:
|
|
|
516 case ICMP_UNREACH_NET:
|
|
|
517 unreach = _B_TRUE;
|
|
|
518 Printf(" !N");
|
|
|
519 break;
|
|
|
520
|
|
|
521 case ICMP_UNREACH_HOST_UNKNOWN:
|
|
|
522 case ICMP_UNREACH_HOST:
|
|
|
523 unreach = _B_TRUE;
|
|
|
524 Printf(" !H");
|
|
|
525 break;
|
|
|
526
|
|
|
527 case ICMP_UNREACH_PROTOCOL:
|
|
|
528 Printf(" !P");
|
|
|
529 break;
|
|
|
530
|
|
|
531 case ICMP_UNREACH_NEEDFRAG:
|
|
|
532 unreach = _B_TRUE;
|
|
|
533 Printf(" !F");
|
|
|
534 break;
|
|
|
535
|
|
|
536 case ICMP_UNREACH_SRCFAIL:
|
|
|
537 unreach = _B_TRUE;
|
|
|
538 Printf(" !S");
|
|
|
539 break;
|
|
|
540
|
|
|
541 case ICMP_UNREACH_FILTER_PROHIB:
|
|
|
542 case ICMP_UNREACH_NET_PROHIB:
|
|
|
543 case ICMP_UNREACH_HOST_PROHIB:
|
|
|
544 unreach = _B_TRUE;
|
|
|
545 Printf(" !X");
|
|
|
546 break;
|
|
|
547
|
|
|
548 case ICMP_UNREACH_TOSNET:
|
|
|
549 case ICMP_UNREACH_TOSHOST:
|
|
|
550 unreach = _B_TRUE;
|
|
|
551 Printf(" !T");
|
|
|
552 break;
|
|
|
553
|
|
|
554 case ICMP_UNREACH_ISOLATED:
|
|
|
555 case ICMP_UNREACH_HOST_PRECEDENCE:
|
|
|
556 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
|
|
|
557 unreach = _B_TRUE;
|
|
|
558 Printf(" !U");
|
|
|
559 break;
|
|
|
560
|
|
|
561 default:
|
|
|
562 unreach = _B_TRUE;
|
|
|
563 Printf(" !<%d>", code);
|
|
|
564 break;
|
|
|
565 }
|
|
|
566
|
|
|
567 return (unreach);
|
|
|
568 }
|
