/*
mtr -- a network diagnostic tool
Copyright (C) 2016 Matt Kimball
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "cmdpipe.h"
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/wait.h>
#include <unistd.h>
#ifdef HAVE_ERROR_H
#include <error.h>
#else
#include "portability/error.h"
#endif
#include "packet/cmdparse.h"
#include "display.h"
/* Set a file descriptor to non-blocking */
static
void set_fd_nonblock(
int fd)
{
int flags;
/* Get the current flags of the file descriptor */
flags = fcntl(fd, F_GETFL, 0);
if (flags == -1) {
error(EXIT_FAILURE, errno, "F_GETFL failure");
exit(1);
}
/* Add the O_NONBLOCK bit to the current flags */
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
error(EXIT_FAILURE, errno, "Failure to set O_NONBLOCK");
exit(1);
}
}
/*
Send a command synchronously to mtr-packet, blocking until a result
is available. This is intended to be used at start-up to check the
capabilities of mtr-packet, but probes should be sent asynchronously
to avoid blocking other probes and the user interface.
*/
static
int send_synchronous_command(
struct mtr_ctl *ctl,
struct packet_command_pipe_t *cmdpipe,
const char *cmd,
struct command_t *result)
{
char reply[PACKET_REPLY_BUFFER_SIZE];
int command_length;
int write_length;
int read_length;
/* Query send-probe support */
command_length = strlen(cmd);
write_length = write(cmdpipe->write_fd, cmd, command_length);
if (write_length == -1) {
return -1;
}
if (write_length != command_length) {
errno = EIO;
return -1;
}
/* Read the reply to our query */
read_length =
read(cmdpipe->read_fd, reply, PACKET_REPLY_BUFFER_SIZE - 1);
if (read_length < 0) {
return -1;
}
/* Parse the query reply */
reply[read_length] = 0;
if (parse_command(result, reply)) {
return -1;
}
return 0;
}
/* Check support for a particular feature with the mtr-packet we invoked */
static
int check_feature(
struct mtr_ctl *ctl,
struct packet_command_pipe_t *cmdpipe,
const char *feature)
{
char check_command[COMMAND_BUFFER_SIZE];
struct command_t reply;
snprintf(check_command, COMMAND_BUFFER_SIZE,
"1 check-support feature %s\n", feature);
if (send_synchronous_command(ctl, cmdpipe, check_command, &reply) ==
-1) {
return -1;
}
/* Check that the feature is supported */
if (!strcmp(reply.command_name, "feature-support")
&& reply.argument_count >= 1
&& !strcmp(reply.argument_name[0], "support")
&& !strcmp(reply.argument_value[0], "ok")) {
/* Looks good */
return 0;
}
errno = ENOTSUP;
return -1;
}
/*
Check the protocol selected against the mtr-packet we are using.
Returns zero if everything is fine, or -1 with errno for either
a failure during the check, or for an unsupported feature.
*/
static
int check_packet_features(
struct mtr_ctl *ctl,
struct packet_command_pipe_t *cmdpipe)
{
/* Check the IP protocol version */
if (ctl->af == AF_INET6) {
if (check_feature(ctl, cmdpipe, "ip-6")) {
return -1;
}
} else if (ctl->af == AF_INET) {
if (check_feature(ctl, cmdpipe, "ip-4")) {
return -1;
}
} else {
errno = EINVAL;
return -1;
}
/* Check the transport protocol */
if (ctl->mtrtype == IPPROTO_ICMP) {
if (check_feature(ctl, cmdpipe, "icmp")) {
return -1;
}
} else if (ctl->mtrtype == IPPROTO_UDP) {
if (check_feature(ctl, cmdpipe, "udp")) {
return -1;
}
} else if (ctl->mtrtype == IPPROTO_TCP) {
if (check_feature(ctl, cmdpipe, "tcp")) {
return -1;
}
#ifdef HAS_SCTP
} else if (ctl->mtrtype == IPPROTO_SCTP) {
if (check_feature(ctl, cmdpipe, "sctp")) {
return -1;
}
#endif
} else {
errno = EINVAL;
return -1;
}
#ifdef SO_MARK
if (ctl->mark) {
if (check_feature(ctl, cmdpipe, "mark")) {
return -1;
}
}
#endif
return 0;
}
/*
Execute mtr-packet, allowing the MTR_PACKET evironment to override
the PATH when locating the executable.
*/
static
void execute_packet_child(
void)
{
/*
Allow the MTR_PACKET environment variable to override
the path to the mtr-packet executable. This is necessary
for debugging changes for mtr-packet.
*/
char *mtr_packet_path = getenv("MTR_PACKET");
if (mtr_packet_path == NULL) {
mtr_packet_path = "mtr-packet";
}
/*
First, try to execute mtr-packet from PATH
or MTR_PACKET environment variable.
*/
execlp(mtr_packet_path, "mtr-packet", (char *) NULL);
/*
If mtr-packet is not found, try to use mtr-packet from current directory
*/
execl("./mtr-packet", "./mtr-packet", (char *) NULL);
/* Both exec attempts failed, so nothing to do but exit */
exit(1);
}
/* Create the command pipe to a new mtr-packet subprocess */
int open_command_pipe(
struct mtr_ctl *ctl,
struct packet_command_pipe_t *cmdpipe)
{
int stdin_pipe[2];
int stdout_pipe[2];
pid_t child_pid;
int i;
/*
We actually need two Unix pipes. One for stdin and one for
stdout on the new process.
*/
if (pipe(stdin_pipe) || pipe(stdout_pipe)) {
return errno;
}
child_pid = fork();
if (child_pid == -1) {
return errno;
}
if (child_pid == 0) {
/*
In the child process, attach our created pipes to stdin
and stdout
*/
dup2(stdin_pipe[0], STDIN_FILENO);
dup2(stdout_pipe[1], STDOUT_FILENO);
/* Close all unnecessary fds */
for (i = STDERR_FILENO + 1; i <= stdout_pipe[1]; i++) {
close(i);
}
execute_packet_child();
} else {
memset(cmdpipe, 0, sizeof(struct packet_command_pipe_t));
/*
In the parent process, save the opposite ends of the pipes
attached as stdin and stdout in the child.
*/
cmdpipe->pid = child_pid;
cmdpipe->read_fd = stdout_pipe[0];
cmdpipe->write_fd = stdin_pipe[1];
/* We don't need the child ends of the pipe open in the parent. */
close(stdout_pipe[1]);
close(stdin_pipe[0]);
/*
Check that we can communicate with the client. If we failed to
execute the mtr-packet binary, we will discover that here.
*/
if (check_feature(ctl, cmdpipe, "send-probe")) {
error(EXIT_FAILURE, errno, "Failure to start mtr-packet");
}
if (check_packet_features(ctl, cmdpipe)) {
error(EXIT_FAILURE, errno, "Packet type unsupported");
}
/* We will need non-blocking reads from the child */
set_fd_nonblock(cmdpipe->read_fd);
}
return 0;
}
/* Kill the mtr-packet child process and close the command pipe */
void close_command_pipe(
struct packet_command_pipe_t *cmdpipe)
{
int child_exit_value;
if (cmdpipe->pid) {
close(cmdpipe->read_fd);
close(cmdpipe->write_fd);
kill(cmdpipe->pid, SIGTERM);
waitpid(cmdpipe->pid, &child_exit_value, 0);
}
memset(cmdpipe, 0, sizeof(struct packet_command_pipe_t));
}
/* Start building the command string for the "send-probe" command */
static
void construct_base_command(
struct mtr_ctl *ctl,
char *command,
int buffer_size,
int command_token,
ip_t * address,
ip_t * localaddress)
{
char ip_string[INET6_ADDRSTRLEN];
char local_ip_string[INET6_ADDRSTRLEN];
const char *ip_type;
const char *local_ip_type;
const char *protocol = NULL;
/* Conver the remote IP address to a string */
if (inet_ntop(ctl->af, address, ip_string, INET6_ADDRSTRLEN) == NULL) {
display_close(ctl);
error(EXIT_FAILURE, errno, "invalid remote IP address");
}
if (inet_ntop(ctl->af, localaddress,
local_ip_string, INET6_ADDRSTRLEN) == NULL) {
display_close(ctl);
error(EXIT_FAILURE, errno, "invalid local IP address");
}
if (ctl->af == AF_INET6) {
ip_type = "ip-6";
local_ip_type = "local-ip-6";
} else {
ip_type = "ip-4";
local_ip_type = "local-ip-4";
}
if (ctl->mtrtype == IPPROTO_ICMP) {
protocol = "icmp";
} else if (ctl->mtrtype == IPPROTO_UDP) {
protocol = "udp";
} else if (ctl->mtrtype == IPPROTO_TCP) {
protocol = "tcp";
#ifdef HAS_SCTP
} else if (ctl->mtrtype == IPPROTO_SCTP) {
protocol = "sctp";
#endif
} else {
display_close(ctl);
error(EXIT_FAILURE, 0,
"protocol unsupported by mtr-packet interface");
}
snprintf(command, buffer_size,
"%d send-probe %s %s %s %s protocol %s",
command_token,
ip_type, ip_string, local_ip_type, local_ip_string, protocol);
}
/* Append an argument to the "send-probe" command string */
static
void append_command_argument(
char *command,
int buffer_size,
char *name,
int value)
{
char argument[COMMAND_BUFFER_SIZE];
int remaining_size;
remaining_size = buffer_size - strlen(command) - 1;
snprintf(argument, buffer_size, " %s %d", name, value);
strncat(command, argument, remaining_size);
}
/* Request a new probe from the "mtr-packet" child process */
void send_probe_command(
struct mtr_ctl *ctl,
struct packet_command_pipe_t *cmdpipe,
ip_t * address,
ip_t * localaddress,
int packet_size,
int sequence,
int time_to_live)
{
char command[COMMAND_BUFFER_SIZE];
int remaining_size;
int timeout;
construct_base_command(ctl, command, COMMAND_BUFFER_SIZE, sequence,
address, localaddress);
append_command_argument(command, COMMAND_BUFFER_SIZE, "size",
packet_size);
append_command_argument(command, COMMAND_BUFFER_SIZE, "bit-pattern",
ctl->bitpattern);
append_command_argument(command, COMMAND_BUFFER_SIZE, "tos", ctl->tos);
append_command_argument(command, COMMAND_BUFFER_SIZE, "ttl",
time_to_live);
timeout = ctl->probe_timeout / 1000000;
append_command_argument(command, COMMAND_BUFFER_SIZE, "timeout",
timeout);
if (ctl->remoteport) {
append_command_argument(command, COMMAND_BUFFER_SIZE, "port",
ctl->remoteport);
}
if (ctl->localport) {
append_command_argument(command, COMMAND_BUFFER_SIZE, "local-port",
ctl->localport);
}
#ifdef SO_MARK
if (ctl->mark) {
append_command_argument(command, COMMAND_BUFFER_SIZE, "mark",
ctl->mark);
}
#endif
remaining_size = COMMAND_BUFFER_SIZE - strlen(command) - 1;
strncat(command, "\n", remaining_size);
/* Send a probe using the mtr-packet subprocess */
if (write(cmdpipe->write_fd, command, strlen(command)) == -1) {
display_close(ctl);
error(EXIT_FAILURE, errno,
"mtr-packet command pipe write failure");
}
}
/*
Parse a comma separated field of mpls values, filling out the mplslen
structure with mpls labels.
*/
static
void parse_mpls_values(
struct mplslen *mpls,
char *value_str)
{
char *next_value = value_str;
char *end_of_value;
int value;
int label_count = 0;
int label_field = 0;
while (*next_value) {
value = strtol(next_value, &end_of_value, 10);
/* Failure to advance means an invalid numeric value */
if (end_of_value == next_value) {
return;
}
/* If the next character is not a comma or a NUL, we have
an invalid string */
if (*end_of_value == ',') {
next_value = end_of_value + 1;
} else if (*end_of_value == 0) {
next_value = end_of_value;
} else {
return;
}
/*
Store the converted value in the next field of the MPLS
structure.
*/
if (label_field == 0) {
mpls->label[label_count] = value;
} else if (label_field == 1) {
mpls->exp[label_count] = value;
} else if (label_field == 2) {
mpls->s[label_count] = value;
} else if (label_field == 3) {
mpls->ttl[label_count] = value;
}
label_field++;
if (label_field > 3) {
label_field = 0;
label_count++;
}
/*
If we've used up all MPLS labels in the structure, return with
what we've got
*/
if (label_count >= MAXLABELS) {
break;
}
}
mpls->labels = label_count;
}
/*
Extract the IP address and round trip time from a reply to a probe.
Returns true if both arguments are found in the reply, false otherwise.
*/
static
bool parse_reply_arguments(
struct mtr_ctl *ctl,
struct command_t *reply,
ip_t * fromaddress,
int *round_trip_time,
struct mplslen *mpls)
{
bool found_round_trip;
bool found_ip;
char *arg_name;
char *arg_value;
int i;
*round_trip_time = 0;
memset(fromaddress, 0, sizeof(ip_t));
memset(mpls, 0, sizeof(struct mplslen));
found_ip = false;
found_round_trip = false;
/* Examine the reply arguments for known values */
for (i = 0; i < reply->argument_count; i++) {
arg_name = reply->argument_name[i];
arg_value = reply->argument_value[i];
if (ctl->af == AF_INET6) {
/* IPv6 address of the responding host */
if (!strcmp(arg_name, "ip-6")) {
if (inet_pton(AF_INET6, arg_value, fromaddress)) {
found_ip = true;
}
}
} else {
/* IPv4 address of the responding host */
if (!strcmp(arg_name, "ip-4")) {
if (inet_pton(AF_INET, arg_value, fromaddress)) {
found_ip = true;
}
}
}
/* The round trip time in microseconds */
if (!strcmp(arg_name, "round-trip-time")) {
errno = 0;
*round_trip_time = strtol(arg_value, NULL, 10);
if (!errno) {
found_round_trip = true;
}
}
/* MPLS labels */
if (!strcmp(arg_name, "mpls")) {
parse_mpls_values(mpls, arg_value);
}
}
return found_ip && found_round_trip;
}
/*
If an mtr-packet command has returned an error result,
report the error and exit.
*/
static
void handle_reply_errors(
struct mtr_ctl *ctl,
struct command_t *reply)
{
char *reply_name;
reply_name = reply->command_name;
if (!strcmp(reply_name, "no-route")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "No route to host");
}
if (!strcmp(reply_name, "network-down")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "Network down");
}
if (!strcmp(reply_name, "probes-exhausted")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "Probes exhausted");
}
if (!strcmp(reply_name, "invalid-argument")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "mtr-packet reported invalid argument");
}
if (!strcmp(reply_name, "permission-denied")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "Permission denied");
}
if (!strcmp(reply_name, "address-in-use")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "Address in use");
}
if (!strcmp(reply_name, "address-not-available")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "Address not available");
}
if (!strcmp(reply_name, "unexpected-error")) {
display_close(ctl);
error(EXIT_FAILURE, 0, "Unexpected mtr-packet error");
}
}
/*
A complete mtr-packet reply line has arrived. Parse it and record
the responding IP and round trip time, if it is a reply that we
understand.
*/
static
void handle_command_reply(
struct mtr_ctl *ctl,
char *reply_str,
probe_reply_func_t reply_func)
{
struct command_t reply;
ip_t fromaddress;
int seq_num;
int round_trip_time;
char *reply_name;
struct mplslen mpls;
/* Parse the reply string */
if (parse_command(&reply, reply_str)) {
/*
If the reply isn't well structured, something is fundamentally
wrong, as we might as well exit. Even if the reply is of an
unknown type, it should still parse.
*/
display_close(ctl);
error(EXIT_FAILURE, errno, "reply parse failure");
return;
}
handle_reply_errors(ctl, &reply);
seq_num = reply.token;
reply_name = reply.command_name;
/* If the reply type is unknown, ignore it for future compatibility */
if (strcmp(reply_name, "reply") && strcmp(reply_name, "ttl-expired")) {
return;
}
/*
If the reply had an IP address and a round trip time, we can
record the result.
*/
if (parse_reply_arguments
(ctl, &reply, &fromaddress, &round_trip_time, &mpls)) {
reply_func(ctl, seq_num, &mpls, (void *) &fromaddress,
round_trip_time);
}
}
/*
Check the command pipe for completed replies to commands
we have previously sent. Record the results of those replies.
*/
static
void consume_reply_buffer(
struct mtr_ctl *ctl,
struct packet_command_pipe_t *cmdpipe,
probe_reply_func_t reply_func)
{
char *reply_buffer;
char *reply_start;
char *end_of_reply;
int used_size;
int move_size;
reply_buffer = cmdpipe->reply_buffer;
/* Terminate the string storing the replies */
assert(cmdpipe->reply_buffer_used < PACKET_REPLY_BUFFER_SIZE);
reply_buffer[cmdpipe->reply_buffer_used] = 0;
reply_start = reply_buffer;
/*
We may have multiple completed replies. Loop until we don't
have any more newlines termininating replies.
*/
while (true) {
/* If no newline is found, our reply isn't yet complete */
end_of_reply = index(reply_start, '\n');
if (end_of_reply == NULL) {
/* No complete replies remaining */
break;
}
/*
Terminate the reply string at the newline, which
is necessary in the case where we are able to read
mulitple replies arriving simultaneously.
*/
*end_of_reply = 0;
/* Parse and record the reply results */
handle_command_reply(ctl, reply_start, reply_func);
reply_start = end_of_reply + 1;
}
/*
After replies have been processed, free the space used
by the replies, and move any remaining partial reply text
to the start of the reply buffer.
*/
used_size = reply_start - reply_buffer;
move_size = cmdpipe->reply_buffer_used - used_size;
memmove(reply_buffer, reply_start, move_size);
cmdpipe->reply_buffer_used -= used_size;
if (cmdpipe->reply_buffer_used >= PACKET_REPLY_BUFFER_SIZE - 1) {
/*
We've overflowed the reply buffer without a complete reply.
There's not much we can do about it but discard the data
we've got and hope new data coming in fits.
*/
cmdpipe->reply_buffer_used = 0;
}
}
/*
Read as much as we can from the reply pipe from the child process, and
process as many replies as are available.
*/
void handle_command_replies(
struct mtr_ctl *ctl,
struct packet_command_pipe_t *cmdpipe,
probe_reply_func_t reply_func)
{
int read_count;
int buffer_remaining;
char *reply_buffer;
char *read_buffer;
reply_buffer = cmdpipe->reply_buffer;
/*
Read the available reply text, up to the the remaining
buffer space. (Minus one for the terminating NUL.)
*/
read_buffer = &reply_buffer[cmdpipe->reply_buffer_used];
buffer_remaining =
PACKET_REPLY_BUFFER_SIZE - cmdpipe->reply_buffer_used;
read_count = read(cmdpipe->read_fd, read_buffer, buffer_remaining - 1);
if (read_count < 0) {
/*
EAGAIN simply indicates that there is no data currently
available on our non-blocking pipe.
*/
if (errno == EAGAIN) {
return;
}
display_close(ctl);
error(EXIT_FAILURE, errno, "command reply read failure");
return;
}
if (read_count == 0) {
display_close(ctl);
errno = EPIPE;
error(EXIT_FAILURE, EPIPE, "unexpected packet generator exit");
}
cmdpipe->reply_buffer_used += read_count;
/* Handle any replies completed by this read */
consume_reply_buffer(ctl, cmdpipe, reply_func);
}