Annotation of embedaddon/mtr/packet/probe_cygwin.c, revision 1.1.1.1
1.1 misho 1: /*
2: mtr -- a network diagnostic tool
3: Copyright (C) 2016 Matt Kimball
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License version 2 as
7: published by the Free Software Foundation.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: GNU General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; if not, write to the Free Software
16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: #include "probe.h"
20:
21: #include <errno.h>
22: #include <stdio.h>
23: #include <winternl.h>
24:
25: #include "protocols.h"
26:
27: /* Windows doesn't require any initialization at a privileged level */
28: void init_net_state_privileged(
29: struct net_state_t *net_state)
30: {
31: }
32:
33: /* Open the ICMP.DLL interface */
34: void init_net_state(
35: struct net_state_t *net_state)
36: {
37: memset(net_state, 0, sizeof(struct net_state_t));
38:
39: net_state->platform.icmp4 = IcmpCreateFile();
40: net_state->platform.icmp6 = Icmp6CreateFile();
41:
42: if (net_state->platform.icmp4 == INVALID_HANDLE_VALUE
43: && net_state->platform.icmp6 == INVALID_HANDLE_VALUE) {
44: fprintf(stderr, "Failure opening ICMP %d\n", GetLastError());
45: exit(EXIT_FAILURE);
46: }
47: }
48:
49: /*
50: If we succeeded at opening the ICMP file handle, we can
51: assume that IP protocol version is supported.
52: */
53: bool is_ip_version_supported(
54: struct net_state_t *net_state,
55: int ip_version)
56: {
57: if (ip_version == 4) {
58: return (net_state->platform.icmp4 != INVALID_HANDLE_VALUE);
59: } else if (ip_version == 6) {
60: return (net_state->platform.icmp6 != INVALID_HANDLE_VALUE);
61: }
62:
63: return false;
64: }
65:
66: /* On Windows, we only support ICMP probes */
67: bool is_protocol_supported(
68: struct net_state_t * net_state,
69: int protocol)
70: {
71: if (protocol == IPPROTO_ICMP) {
72: return true;
73: }
74:
75: return false;
76: }
77:
78: /* Set the back pointer to the net_state when a probe is allocated */
79: void platform_alloc_probe(
80: struct net_state_t *net_state,
81: struct probe_t *probe)
82: {
83: probe->platform.net_state = net_state;
84: }
85:
86: /* Free the reply buffer when the probe is freed */
87: void platform_free_probe(
88: struct probe_t *probe)
89: {
90: if (probe->platform.reply4) {
91: free(probe->platform.reply4);
92: probe->platform.reply4 = NULL;
93: }
94: }
95:
96: /* Report a windows error code using a platform-independent error string */
97: static
98: void report_win_error(
99: int command_token,
100: int err)
101: {
102: /* It could be that we got no reply because of timeout */
103: if (err == IP_REQ_TIMED_OUT || err == IP_SOURCE_QUENCH) {
104: printf("%d no-reply\n", command_token);
105: } else if (err == IP_DEST_HOST_UNREACHABLE
106: || err == IP_DEST_PORT_UNREACHABLE
107: || err == IP_DEST_PROT_UNREACHABLE
108: || err == IP_DEST_NET_UNREACHABLE
109: || err == IP_DEST_UNREACHABLE
110: || err == IP_DEST_NO_ROUTE
111: || err == IP_BAD_ROUTE || err == IP_BAD_DESTINATION) {
112: printf("%d no-route\n", command_token);
113: } else if (err == ERROR_INVALID_NETNAME) {
114: printf("%d address-not-available\n", command_token);
115: } else if (err == ERROR_INVALID_PARAMETER) {
116: printf("%d invalid-argument\n", command_token);
117: } else {
118: printf("%d unexpected-error winerror %d\n", command_token, err);
119: }
120: }
121:
122: /*
123: The overlapped I/O style completion routine to be called by
124: Windows during an altertable wait when an ICMP probe has
125: completed, either by reply, or by ICMP.DLL timeout.
126: */
127: static
128: void WINAPI on_icmp_reply(
129: PVOID context,
130: PIO_STATUS_BLOCK status,
131: ULONG reserved)
132: {
133: struct probe_t *probe = (struct probe_t *) context;
134: struct net_state_t *net_state = probe->platform.net_state;
135: int icmp_type;
136: int round_trip_us = 0;
137: int reply_count;
138: int reply_status = 0;
139: struct sockaddr_storage remote_addr;
140: struct sockaddr_in *remote_addr4;
141: struct sockaddr_in6 *remote_addr6;
142: ICMP_ECHO_REPLY32 *reply4;
143: ICMPV6_ECHO_REPLY *reply6;
144:
145: if (probe->platform.ip_version == 6) {
146: reply6 = probe->platform.reply6;
147: reply_count = Icmp6ParseReplies(reply6, sizeof(ICMPV6_ECHO_REPLY));
148:
149: if (reply_count > 0) {
150: reply_status = reply6->Status;
151:
152: /* Unfortunately, ICMP.DLL only has millisecond precision */
153: round_trip_us = reply6->RoundTripTime * 1000;
154:
155: remote_addr6 = (struct sockaddr_in6 *) &remote_addr;
156: remote_addr6->sin6_family = AF_INET6;
157: remote_addr6->sin6_port = 0;
158: remote_addr6->sin6_flowinfo = 0;
159: memcpy(&remote_addr6->sin6_addr, reply6->AddressBits,
160: sizeof(struct in6_addr));
161: remote_addr6->sin6_scope_id = 0;
162: }
163: } else {
164: reply4 = probe->platform.reply4;
165: reply_count = IcmpParseReplies(reply4, sizeof(ICMP_ECHO_REPLY));
166:
167: if (reply_count > 0) {
168: reply_status = reply4->Status;
169:
170: /* Unfortunately, ICMP.DLL only has millisecond precision */
171: round_trip_us = reply4->RoundTripTime * 1000;
172:
173: remote_addr4 = (struct sockaddr_in *) &remote_addr;
174: remote_addr4->sin_family = AF_INET;
175: remote_addr4->sin_port = 0;
176: remote_addr4->sin_addr.s_addr = reply4->Address;
177: }
178: }
179:
180: if (reply_count == 0) {
181: reply_status = GetLastError();
182: }
183:
184: icmp_type = -1;
185: if (reply_status == IP_SUCCESS) {
186: icmp_type = ICMP_ECHOREPLY;
187: } else if (reply_status == IP_TTL_EXPIRED_TRANSIT
188: || reply_status == IP_TTL_EXPIRED_REASSEM) {
189: icmp_type = ICMP_TIME_EXCEEDED;
190: }
191:
192: if (icmp_type != -1) {
193: /* Record probe result */
194: respond_to_probe(net_state, probe, icmp_type,
195: &remote_addr, round_trip_us, 0, NULL);
196: } else {
197: report_win_error(probe->token, reply_status);
198: free_probe(net_state, probe);
199: }
200: }
201:
202: /* Use ICMP.DLL's send echo support to send a probe */
203: static
204: void icmp_send_probe(
205: struct net_state_t *net_state,
206: struct probe_t *probe,
207: const struct probe_param_t *param,
208: struct sockaddr_storage *src_sockaddr,
209: struct sockaddr_storage *dest_sockaddr,
210: char *payload,
211: int payload_size)
212: {
213: IP_OPTION_INFORMATION option;
214: DWORD timeout;
215: DWORD send_result;
216: int reply_size;
217: int err;
218: struct sockaddr_in *dest_sockaddr4;
219: struct sockaddr_in6 *src_sockaddr6;
220: struct sockaddr_in6 *dest_sockaddr6;
221:
222: if (param->timeout > 0) {
223: timeout = 1000 * param->timeout;
224: } else {
225: /*
226: IcmpSendEcho2 will return invalid argument on a timeout of
227: zero. Our Unix implementation allows it. Bump up the timeout
228: to 1 millisecond.
229: */
230: timeout = 1;
231: }
232:
233: memset(&option, 0, sizeof(IP_OPTION_INFORMATION32));
234: option.Ttl = param->ttl;
235:
236: if (param->ip_version == 6) {
237: reply_size = sizeof(ICMPV6_ECHO_REPLY) + payload_size;
238: } else {
239: reply_size = sizeof(ICMP_ECHO_REPLY32) + payload_size;
240: }
241:
242: probe->platform.reply4 = malloc(reply_size);
243: if (probe->platform.reply4 == NULL) {
244: perror("failure to allocate reply buffer");
245: exit(EXIT_FAILURE);
246: }
247:
248: if (param->ip_version == 6) {
249: src_sockaddr6 = (struct sockaddr_in6 *) src_sockaddr;
250: dest_sockaddr6 = (struct sockaddr_in6 *) dest_sockaddr;
251:
252: send_result = Icmp6SendEcho2(net_state->platform.icmp6, NULL,
253: (FARPROC) on_icmp_reply, probe,
254: src_sockaddr6, dest_sockaddr6,
255: payload, payload_size, &option,
256: probe->platform.reply6, reply_size,
257: timeout);
258: } else {
259: dest_sockaddr4 = (struct sockaddr_in *) dest_sockaddr;
260:
261: send_result = IcmpSendEcho2(net_state->platform.icmp4, NULL,
262: (FARPROC) on_icmp_reply, probe,
263: dest_sockaddr4->sin_addr.s_addr,
264: payload, payload_size, &option,
265: probe->platform.reply4, reply_size,
266: timeout);
267: }
268:
269: if (send_result == 0) {
270: err = GetLastError();
271:
272: /*
273: ERROR_IO_PENDING is expected for asynchronous probes,
274: but any other error is unexpected.
275: */
276: if (err != ERROR_IO_PENDING) {
277: report_win_error(probe->token, err);
278: free_probe(net_state, probe);
279: }
280: }
281: }
282:
283: /* Fill the payload of the packet as specified by the probe parameters */
284: static
285: int fill_payload(
286: const struct probe_param_t *param,
287: char *payload,
288: int payload_buffer_size)
289: {
290: int ip_icmp_size;
291: int payload_size;
292:
293: if (param->ip_version == 6) {
294: ip_icmp_size =
295: sizeof(struct IP6Header) + sizeof(struct ICMPHeader);
296: } else if (param->ip_version == 4) {
297: ip_icmp_size = sizeof(struct IPHeader) + sizeof(struct ICMPHeader);
298: } else {
299: errno = EINVAL;
300: return -1;
301: }
302:
303: payload_size = param->packet_size - ip_icmp_size;
304: if (payload_size < 0) {
305: payload_size = 0;
306: }
307:
308: if (payload_size > payload_buffer_size) {
309: errno = EINVAL;
310: return -1;
311: }
312:
313: memset(payload, param->bit_pattern, payload_size);
314:
315: return payload_size;
316: }
317:
318: /* Decode the probe parameters and send a probe */
319: void send_probe(
320: struct net_state_t *net_state,
321: const struct probe_param_t *param)
322: {
323: struct probe_t *probe;
324: struct sockaddr_storage dest_sockaddr;
325: struct sockaddr_storage src_sockaddr;
326: char payload[PACKET_BUFFER_SIZE];
327: int payload_size;
328:
329: if (resolve_probe_addresses(param, &dest_sockaddr, &src_sockaddr)) {
330: printf("%d invalid-argument\n", param->command_token);
331: return;
332: }
333:
334: probe = alloc_probe(net_state, param->command_token);
335: if (probe == NULL) {
336: printf("%d probes-exhausted\n", param->command_token);
337: return;
338: }
339:
340: probe->platform.ip_version = param->ip_version;
341:
342: payload_size = fill_payload(param, payload, PACKET_BUFFER_SIZE);
343: if (payload_size < 0) {
344: perror("Error construction packet");
345: exit(EXIT_FAILURE);
346: }
347:
348: icmp_send_probe(net_state, probe, param,
349: &src_sockaddr, &dest_sockaddr, payload, payload_size);
350: }
351:
352: /*
353: On Windows, an implementation of receive_replies is unnecessary, because,
354: unlike Unix, replies are completed using Overlapped I/O during an
355: alertable wait, and don't require explicit reads.
356: */
357: void receive_replies(
358: struct net_state_t *net_state)
359: {
360: }
361:
362: /*
363: On Windows, an implementation of check_probe_timeout is unnecesary because
364: timeouts are managed by ICMP.DLL, including a call to the I/O completion
365: routine when the time fully expires.
366: */
367: void check_probe_timeouts(
368: struct net_state_t *net_state)
369: {
370: }
371:
372: /*
373: As in the case of check_probe_timeout, getting the next probe timeout is
374: unnecessary under Windows, as ICMP.DLL manages timeouts for us.
375: */
376: bool get_next_probe_timeout(
377: const struct net_state_t *net_state,
378: struct timeval *timeout)
379: {
380: return false;
381: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to probe_cygwin.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / packet