tor_multipath_voip/src/algo_naive.c

149 lines
4.9 KiB
C
Raw Normal View History

2019-02-11 21:40:00 +00:00
#include "algo_skel.h"
#define NAIVE_BUFFER 128
2019-02-12 10:17:37 +00:00
struct naive_ctx {
struct ring_buffer rb;
};
void free_nothing(void* app_ctx) {}
2019-02-11 21:40:00 +00:00
void free_naive(void* app_ctx) {
if (app_ctx != NULL) free(app_ctx);
}
void on_tcp_co(struct evt_core_ctx* ctx, struct evt_core_cat* cat, int fd) {
2019-02-12 16:38:11 +00:00
int conn_sock1, conn_sock2;
struct sockaddr addr;
2019-02-11 21:40:00 +00:00
socklen_t in_len;
struct epoll_event current_event;
2019-02-12 16:38:11 +00:00
in_len = sizeof(addr);
2019-02-11 21:40:00 +00:00
2019-02-12 16:38:11 +00:00
conn_sock1 = accept(fd, &addr, &in_len);
if (conn_sock1 == -1) goto co_error;
conn_sock2 = dup(conn_sock1);
if (conn_sock2 == -1) goto co_error;
printf("fd=%d accepts, creating fds=%d,%d\n", fd, conn_sock1, conn_sock2);
evt_core_add_fd (ctx, "tcp-read", conn_sock1);
evt_core_add_fd (ctx, "tcp-write", conn_sock2);
2019-02-11 21:40:00 +00:00
return;
co_error:
perror("Failed to handle new connection");
exit(EXIT_FAILURE);
}
2019-02-12 10:17:37 +00:00
void tcp_to_udp(struct evt_core_ctx* ctx, struct evt_core_cat* cat, int fd) {
// Get target file descriptor
2019-02-12 16:38:11 +00:00
struct evt_core_cat* udp = g_hash_table_lookup (ctx->catlist, "udp-write");
2019-02-11 22:40:37 +00:00
if (udp == NULL || udp->socklist->len < 1) goto co_error;
int udp_fd = g_array_index(udp->socklist, int, 0);
2019-02-12 10:17:37 +00:00
// Init data structures for the transfer
struct naive_ctx* app_ctx = cat->app_ctx;
struct ring_buffer* rb = &(app_ctx->rb);
char buffer[RING_BUFFER_SIZE];
int nread, nwrite, rb_free_space;
while (1) {
rb_free_space = ring_buffer_free_space (rb); // We can't afford to read more
nread = read(fd, buffer, rb_free_space); // Effective read
if (nread == 0) return; // End of file
if (nread == -1 && errno == EAGAIN) return; // No more data to read
if (nread == -1) goto co_error; // A bad error
ring_buffer_write(rb, buffer, nread); // Persist read data in our buffer
nread = ring_buffer_read(rb, buffer, RING_BUFFER_SIZE);
nwrite = write(udp_fd, buffer, nread);
if (nwrite == -1 && errno == EAGAIN) return;
if (nwrite == -1) goto co_error;
ring_buffer_ack_read (rb, nwrite);
2019-02-11 21:40:00 +00:00
}
return;
co_error:
2019-02-11 22:40:37 +00:00
perror("Failed to handle read write for tcp-data");
2019-02-11 21:40:00 +00:00
exit(EXIT_FAILURE);
}
2019-02-12 10:17:37 +00:00
void udp_to_tcp(struct evt_core_ctx* ctx, struct evt_core_cat* cat, int fd) {
// Get target file descriptor
2019-02-12 16:38:11 +00:00
struct evt_core_cat* tcp = g_hash_table_lookup (ctx->catlist, "tcp-write");
2019-02-11 22:40:37 +00:00
if (tcp == NULL || tcp->socklist->len < 1) goto co_error;
int tcp_fd = g_array_index(tcp->socklist, int, 0);
2019-02-11 21:40:00 +00:00
2019-02-12 10:17:37 +00:00
// Init data structures for the transfer
struct naive_ctx* app_ctx = cat->app_ctx;
struct ring_buffer* rb = &(app_ctx->rb);
char buffer[RING_BUFFER_SIZE];
int nread, nwrite, rb_free_space;
while (1) {
rb_free_space = ring_buffer_free_space (rb); // We can't afford to read more
nread = read(fd, buffer, rb_free_space); // Effective read
if (nread == 0) return; // End of file
if (nread == -1 && errno == EAGAIN) return; // No more data to read
if (nread == -1) goto co_error; // A bad error
ring_buffer_write(rb, buffer, nread); // Persist read data in our buffer
nread = ring_buffer_read(rb, buffer, RING_BUFFER_SIZE);
nwrite = write(tcp_fd, buffer, nread);
if (nwrite == -1 && errno == EAGAIN) return;
if (nwrite == -1) goto co_error;
ring_buffer_ack_read (rb, nwrite);
2019-02-11 22:40:37 +00:00
}
return;
co_error:
perror("Failed to handle read write for udp-data");
exit(EXIT_FAILURE);
2019-02-11 21:40:00 +00:00
}
void algo_naive(struct algo_skel* as) {
as->on_tcp_co.name = "tcp-listen";
2019-02-12 10:17:37 +00:00
as->on_tcp_co.flags = EPOLLIN;
2019-02-11 21:40:00 +00:00
as->on_tcp_co.app_ctx = NULL;
as->on_tcp_co.free_app_ctx = free_naive;
as->on_tcp_co.cb = on_tcp_co;
as->on_tcp_co.socklist = NULL;
2019-02-12 10:17:37 +00:00
as->on_tcp_read.name = "tcp-read";
as->on_tcp_read.flags = EPOLLIN | EPOLLET;
as->on_tcp_read.app_ctx = malloc(sizeof(struct naive_ctx));
as->on_tcp_read.free_app_ctx = free_naive;
as->on_tcp_read.cb = tcp_to_udp;
as->on_tcp_read.socklist = NULL;
2019-02-12 16:47:14 +00:00
if (as->on_tcp_read.app_ctx == NULL) goto init_err;
memset(as->on_tcp_read.app_ctx, 0, sizeof(struct naive_ctx));
2019-02-12 10:17:37 +00:00
as->on_udp_read.name = "udp-read";
as->on_udp_read.flags = EPOLLIN | EPOLLET;
as->on_udp_read.app_ctx = malloc(sizeof(struct naive_ctx));
as->on_udp_read.free_app_ctx = free_naive;
as->on_udp_read.cb = tcp_to_udp;
as->on_udp_read.socklist = NULL;
2019-02-12 16:47:14 +00:00
if (as->on_udp_read.app_ctx == NULL) goto init_err;
memset(as->on_udp_read.app_ctx, 0, sizeof(struct naive_ctx));
2019-02-12 10:17:37 +00:00
as->on_tcp_write.name = "tcp-write";
as->on_tcp_write.flags = EPOLLOUT | EPOLLET;
as->on_tcp_write.app_ctx = as->on_udp_read.app_ctx;
as->on_tcp_write.free_app_ctx = free_nothing;
as->on_tcp_write.cb = udp_to_tcp;
as->on_tcp_write.socklist = NULL;
as->on_udp_write.name = "udp-write";
as->on_udp_write.flags = EPOLLOUT | EPOLLET;
as->on_udp_write.app_ctx = as->on_tcp_read.app_ctx;
as->on_udp_write.free_app_ctx = free_nothing;
as->on_udp_write.cb = tcp_to_udp;
as->on_udp_write.socklist = NULL;
2019-02-12 16:47:14 +00:00
return;
init_err:
fprintf(stderr, "Failed to init algo naive\n");
exit(EXIT_FAILURE);
2019-02-11 21:40:00 +00:00
}