Annotation of embedaddon/mtr/packet/probe.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 <arpa/inet.h>
22: #include <assert.h>
23: #include <errno.h>
24: #include <stdio.h>
25: #include <stdlib.h>
26: #include <string.h>
27: #include <sys/socket.h>
28: #include <unistd.h>
29:
30: #include "command.h"
31: #include "platform.h"
32: #include "protocols.h"
33: #include "timeval.h"
34:
35: #define IP_TEXT_LENGTH 64
36:
37: /* Convert the destination address from text to sockaddr */
38: int decode_address_string(
39: int ip_version,
40: const char *address_string,
41: struct sockaddr_storage *address)
42: {
43: struct in_addr addr4;
44: struct in6_addr addr6;
45: struct sockaddr_in *sockaddr4;
46: struct sockaddr_in6 *sockaddr6;
47:
48: if (address == NULL) {
49: errno = EINVAL;
50: return -1;
51: }
52:
53: if (ip_version == 6) {
54: sockaddr6 = (struct sockaddr_in6 *) address;
55:
56: if (inet_pton(AF_INET6, address_string, &addr6) != 1) {
57: errno = EINVAL;
58: return -1;
59: }
60:
61: sockaddr6->sin6_family = AF_INET6;
62: sockaddr6->sin6_port = 0;
63: sockaddr6->sin6_flowinfo = 0;
64: sockaddr6->sin6_addr = addr6;
65: sockaddr6->sin6_scope_id = 0;
66: } else if (ip_version == 4) {
67: sockaddr4 = (struct sockaddr_in *) address;
68:
69: if (inet_pton(AF_INET, address_string, &addr4) != 1) {
70: errno = EINVAL;
71: return -1;
72: }
73:
74: sockaddr4->sin_family = AF_INET;
75: sockaddr4->sin_port = 0;
76: sockaddr4->sin_addr = addr4;
77: } else {
78: errno = EINVAL;
79: return -1;
80: }
81:
82: return 0;
83: }
84:
85: /*
86: Resolve the probe parameters into a remote and local address
87: for the probe.
88: */
89: int resolve_probe_addresses(
90: const struct probe_param_t *param,
91: struct sockaddr_storage *dest_sockaddr,
92: struct sockaddr_storage *src_sockaddr)
93: {
94: if (decode_address_string
95: (param->ip_version, param->remote_address, dest_sockaddr)) {
96: return -1;
97: }
98:
99: if (param->local_address) {
100: if (decode_address_string
101: (param->ip_version, param->local_address, src_sockaddr)) {
102: return -1;
103: }
104: } else {
105: if (find_source_addr(src_sockaddr, dest_sockaddr)) {
106: return -1;
107: }
108: }
109:
110: return 0;
111: }
112:
113: /* Allocate a structure for tracking a new probe */
114: struct probe_t *alloc_probe(
115: struct net_state_t *net_state,
116: int token)
117: {
118: struct probe_t *probe;
119:
120: if (net_state->outstanding_probe_count >= MAX_PROBES) {
121: return NULL;
122: }
123:
124: probe = malloc(sizeof(struct probe_t));
125: if (probe == NULL) {
126: return NULL;
127: }
128:
129: memset(probe, 0, sizeof(struct probe_t));
130: probe->token = token;
131:
132: platform_alloc_probe(net_state, probe);
133:
134: net_state->outstanding_probe_count++;
135: LIST_INSERT_HEAD(&net_state->outstanding_probes, probe,
136: probe_list_entry);
137:
138: return probe;
139: }
140:
141: /* Mark a probe tracking structure as unused */
142: void free_probe(
143: struct net_state_t *net_state,
144: struct probe_t *probe)
145: {
146: LIST_REMOVE(probe, probe_list_entry);
147: net_state->outstanding_probe_count--;
148:
149: platform_free_probe(probe);
150:
151: free(probe);
152: }
153:
154: /*
155: Find an existing probe structure by ICMP id and sequence number.
156: Returns NULL if non is found.
157: */
158: struct probe_t *find_probe(
159: struct net_state_t *net_state,
160: int protocol,
161: int id,
162: int sequence)
163: {
164: struct probe_t *probe;
165:
166: /*
167: ICMP has room for an id to check against our process, but
168: UDP doesn't.
169: */
170: if (protocol == IPPROTO_ICMP) {
171: /*
172: If the ICMP id doesn't match our process ID, it wasn't a
173: probe generated by this process, so ignore it.
174: */
175: if (id != htons(getpid())) {
176: return NULL;
177: }
178: }
179:
180: LIST_FOREACH(probe, &net_state->outstanding_probes, probe_list_entry) {
181: if (htons(probe->sequence) == sequence) {
182: return probe;
183: }
184: }
185:
186: return NULL;
187: }
188:
189: /*
190: Format a list of MPLS labels into a string appropriate for including
191: as an argument to a probe reply.
192: */
193: static
194: void format_mpls_string(
195: char *str,
196: int buffer_size,
197: int mpls_count,
198: const struct mpls_label_t *mpls_list)
199: {
200: int i;
201: char *append_pos = str;
202: const struct mpls_label_t *mpls;
203:
204: /* Start with an empty string */
205: str[0] = 0;
206:
207: for (i = 0; i < mpls_count; i++) {
208: mpls = &mpls_list[i];
209:
210: if (i > 0) {
211: strncat(append_pos, ",", buffer_size - 1);
212:
213: buffer_size -= strlen(append_pos);
214: append_pos += strlen(append_pos);
215: }
216:
217: snprintf(append_pos, buffer_size, "%d,%d,%d,%d",
218: mpls->label, mpls->experimental_use,
219: mpls->bottom_of_stack, mpls->ttl);
220:
221: buffer_size -= strlen(append_pos);
222: append_pos += strlen(append_pos);
223: }
224: }
225:
226: /*
227: After a probe reply has arrived, respond to the command request which
228: sent the probe.
229: */
230: void respond_to_probe(
231: struct net_state_t *net_state,
232: struct probe_t *probe,
233: int icmp_type,
234: const struct sockaddr_storage *remote_addr,
235: unsigned int round_trip_us,
236: int mpls_count,
237: const struct mpls_label_t *mpls)
238: {
239: char ip_text[IP_TEXT_LENGTH];
240: char response[COMMAND_BUFFER_SIZE];
241: char mpls_str[COMMAND_BUFFER_SIZE];
242: int remaining_size;
243: const char *result;
244: const char *ip_argument;
245: struct sockaddr_in *sockaddr4;
246: struct sockaddr_in6 *sockaddr6;
247: void *addr;
248:
249: if (icmp_type == ICMP_TIME_EXCEEDED) {
250: result = "ttl-expired";
251: } else {
252: assert(icmp_type == ICMP_ECHOREPLY);
253: result = "reply";
254: }
255:
256: if (remote_addr->ss_family == AF_INET6) {
257: ip_argument = "ip-6";
258: sockaddr6 = (struct sockaddr_in6 *) remote_addr;
259: addr = &sockaddr6->sin6_addr;
260: } else {
261: ip_argument = "ip-4";
262: sockaddr4 = (struct sockaddr_in *) remote_addr;
263: addr = &sockaddr4->sin_addr;
264: }
265:
266: if (inet_ntop(remote_addr->ss_family, addr, ip_text, IP_TEXT_LENGTH) ==
267: NULL) {
268:
269: perror("inet_ntop failure");
270: exit(EXIT_FAILURE);
271: }
272:
273: snprintf(response, COMMAND_BUFFER_SIZE,
274: "%d %s %s %s round-trip-time %d",
275: probe->token, result, ip_argument, ip_text, round_trip_us);
276:
277: if (mpls_count) {
278: format_mpls_string(mpls_str, COMMAND_BUFFER_SIZE, mpls_count,
279: mpls);
280:
281: remaining_size = COMMAND_BUFFER_SIZE - strlen(response) - 1;
282: strncat(response, " mpls ", remaining_size);
283:
284: remaining_size = COMMAND_BUFFER_SIZE - strlen(response) - 1;
285: strncat(response, mpls_str, remaining_size);
286: }
287:
288: puts(response);
289: free_probe(net_state, probe);
290: }
291:
292: /*
293: Find the source address for transmitting to a particular destination
294: address. Remember that hosts can have multiple addresses, for example
295: a unique address for each network interface. So we will bind a UDP
296: socket to our destination and check the socket address after binding
297: to get the source for that destination, which will allow the kernel
298: to do the routing table work for us.
299:
300: (connecting UDP sockets, unlike TCP sockets, doesn't transmit any packets.
301: It's just an association.)
302: */
303: int find_source_addr(
304: struct sockaddr_storage *srcaddr,
305: const struct sockaddr_storage *destaddr)
306: {
307: int sock;
308: int len;
309: struct sockaddr_in *destaddr4;
310: struct sockaddr_in6 *destaddr6;
311: struct sockaddr_storage dest_with_port;
312: struct sockaddr_in *srcaddr4;
313: struct sockaddr_in6 *srcaddr6;
314:
315: dest_with_port = *destaddr;
316:
317: /*
318: MacOS requires a non-zero sin_port when used as an
319: address for a UDP connect. If we provide a zero port,
320: the connect will fail. We aren't actually sending
321: anything to the port.
322: */
323: if (destaddr->ss_family == AF_INET6) {
324: destaddr6 = (struct sockaddr_in6 *) &dest_with_port;
325: destaddr6->sin6_port = htons(1);
326:
327: len = sizeof(struct sockaddr_in6);
328: } else {
329: destaddr4 = (struct sockaddr_in *) &dest_with_port;
330: destaddr4->sin_port = htons(1);
331:
332: len = sizeof(struct sockaddr_in);
333: }
334:
335: sock = socket(destaddr->ss_family, SOCK_DGRAM, IPPROTO_UDP);
336: if (sock == -1) {
337: return -1;
338: }
339:
340: if (connect(sock, (struct sockaddr *) &dest_with_port, len)) {
341: close(sock);
342: return -1;
343: }
344:
345: if (getsockname(sock, (struct sockaddr *) srcaddr, &len)) {
346: close(sock);
347: return -1;
348: }
349:
350: close(sock);
351:
352: /*
353: Zero the port, as we may later use this address to finding, and
354: we don't want to use the port from the socket we just created.
355: */
356: if (destaddr->ss_family == AF_INET6) {
357: srcaddr6 = (struct sockaddr_in6 *) srcaddr;
358:
359: srcaddr6->sin6_port = 0;
360: } else {
361: srcaddr4 = (struct sockaddr_in *) srcaddr;
362:
363: srcaddr4->sin_port = 0;
364: }
365:
366: return 0;
367: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to probe.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