Annotation of embedaddon/mtr/packet/command.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 "command.h"
20:
21: #include <assert.h>
22: #include <errno.h>
23: #include <stdbool.h>
24: #include <stdio.h>
25: #include <stdlib.h>
26: #include <string.h>
27: #include <strings.h>
28:
29: #include "cmdparse.h"
30: #include "platform.h"
31: #include "config.h"
32:
33: /*
34: Find a parameter with a particular name in a command_t structure.
35: If no such parameter exists, return NULL.
36: */
37: static
38: const char *find_parameter(
39: const struct command_t *command,
40: const char *name_request)
41: {
42: const char *name;
43: const char *value;
44: int i;
45:
46: for (i = 0; i < command->argument_count; i++) {
47: name = command->argument_name[i];
48: value = command->argument_value[i];
49:
50: if (!strcmp(name, name_request)) {
51: return value;
52: }
53: }
54:
55: return NULL;
56: }
57:
58: /* Returns a feature support string for a particular probe protocol */
59: static
60: const char *check_protocol_support(
61: struct net_state_t *net_state,
62: int protocol)
63: {
64: if (is_protocol_supported(net_state, protocol)) {
65: return "ok";
66: } else {
67: return "no";
68: }
69: }
70:
71: /* Return a feature support string for an IP protocol version */
72: static
73: const char *check_ip_version_support(
74: struct net_state_t *net_state,
75: int ip_version)
76: {
77: if (is_ip_version_supported(net_state, ip_version)) {
78: return "ok";
79: } else {
80: return "no";
81: }
82: }
83:
84: /* Given a feature name, return a string for the check-support reply */
85: static
86: const char *check_support(
87: const char *feature,
88: struct net_state_t *net_state)
89: {
90: if (!strcmp(feature, "version")) {
91: return PACKAGE_VERSION;
92: }
93:
94: if (!strcmp(feature, "ip-4")) {
95: return check_ip_version_support(net_state, 4);
96: }
97:
98: if (!strcmp(feature, "ip-6")) {
99: return check_ip_version_support(net_state, 6);
100: }
101:
102: if (!strcmp(feature, "send-probe")) {
103: return "ok";
104: }
105:
106: if (!strcmp(feature, "icmp")) {
107: return check_protocol_support(net_state, IPPROTO_ICMP);
108: }
109:
110: if (!strcmp(feature, "udp")) {
111: return check_protocol_support(net_state, IPPROTO_UDP);
112: }
113:
114: if (!strcmp(feature, "tcp")) {
115: return check_protocol_support(net_state, IPPROTO_TCP);
116: }
117: #ifdef IPPROTO_SCTP
118: if (!strcmp(feature, "sctp")) {
119: return check_protocol_support(net_state, IPPROTO_SCTP);
120: }
121: #endif
122:
123: #ifdef SO_MARK
124: if (!strcmp(feature, "mark")) {
125: return "ok";
126: }
127: #endif
128:
129: return "no";
130: }
131:
132: /* Handle a check-support request by checking for a particular feature */
133: static
134: void check_support_command(
135: const struct command_t *command,
136: struct net_state_t *net_state)
137: {
138: const char *feature;
139: const char *support;
140:
141: feature = find_parameter(command, "feature");
142: if (feature == NULL) {
143: printf("%d invalid-argument\n", command->token);
144: return;
145: }
146:
147: support = check_support(feature, net_state);
148: printf("%d feature-support support %s\n", command->token, support);
149: }
150:
151: /*
152: If a named send_probe argument is recognized, fill in the probe paramters
153: structure with the argument value.
154: */
155: static
156: bool decode_probe_argument(
157: struct probe_param_t *param,
158: const char *name,
159: const char *value)
160: {
161: char *endstr = NULL;
162:
163: /* Pass IPv4 addresses as string values */
164: if (!strcmp(name, "ip-4")) {
165: param->ip_version = 4;
166: param->remote_address = value;
167: }
168:
169: /* IPv6 address */
170: if (!strcmp(name, "ip-6")) {
171: param->ip_version = 6;
172: param->remote_address = value;
173: }
174:
175: /* IPv4 address to send from */
176: if (!strcmp(name, "local-ip-4")) {
177: param->local_address = value;
178: }
179:
180: /* IPv6 address to send from */
181: if (!strcmp(name, "local-ip-6")) {
182: param->local_address = value;
183: }
184:
185: /* Protocol for the probe */
186: if (!strcmp(name, "protocol")) {
187: if (!strcmp(value, "icmp")) {
188: param->protocol = IPPROTO_ICMP;
189: } else if (!strcmp(value, "udp")) {
190: param->protocol = IPPROTO_UDP;
191: } else if (!strcmp(value, "tcp")) {
192: param->protocol = IPPROTO_TCP;
193: #ifdef IPPROTO_SCTP
194: } else if (!strcmp(value, "sctp")) {
195: param->protocol = IPPROTO_SCTP;
196: #endif
197: } else {
198: return false;
199: }
200: }
201:
202: /* Destination port for the probe */
203: if (!strcmp(name, "port")) {
204: param->dest_port = strtol(value, &endstr, 10);
205: if (*endstr != 0) {
206: return false;
207: }
208: }
209:
210: /* The local port to send UDP probes from */
211: if (!strcmp(name, "local-port")) {
212: param->local_port = strtol(value, &endstr, 10);
213: if (*endstr != 0) {
214: return false;
215: }
216:
217: /*
218: Don't allow using a local port which requires
219: privileged binding.
220: */
221: if (param->local_port < 1024) {
222: param->local_port = 0;
223: return false;
224: }
225: }
226:
227: /* The "type of service" field for the IP header */
228: if (!strcmp(name, "tos")) {
229: param->type_of_service = strtol(value, &endstr, 10);
230: if (*endstr != 0) {
231: return false;
232: }
233: }
234:
235: /* The Linux packet mark for mark-based routing */
236: if (!strcmp(name, "mark")) {
237: param->routing_mark = strtol(value, &endstr, 10);
238: if (*endstr != 0) {
239: return false;
240: }
241: }
242:
243: /* The size of the packet (including headers) */
244: if (!strcmp(name, "size")) {
245: param->packet_size = strtol(value, &endstr, 10);
246: if (*endstr != 0) {
247: return false;
248: }
249: }
250:
251: /* The packet's bytes will be filled with this value */
252: if (!strcmp(name, "bit-pattern")) {
253: param->bit_pattern = strtol(value, &endstr, 10);
254: if (*endstr != 0) {
255: return false;
256: }
257: }
258:
259: /* Time-to-live values */
260: if (!strcmp(name, "ttl")) {
261: param->ttl = strtol(value, &endstr, 10);
262: if (*endstr != 0) {
263: return false;
264: }
265: }
266:
267: /* Number of seconds to wait for a reply */
268: if (!strcmp(name, "timeout")) {
269: param->timeout = strtol(value, &endstr, 10);
270: if (*endstr != 0) {
271: return false;
272: }
273: }
274:
275: return true;
276: }
277:
278: /*
279: Check the probe parameters against currently supported features
280: and report and error if there is a problem.
281:
282: Return true if everything is okay, false otherwise.
283: */
284: static
285: bool validate_probe_parameters(
286: struct net_state_t *net_state,
287: struct probe_param_t *param)
288: {
289: if (!is_ip_version_supported(net_state, param->ip_version)) {
290: printf("%d invalid-argument reason ip-version-not-supported\n",
291: param->command_token);
292:
293: return false;
294: }
295:
296: if (!is_protocol_supported(net_state, param->protocol)) {
297: printf("%d invalid-argument reason protocol-not-supported\n",
298: param->command_token);
299:
300: return false;
301: }
302:
303: return true;
304: }
305:
306: /* Handle "send-probe" commands */
307: static
308: void send_probe_command(
309: const struct command_t *command,
310: struct net_state_t *net_state)
311: {
312: struct probe_param_t param;
313: int i;
314: char *name;
315: char *value;
316:
317: /* We will prepare a probe_param_t for send_probe. */
318: memset(¶m, 0, sizeof(struct probe_param_t));
319: param.command_token = command->token;
320: param.protocol = IPPROTO_ICMP;
321: param.ttl = 255;
322: param.packet_size = 64;
323: param.timeout = 10;
324:
325: for (i = 0; i < command->argument_count; i++) {
326: name = command->argument_name[i];
327: value = command->argument_value[i];
328:
329: if (!decode_probe_argument(¶m, name, value)) {
330: printf("%d invalid-argument\n", command->token);
331: return;
332: }
333: }
334:
335: if (!validate_probe_parameters(net_state, ¶m)) {
336: return;
337: }
338:
339: /* Send the probe using a platform specific mechanism */
340: send_probe(net_state, ¶m);
341: }
342:
343: /*
344: Given a parsed command, dispatch to the handler for specific
345: command requests.
346: */
347: static
348: void dispatch_command(
349: const struct command_t *command,
350: struct net_state_t *net_state)
351: {
352: if (!strcmp(command->command_name, "check-support")) {
353: check_support_command(command, net_state);
354: } else if (!strcmp(command->command_name, "send-probe")) {
355: send_probe_command(command, net_state);
356: } else {
357: /* For unrecognized commands, respond with an error */
358: printf("%d unknown-command\n", command->token);
359: }
360: }
361:
362: /*
363: With newly read data in our command buffer, dispatch all completed
364: command requests.
365: */
366: void dispatch_buffer_commands(
367: struct command_buffer_t *buffer,
368: struct net_state_t *net_state)
369: {
370: struct command_t command;
371: char *end_of_command;
372: char full_command[COMMAND_BUFFER_SIZE];
373: int command_length;
374: int remaining_count;
375:
376: while (true) {
377: assert(buffer->incoming_read_position < COMMAND_BUFFER_SIZE);
378:
379: /* Terminate the buffer string */
380: buffer->incoming_buffer[buffer->incoming_read_position] = 0;
381:
382: /* Find the next newline, which terminates command requests */
383: end_of_command = index(buffer->incoming_buffer, '\n');
384: if (end_of_command == NULL) {
385: /*
386: No newlines found, so any data we've read so far is
387: not yet complete.
388: */
389: break;
390: }
391:
392: command_length = end_of_command - buffer->incoming_buffer;
393: remaining_count =
394: buffer->incoming_read_position - command_length - 1;
395:
396: /* Copy the completed command */
397: memmove(full_command, buffer->incoming_buffer, command_length);
398: full_command[command_length] = 0;
399:
400: /*
401: Free the space used by the completed command by advancing the
402: remaining requests within the buffer.
403: */
404: memmove(buffer->incoming_buffer, end_of_command + 1,
405: remaining_count);
406: buffer->incoming_read_position -= command_length + 1;
407:
408: if (parse_command(&command, full_command)) {
409: /* If the command fails to parse, respond with an error */
410: printf("0 command-parse-error\n");
411: } else {
412: dispatch_command(&command, net_state);
413: }
414: }
415:
416: if (buffer->incoming_read_position >= COMMAND_BUFFER_SIZE - 1) {
417: /*
418: If we've filled the buffer without a complete command, the
419: only thing we can do is discard what we've read and hope that
420: new data is better formatted.
421: */
422: printf("0 command-buffer-overflow\n");
423: buffer->incoming_read_position = 0;
424: }
425: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to command.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