137 lines
4.1 KiB
C
137 lines
4.1 KiB
C
#include <sys/timerfd.h>
|
|
#include "algo_utils.h"
|
|
#include "utils.h"
|
|
#include "url.h"
|
|
#include "proxy.h"
|
|
#include "timer.h"
|
|
|
|
struct thunder_ctx {
|
|
uint16_t recv_id;
|
|
uint16_t emit_id;
|
|
uint8_t selected_link;
|
|
uint8_t total_links;
|
|
uint8_t delta_t_per_link[64];
|
|
uint8_t blacklisted[64];
|
|
struct timespec prev_link_time;
|
|
};
|
|
|
|
void prepare(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo, struct buffer_packet* bp) {
|
|
struct algo_ctx* app_ctx = fdinfo->cat->app_ctx;
|
|
struct thunder_ctx* thunderc = app_ctx->misc;
|
|
|
|
thunderc->emit_id++;
|
|
union abstract_packet metadata = {
|
|
.fmt.headers.cmd = CMD_UDP_METADATA_THUNDER,
|
|
.fmt.headers.size = sizeof(metadata.fmt.headers) + sizeof(metadata.fmt.content.udp_metadata_thunder),
|
|
.fmt.headers.flags = 0,
|
|
.fmt.content.udp_metadata_thunder.id = thunderc->emit_id,
|
|
.fmt.content.udp_metadata_thunder.deltat = 0 //@FIXME delta t must be set
|
|
};
|
|
buffer_append_ap (bp, &metadata);
|
|
}
|
|
|
|
void pad(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo, struct buffer_packet* bp) {
|
|
|
|
|
|
}
|
|
|
|
int schedule(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo, struct buffer_packet* bp) {
|
|
struct algo_ctx* app_ctx = fdinfo->cat->app_ctx;
|
|
struct thunder_ctx* thunderc = app_ctx->misc;
|
|
struct evt_core_fdinfo *to_fdinfo = NULL;
|
|
struct evt_core_cat* cat = evt_core_get_from_cat (ctx, "tcp-write");
|
|
|
|
struct timespec curr;
|
|
int secs, nsecs;
|
|
uint64_t mili_sec;
|
|
|
|
|
|
do {
|
|
// 1. We choose the link
|
|
thunderc->selected_link = (thunderc->selected_link + 1) % cat->socklist->len;
|
|
|
|
// 2. We create the packet template
|
|
union abstract_packet links = {
|
|
.fmt.headers.cmd = CMD_LINK_MONITORING_THUNDER,
|
|
.fmt.headers.size = sizeof(links.fmt.headers) + sizeof(links.fmt.content.link_monitoring_thunder) + sizeof(struct link_info) * (thunderc->total_links - 1),
|
|
.fmt.headers.flags = 0,
|
|
.fmt.content.link_monitoring_thunder.links_status = {}
|
|
};
|
|
|
|
to_fdinfo = g_array_index(cat->socklist, struct evt_core_fdinfo*, thunderc->selected_link);
|
|
|
|
// 3. We append the template to the buffer
|
|
struct buffer_packet* bp_dup = dup_buffer_tow (&app_ctx->br, bp, to_fdinfo);
|
|
union abstract_packet *new_ap = buffer_append_ap (bp_dup, &links);
|
|
|
|
// 4. We compute the time difference
|
|
if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1){
|
|
perror("clock_gettime error");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
secs = curr.tv_sec - thunderc->prev_link_time.tv_sec;
|
|
nsecs = curr.tv_nsec - thunderc->prev_link_time.tv_nsec;
|
|
thunderc->prev_link_time = curr;
|
|
mili_sec = secs * 1000 + nsecs / 1000000;
|
|
if (mili_sec > 200) mili_sec = 200;
|
|
|
|
// 5. We create the array
|
|
struct link_info *li = &new_ap->fmt.content.link_monitoring_thunder.links_status;
|
|
for (int i = 0; i < thunderc->total_links; i++) {
|
|
thunderc->delta_t_per_link[i] += mili_sec;
|
|
li[i].delta_t = thunderc->delta_t_per_link[i];
|
|
}
|
|
li[thunderc->selected_link].delta_t = 0;
|
|
|
|
main_on_tcp_write(ctx, to_fdinfo);
|
|
} while (thunderc->blacklisted[thunderc->selected_link]);
|
|
|
|
if (ctx->verbose > 1) fprintf(stderr, " [algo_thunder] Packets sent\n");
|
|
|
|
// Release the buffer
|
|
mv_buffer_rtof (&app_ctx->br, fdinfo);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void algo_thunder_init(struct evt_core_ctx* ctx, struct algo_ctx* app_ctx, struct algo_params* ap) {
|
|
app_ctx->misc = malloc(sizeof(struct thunder_ctx));
|
|
if (app_ctx->misc == NULL) {
|
|
perror("malloc failed in algo thunder init");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
memset(app_ctx->misc, 0, sizeof(struct thunder_ctx));
|
|
struct thunder_ctx* thunderc = app_ctx->misc;
|
|
thunderc->selected_link = UINT8_MAX - 1;
|
|
}
|
|
|
|
void classify() {
|
|
|
|
}
|
|
|
|
void unpad() {
|
|
|
|
}
|
|
|
|
void adapt() {
|
|
|
|
}
|
|
|
|
int algo_thunder_on_stream(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo, struct buffer_packet* bp) {
|
|
classify();
|
|
unpad();
|
|
adapt();
|
|
return 0;
|
|
}
|
|
|
|
int algo_thunder_on_datagram(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo, struct buffer_packet* bp) {
|
|
prepare(ctx, fdinfo, bp);
|
|
pad(ctx, fdinfo, bp);
|
|
return schedule(ctx, fdinfo, bp);
|
|
}
|
|
|
|
int algo_thunder_on_err(struct evt_core_ctx *ctx, struct evt_core_fdinfo *fdinfo) {
|
|
if (strstr(fdinfo->cat->name, "udp") != NULL) return 1;
|
|
return 0;
|
|
}
|