bool probe_write_payload_ext(probe_t * probe, const void * bytes, size_t num_bytes, size_t offset)
{
layer_t * payload_layer;
if (!(payload_layer = probe_get_layer_payload(probe))) {
goto ERR_PROBE_GET_LAYER_PAYLOAD;
}
if (num_bytes > probe_get_payload_size(probe)) {
if(!probe_payload_resize(probe, num_bytes)) {
goto ERR_PROBE_PAYLOAD_RESIZE;
}
}
if (!layer_write_payload_ext(payload_layer, bytes, num_bytes, offset)) {
goto ERR_LAYER_WRITE_PAYLOAD_EXT;
}
return true;
ERR_LAYER_WRITE_PAYLOAD_EXT:
ERR_PROBE_PAYLOAD_RESIZE:
ERR_PROBE_GET_LAYER_PAYLOAD:
return false;
}
static bool probe_push_payload(probe_t * probe, size_t payload_size) {
layer_t * payload_layer,
* first_layer;
uint8_t * payload_bytes;
size_t packet_size;
// Check whether a payload is already set
if ((payload_layer = probe_get_layer_payload(probe))) {
fprintf(stderr, "Payload already set\n");
goto ERR_PAYLOAD_ALREADY_SET;
}
// Get the first protocol layer
if (!(first_layer = probe_get_layer(probe, 0))) {
fprintf(stderr, "No protocol layer defined in this probe\n");
goto ERR_NO_FIRST_LAYER;
}
// The first segment stores the packet size, thus:
// @payload = @first_segment + packet_size - payload_size
packet_size = probe_get_size(probe) ;
payload_bytes = packet_get_bytes(probe->packet) + packet_size - payload_size;
if (!(payload_layer = layer_create_from_segment(NULL, payload_bytes, payload_size))) {
goto ERR_LAYER_CREATE;
}
// Add the payload layer in the probe
if (!(probe_push_layer(probe, payload_layer))) {
fprintf(stderr, "Can't push payload layer\n");
goto ERR_PUSH_LAYER;
}
// Resize the payload if required
if (payload_size > 0) {
if (!probe_payload_resize(probe, payload_size)) {
fprintf(stderr, "Can't resize payload\n");
goto ERR_PAYLOAD_RESIZE;
}
}
return true;
ERR_PAYLOAD_RESIZE:
dynarray_del_ith_element(probe->layers, probe_get_num_layers(probe) - 1, NULL);
ERR_PUSH_LAYER:
layer_free(payload_layer);
ERR_LAYER_CREATE:
ERR_NO_FIRST_LAYER:
ERR_PAYLOAD_ALREADY_SET:
return false;
}
int main(int argc, char ** argv)
{
int exit_code = EXIT_FAILURE;
char * version = strdup("version 1.0");
const char * usage = "usage: %s [options] host\n";
void * algorithm_options;
traceroute_options_t traceroute_options;
traceroute_options_t * ptraceroute_options;
mda_options_t mda_options;
probe_t * probe;
pt_loop_t * loop;
int family;
address_t dst_addr;
options_t * options;
char * dst_ip;
const char * algorithm_name;
const char * protocol_name;
bool use_icmp, use_udp, use_tcp;
// Prepare the commande line options
if (!(options = init_options(version))) {
fprintf(stderr, "E: Can't initialize options\n");
goto ERR_INIT_OPTIONS;
}
// Retrieve values passed in the command-line
if (options_parse(options, usage, argv) != 1) {
fprintf(stderr, "%s: destination required\n", basename(argv[0]));
goto ERR_OPT_PARSE;
}
// We assume that the target IP address is always the last argument
dst_ip = argv[argc - 1];
algorithm_name = algorithm_names[0];
protocol_name = protocol_names[0];
// Checking if there is any conflicts between options passed in the commandline
if (!check_options(is_icmp, is_tcp, is_udp, is_ipv4, is_ipv6, dst_port[3], src_port[3], protocol_name, algorithm_name)) {
goto ERR_CHECK_OPTIONS;
}
use_icmp = is_icmp || strcmp(protocol_name, "icmp") == 0;
use_tcp = is_tcp || strcmp(protocol_name, "tcp") == 0;
use_udp = is_udp || strcmp(protocol_name, "udp") == 0;
// If not any ip version is set, call address_guess_family.
// If only one is set to true, set family to AF_INET or AF_INET6
if (is_ipv4) {
family = AF_INET;
} else if (is_ipv6) {
family = AF_INET6;
} else {
// Get address family if not defined by the user
if (!address_guess_family(dst_ip, &family)) goto ERR_ADDRESS_GUESS_FAMILY;
}
// Translate the string IP / FQDN into an address_t * instance
if (address_from_string(family, dst_ip, &dst_addr) != 0) {
fprintf(stderr, "E: Invalid destination address %s\n", dst_ip);
goto ERR_ADDRESS_IP_FROM_STRING;
}
// Probe skeleton definition: IPv4/UDP probe targetting 'dst_ip'
if (!(probe = probe_create())) {
fprintf(stderr,"E: Cannot create probe skeleton");
goto ERR_PROBE_CREATE;
}
// Prepare the probe skeleton
probe_set_protocols(
probe,
get_ip_protocol_name(family), // "ipv4" | "ipv6"
get_protocol_name(family, use_icmp, use_tcp, use_udp), // "icmpv4" | "icmpv6" | "tcp" | "udp"
NULL
);
probe_set_field(probe, ADDRESS("dst_ip", &dst_addr));
if (send_time[3]) {
if(send_time[0] <= 10) { // seconds
probe_set_delay(probe, DOUBLE("delay", send_time[0]));
} else { // milli-seconds
probe_set_delay(probe, DOUBLE("delay", 0.001 * send_time[0]));
}
}
// ICMPv* do not support src_port and dst_port fields nor payload.
if (!use_icmp) {
uint16_t sport = 0,
dport = 0;
if (use_udp) {
// Option -U sets port to 53 (DNS) if dst_port is not explicitely set
sport = src_port[3] ? src_port[0] : UDP_DEFAULT_SRC_PORT;
dport = dst_port[3] ? dst_port[0] : (is_udp ? UDP_DST_PORT_USING_U : UDP_DEFAULT_DST_PORT);
} else if (use_tcp) {
// Option -T sets port to 80 (http) if dst_port is not explicitely set
sport = src_port[3] ? src_port[0] : TCP_DEFAULT_SRC_PORT;
dport = dst_port[3] ? dst_port[0] : (is_tcp ? TCP_DST_PORT_USING_T : TCP_DEFAULT_DST_PORT);
}
// Update ports
probe_set_fields(
probe,
I16("src_port", sport),
I16("dst_port", dport),
NULL
);
// Resize payload (it will be use to set our customized checksum in the {TCP, UDP} layer)
probe_payload_resize(probe, 2);
}
// Algorithm options (dedicated options)
if (strcmp(algorithm_name, "paris-traceroute") == 0) {
traceroute_options = traceroute_get_default_options();
ptraceroute_options = &traceroute_options;
algorithm_options = &traceroute_options;
algorithm_name = "traceroute";
} else if ((strcmp(algorithm_name, "mda") == 0) || options_mda_get_is_set()) {
mda_options = mda_get_default_options();
ptraceroute_options = &mda_options.traceroute_options;
algorithm_options = &mda_options;
options_mda_init(&mda_options);
} else {
fprintf(stderr, "E: Unknown algorithm");
goto ERR_UNKNOWN_ALGORITHM;
}
// Algorithm options (common options)
options_traceroute_init(ptraceroute_options, &dst_addr);
// Create libparistraceroute loop
if (!(loop = pt_loop_create(loop_handler, NULL))) {
fprintf(stderr, "E: Cannot create libparistraceroute loop");
goto ERR_LOOP_CREATE;
}
// Set network options (network and verbose)
options_network_init(loop->network, is_debug);
printf("%s to %s (", algorithm_name, dst_ip);
address_dump(&dst_addr);
printf("), %u hops max, %u bytes packets\n",
ptraceroute_options->max_ttl,
(unsigned int)packet_get_size(probe->packet)
);
// Add an algorithm instance in the main loop
if (!pt_add_instance(loop, algorithm_name, algorithm_options, probe)) {
fprintf(stderr, "E: Cannot add the chosen algorithm");
goto ERR_INSTANCE;
}
// Wait for events. They will be catched by handler_user()
if (pt_loop(loop, 0) < 0) {
fprintf(stderr, "E: Main loop interrupted");
goto ERR_PT_LOOP;
}
exit_code = EXIT_SUCCESS;
// Leave the program
ERR_PT_LOOP:
ERR_INSTANCE:
// pt_loop_free() automatically removes algorithms instances,
// probe_replies and events from the memory.
// Options and probe must be manually removed.
pt_loop_free(loop);
ERR_LOOP_CREATE:
ERR_UNKNOWN_ALGORITHM:
probe_free(probe);
ERR_PROBE_CREATE:
ERR_ADDRESS_IP_FROM_STRING:
ERR_ADDRESS_GUESS_FAMILY:
if (errno) perror(gai_strerror(errno));
ERR_CHECK_OPTIONS:
ERR_OPT_PARSE:
ERR_INIT_OPTIONS:
free(version);
exit(exit_code);
}
