tor_multipath_voip/src/meas_lat.c

334 lines
9.1 KiB
C
Raw Normal View History

#include <stdlib.h>
#include <stdio.h>
2019-02-20 15:50:44 +00:00
#include <sys/timerfd.h>
#include <time.h>
#include <unistd.h>
2019-02-20 16:46:58 +00:00
#include <errno.h>
#include "evt_core.h"
2019-02-14 17:08:20 +00:00
#include "net_tools.h"
2019-03-11 14:17:15 +00:00
#include "socks5.h"
2019-03-25 16:20:47 +00:00
struct measlat_ctx {
2019-04-01 12:16:41 +00:00
int count, size, interval, verbose;
2019-03-25 16:20:47 +00:00
char *host, *port, *transport;
};
2019-02-20 15:50:44 +00:00
struct measure_conf {
uint64_t max_measure;
uint64_t payload_size;
char* payload;
2019-02-14 17:08:20 +00:00
uint64_t counter;
};
2019-02-20 15:50:44 +00:00
struct packet_header {
uint64_t counter;
struct timespec emit_time;
};
2019-03-05 15:13:08 +00:00
struct measure_conf* create_measure_conf(int max_mes, int plsize) {
2019-02-20 15:50:44 +00:00
struct measure_conf* mc = malloc(sizeof(struct measure_conf));
if (mc == NULL) {
perror("Malloc failed");
exit(EXIT_FAILURE);
}
mc->counter = 0;
2019-02-22 14:22:06 +00:00
mc->max_measure = max_mes;
mc->payload_size = plsize;
2019-02-20 15:50:44 +00:00
mc->payload = malloc(mc->payload_size);
if (mc->payload == NULL) {
perror("malloc failed");
exit(EXIT_FAILURE);
}
return mc;
}
2019-03-05 15:13:08 +00:00
void free_mesure_conf(void* v) {
struct measure_conf* mc = (struct measure_conf*)v;
free(mc->payload);
free(mc);
}
2019-03-05 15:21:25 +00:00
int on_udp_err(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
return 1;
}
2019-02-20 16:46:58 +00:00
int on_udp(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
2019-02-20 15:50:44 +00:00
ssize_t res;
int secs, nsecs;
uint64_t micro_sec;
struct timespec curr;
struct measure_conf* mc = fdinfo->other;
res = read(fdinfo->fd, mc->payload, mc->payload_size);
2019-02-20 16:46:58 +00:00
if (res == -1 && errno == EAGAIN) return 1;
2019-02-20 15:50:44 +00:00
if (res != mc->payload_size) {
perror("read error");
exit(EXIT_FAILURE);
}
struct packet_header* head = (struct packet_header*) mc->payload;
if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1){
perror("clock_gettime error");
exit(EXIT_FAILURE);
}
secs = curr.tv_sec - head->emit_time.tv_sec;
nsecs = curr.tv_nsec - head->emit_time.tv_nsec;
micro_sec = secs * 1000000 + nsecs / 1000;
printf("Packet %llu latency %luµs\n", (unsigned long long)head->counter, micro_sec);
if (head->counter >= mc->max_measure) {
printf("Measurement done\n");
exit(EXIT_SUCCESS);
}
2019-02-20 16:46:58 +00:00
return 0;
2019-02-14 17:08:20 +00:00
}
2019-03-25 16:20:47 +00:00
void free_timer_conf(void* v) {
struct measure_conf* mc = v;
free(mc->payload);
free(mc);
}
2019-02-20 16:46:58 +00:00
int on_timer(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
2019-02-20 15:50:44 +00:00
ssize_t s;
uint64_t ticks;
struct measure_conf* mc = fdinfo->other;
s = read(fdinfo->fd, &ticks, sizeof(uint64_t));
2019-03-27 16:31:46 +00:00
if (s == -1 && errno == EAGAIN) return 1;
2019-02-20 15:50:44 +00:00
if (s != sizeof(uint64_t)) {
perror("Read error");
exit(EXIT_FAILURE);
}
if (ticks != 1) {
fprintf(stderr, "Has ticked %lu times, expected 1 time. This is a bug\n", ticks);
}
2019-02-22 14:22:06 +00:00
mc->counter++;
2019-02-20 15:50:44 +00:00
memset(mc->payload, 0, mc->payload_size);
struct packet_header* head = (struct packet_header*)mc->payload;
head->counter = mc->counter;
if (clock_gettime(CLOCK_MONOTONIC, &head->emit_time) == -1) {
perror("clock_gettime error");
exit(EXIT_FAILURE);
}
2019-03-11 14:17:15 +00:00
struct evt_core_fdinfo* tgtinfo = evt_core_get_first_from_cat (ctx, "udp-read");
if (tgtinfo == NULL) tgtinfo = evt_core_get_first_from_cat (ctx, "tcp-read");
if (tgtinfo == NULL) {
2019-03-05 15:13:08 +00:00
printf("No connection yet\n");
return 1;
}
2019-03-11 14:17:15 +00:00
s = send(tgtinfo->fd, mc->payload, mc->payload_size, 0);
2019-02-20 15:50:44 +00:00
if (s < 0) {
perror("Send error");
2019-03-05 15:13:08 +00:00
//exit(EXIT_FAILURE);
2019-02-20 15:50:44 +00:00
}
2019-03-25 16:38:05 +00:00
return 0;
2019-02-20 15:50:44 +00:00
}
2019-02-22 14:22:06 +00:00
void register_timer(struct evt_core_ctx* evts, int udp, int interval, int count, int size) {
2019-02-20 15:50:44 +00:00
struct timespec now;
struct itimerspec timer_config;
2019-02-22 14:22:06 +00:00
char url[1024];
struct evt_core_cat cat = {0};
struct evt_core_fdinfo fdinfo = {0};
fdinfo.cat = &cat;
fdinfo.url = url;
2019-02-20 15:50:44 +00:00
if (clock_gettime(CLOCK_REALTIME, &now) == -1) {
perror("clock_gettime");
2019-02-22 14:22:06 +00:00
exit(EXIT_FAILURE);
2019-02-20 15:50:44 +00:00
}
2019-02-22 14:22:06 +00:00
uint64_t micro_sec = interval;
2019-02-20 15:50:44 +00:00
timer_config.it_value.tv_sec = now.tv_sec + 1;
timer_config.it_value.tv_nsec = now.tv_nsec;
timer_config.it_interval.tv_sec = micro_sec / 1000;
timer_config.it_interval.tv_nsec = micro_sec % 1000 * 1000000;
fdinfo.fd = timerfd_create(CLOCK_REALTIME, 0);
if (fdinfo.fd == -1) {
perror("Unable to timerfd_create");
2019-02-22 14:22:06 +00:00
exit(EXIT_FAILURE);
2019-02-20 15:50:44 +00:00
}
if (timerfd_settime (fdinfo.fd, TFD_TIMER_ABSTIME, &timer_config, NULL) == -1) {
perror("Unable to timerfd_time");
2019-02-22 14:22:06 +00:00
exit(EXIT_FAILURE);
2019-02-20 15:50:44 +00:00
}
fdinfo.cat->name = "timer";
2019-03-05 15:13:08 +00:00
fdinfo.other = create_measure_conf(count, size);
2019-02-20 15:50:44 +00:00
fdinfo.free_other = free_timer_conf;
2019-02-22 14:22:06 +00:00
sprintf(fdinfo.url, "timer:%d:%d", interval, count);
evt_core_add_fd (evts, &fdinfo);
2019-02-20 15:50:44 +00:00
printf("--- Timer registered\n");
2019-02-22 14:22:06 +00:00
}
2019-03-25 16:20:47 +00:00
int on_socks5_success_measlat(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
char url[1024];
struct evt_core_cat cat = {0};
struct evt_core_fdinfo fdinfo_n = {0};
struct socks5_ctx* s5ctx = fdinfo->other;
fdinfo_n.cat = &cat;
fdinfo_n.url = url;
struct evt_core_cat* ucat = evt_core_get_from_cat (ctx, "tcp-read");
if (ucat == NULL) {
fprintf(stderr, "Category udp-read not found\n");
exit(EXIT_FAILURE);
}
struct measlat_ctx* mctx = ucat->app_ctx;
fdinfo_n.fd = dup(fdinfo->fd);
fdinfo_n.cat->name = "tcp-read";
fdinfo_n.other = create_measure_conf (mctx->count, mctx->size);
fdinfo_n.free_other = free_mesure_conf;
sprintf(fdinfo_n.url, "tcp:read:%s:%d", s5ctx->addr, s5ctx->port);
evt_core_add_fd (ctx, &fdinfo_n);
printf("--- Tor socket registered\n");
register_timer(ctx, fdinfo->fd, mctx->interval, mctx->count, mctx->size);
return 1;
}
void spawn_tor_socket(struct evt_core_ctx* evts) {
struct evt_core_cat* ucat = evt_core_get_from_cat (evts, "tcp-read");
if (ucat == NULL) {
fprintf(stderr, "Category udp-read not found\n");
exit(EXIT_FAILURE);
}
struct measlat_ctx* mctx = ucat->app_ctx;
socks5_create_dns_client (evts, "127.0.0.1", "9050", mctx->host, atoi(mctx->port));
}
int on_socks5_failed_measlat(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
evt_core_rm_fd (ctx, fdinfo->fd);
spawn_tor_socket(ctx);
return 1;
}
void register_categories(struct evt_core_ctx* evts, struct measlat_ctx* mctx) {
struct evt_core_cat template = {0};
template.app_ctx = mctx;
2019-04-01 12:16:41 +00:00
evt_core_init(evts, mctx->verbose);
2019-03-25 16:20:47 +00:00
template.cb = on_timer;
template.name = "timer";
template.flags = EPOLLIN | EPOLLET;
evt_core_add_cat(evts, &template);
template.cb = on_udp; // intended but not elegant
template.err_cb = on_udp_err; // intended but not elegant
template.name = "tcp-read";
template.flags = EPOLLIN | EPOLLET;
evt_core_add_cat(evts, &template);
template.cb = on_udp;
template.err_cb = on_udp_err;
template.name = "udp-read";
template.flags = EPOLLIN | EPOLLET;
evt_core_add_cat(evts, &template);
template.cb = on_socks5_success_measlat;
template.err_cb = on_socks5_failed_measlat;
template.name = "socks5-success";
template.flags = EPOLLET;
template.cb = on_socks5_failed_measlat;
template.err_cb = on_socks5_failed_measlat;
template.name = "socks5-failed";
template.flags = EPOLLET;
socks5_init(evts);
printf("--- Categories registered\n");
}
void spawn_udp_socket(struct evt_core_ctx* evts) {
struct evt_core_cat* ucat = evt_core_get_from_cat (evts, "udp-read");
if (ucat == NULL) {
fprintf(stderr, "Category udp-read not found\n");
exit(EXIT_FAILURE);
}
struct measlat_ctx* mctx = ucat->app_ctx;
int udp_sock = create_udp_client (mctx->host, mctx->port);
char url[1024];
struct evt_core_cat cat = {0};
struct evt_core_fdinfo fdinfo = {0};
fdinfo.cat = &cat;
fdinfo.url = url;
fdinfo.fd = udp_sock;
fdinfo.cat->name = "udp-read";
fdinfo.other = create_measure_conf (mctx->count, mctx->size);
fdinfo.free_other = free_mesure_conf;
sprintf(fdinfo.url, "udp:read:%s:%s", mctx->host, mctx->port);
evt_core_add_fd (evts, &fdinfo);
printf("--- UDP socket registered\n");
register_timer(evts, fdinfo.fd, mctx->interval, mctx->count, mctx->size);
}
2019-02-22 14:22:06 +00:00
int main(int argc, char** argv) {
2019-03-06 16:12:58 +00:00
setvbuf(stdout, NULL, _IONBF, 0);
2019-02-22 14:22:06 +00:00
printf("~ measlat ~\n");
2019-03-25 16:20:47 +00:00
int opt;
struct measlat_ctx mctx = {0};
2019-02-22 14:22:06 +00:00
struct evt_core_ctx evts = {0};
// 1. Parse parameters
2019-04-01 12:16:41 +00:00
while ((opt = getopt(argc, argv, "vh:p:c:s:i:t:")) != -1) {
2019-02-22 14:22:06 +00:00
switch(opt) {
2019-04-01 12:16:41 +00:00
case 'v':
mctx.verbose++;
break;
2019-03-11 14:17:15 +00:00
case 'h': // host
2019-03-25 16:20:47 +00:00
mctx.host = optarg;
2019-02-22 14:22:06 +00:00
break;
2019-03-11 14:17:15 +00:00
case 'p': // port
2019-03-25 16:20:47 +00:00
mctx.port = optarg;
2019-02-22 14:22:06 +00:00
break;
2019-03-11 14:17:15 +00:00
case 't': // transport
2019-03-25 16:20:47 +00:00
mctx.transport = optarg;
2019-03-11 14:17:15 +00:00
break;
case 'c': // count
2019-03-25 16:20:47 +00:00
mctx.count = atoi(optarg);
2019-02-22 14:22:06 +00:00
break;
2019-03-11 14:17:15 +00:00
case 's': // size - payload in bytes
2019-03-25 16:20:47 +00:00
mctx.size = atoi(optarg);
2019-02-22 14:22:06 +00:00
break;
2019-03-11 14:17:15 +00:00
case 'i': // interval - every ms
2019-03-25 16:20:47 +00:00
mctx.interval = atoi(optarg);
2019-02-22 14:22:06 +00:00
break;
default:
goto usage;
}
}
// 2. Check and fix parameters
size_t header_size = sizeof(struct packet_header);
2019-03-25 16:20:47 +00:00
if (mctx.interval <= 0) mctx.interval = 1000;
if (mctx.count <= 0) mctx.count = 1;
if (mctx.size < header_size) mctx.size = header_size;
if (mctx.transport == NULL) mctx.transport = "udp";
if (mctx.host == NULL || mctx.port == NULL) goto usage;
2019-02-22 14:22:06 +00:00
// 3. Bind events
2019-03-25 16:20:47 +00:00
register_categories(&evts, &mctx);
if (strcmp(mctx.transport, "udp") == 0) spawn_udp_socket(&evts);
else if (strcmp(mctx.transport, "tor") == 0) spawn_tor_socket(&evts);
2019-02-20 15:50:44 +00:00
2019-02-22 14:22:06 +00:00
// 4. Run main loop
2019-02-20 15:50:44 +00:00
evt_core_loop(&evts);
return 0;
2019-02-22 14:22:06 +00:00
usage:
2019-03-11 14:17:15 +00:00
fprintf(stderr, "Usage: %s -h <host> -p <port> [-t <udp|tor>] [-c <count>] [-i <ms>] [-s <bytes>]\n", argv[0]);
2019-02-22 14:22:06 +00:00
exit(EXIT_FAILURE);
}