tor_multipath_voip/src/faketor.c

#include <stdio.h>
#include <stdlib.h>
#include "evt_core.h"
#include "socks5.h"
#include "tor_ctl.h"
#include "timer.h"

int faketor_socks5_listen(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
  int conn_sock1;
  struct sockaddr_in addr;
  socklen_t in_len;

  in_len = sizeof(addr);
  conn_sock1 = accept(fdinfo->fd, (struct sockaddr*)&addr, &in_len);

  if (conn_sock1 == -1 && errno == EAGAIN) return EVT_CORE_FD_EXHAUSTED;
  if (conn_sock1 == -1) goto co_error;

  make_socket_non_blocking (conn_sock1);
  printf("[%s][torfake] Accepted a new connection for socks5 \n", current_human_datetime ());
  socks5_server_handle_req (ctx, conn_sock1);

  return EVT_CORE_FD_UNFINISHED;
co_error:
  perror("Failed to handle new socks5 connection");
  exit(EXIT_FAILURE);
}

int faketor_control_listen(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
  int conn_sock;
  struct sockaddr_in addr;
  socklen_t in_len;

  in_len = sizeof(addr);
  conn_sock = accept(fdinfo->fd, (struct sockaddr*)&addr, &in_len);

  if (conn_sock == -1 && errno == EAGAIN) return EVT_CORE_FD_EXHAUSTED;
  if (conn_sock == -1) goto co_error;

  make_socket_non_blocking (conn_sock);
  printf("[%s][torfake] Accepted a new connection for control port \n", current_human_datetime ());
  tor_ctl_server_handle(ctx, conn_sock);

  return EVT_CORE_FD_UNFINISHED;

co_error:
  perror("Failed to handle new control port connection");
  exit(EXIT_FAILURE);
}

int faketor_socks5_server_success(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
  printf("success socks5!\n");
  // ctos-read and stoc-write
  char buffer[512];
  sprintf(buffer, "%s:write", fdinfo->url);
  struct evt_core_fdinfo *fdinfo2 = evt_core_dup(ctx, fdinfo, buffer);
  evt_core_mv_fd2(ctx, fdinfo, "ctos-read");
  evt_core_mv_fd2(ctx, fdinfo2, "stoc-write");

  return EVT_CORE_FD_EXHAUSTED;
}

int faketor_torctl_server_success(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
  printf("success torctl!\n");
  // ctos-write and stoc-read
  char buffer[512];
  sprintf(buffer, "%s:write", fdinfo->url);
  struct evt_core_fdinfo *fdinfo2 = evt_core_dup(ctx, fdinfo, buffer);
  evt_core_mv_fd2(ctx, fdinfo, "stoc-read");
  evt_core_mv_fd2(ctx, fdinfo2, "ctos-write");
  return EVT_CORE_FD_EXHAUSTED;
}

int faketor_socks5_server_failed(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
  printf("failure socks5!\n");
  evt_core_rm_fd(ctx, fdinfo->fd);

  return EVT_CORE_FD_EXHAUSTED;
}

int faketor_ctos(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
  char buffer[1600];
  ssize_t nread, nwrite;
  size_t skip_socket = strlen("socket:"), skip_torctl = strlen("torctl:");
  char url[512];
  struct evt_core_fdinfo *target, *source;

  // 0. find source
  if (strstr(fdinfo->url, "socket:") != NULL) target = fdinfo;
  else {
    sprintf(url, "socket:%s", fdinfo->url);
  }

  // 1. read some data
  nread = recv(fdinfo->fd, buffer, sizeof(buffer), MSG_PEEK);
  if (nread == -1 && errno == EAGAIN) return EVT_CORE_FD_EXHAUSTED;
  if (nread == -1) goto error;

  // 2. find target
  sprintf(url, "torctl:%s:write", fdinfo->url + skip_socket);
  printf("source url: %s, target url: %s", fdinfo->url, url);
  target = evt_core_get_from_url (ctx, url);

  // 3. write to target
  nwrite = send(target->fd, buffer, nread, 0);
  if (nwrite == -1 && errno == EAGAIN) return EVT_CORE_FD_EXHAUSTED;
  if (nwrite == -1) goto error;
  nread = recv(fdinfo->fd, buffer, nwrite, 0);
  if (nread == -1) goto error;

  return EVT_CORE_FD_UNFINISHED;
error:
  perror("oopsie ctos");
  exit(EXIT_FAILURE);
}

int faketor_stoc(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {

  return EVT_CORE_FD_UNFINISHED;
}

int main(void) {
  struct evt_core_ctx evts = {0};

  struct evt_core_cat socks5_listen = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_socks5_listen,
    .err_cb = NULL,
    .name = "socks5-listen",
    .flags = EPOLLIN | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat control_listen = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_control_listen,
    .err_cb = NULL,
    .name = "control-listen",
    .flags = EPOLLIN | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat socks5_server_success = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_socks5_server_success,
    .err_cb = NULL,
    .name = "socks5-server-success",
    .flags = EPOLLIN | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat socks5_server_failed = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_socks5_server_failed,
    .err_cb = NULL,
    .name = "socks5-server-failed",
    .flags = EPOLLIN | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat torctl_server_success = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_torctl_server_success,
    .err_cb = NULL,
    .name = "torctl-server-success",
    .flags = EPOLLIN | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat ctos_read = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_ctos,
    .err_cb = NULL,
    .name = "ctos-read",
    .flags = EPOLLIN | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat ctos_write = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_ctos,
    .err_cb = NULL,
    .name = "ctos-write",
    .flags = EPOLLOUT | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat stoc_read = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_stoc,
    .err_cb = NULL,
    .name = "stoc-read",
    .flags = EPOLLIN | EPOLLET,
    .socklist = NULL
  };

  struct evt_core_cat stoc_write = {
    .app_ctx = NULL,
    .free_app_ctx = NULL,
    .cb = faketor_stoc,
    .err_cb = NULL,
    .name = "stoc-write",
    .flags = EPOLLOUT | EPOLLET,
    .socklist = NULL
  };

  evt_core_init(&evts, 0);
  evt_core_add_cat(&evts, &socks5_listen);
  evt_core_add_cat(&evts, &control_listen);
  evt_core_add_cat(&evts, &socks5_server_success);
  evt_core_add_cat(&evts, &socks5_server_failed);
  evt_core_add_cat(&evts, &torctl_server_success);
  evt_core_add_cat(&evts, &ctos_read);
  evt_core_add_cat(&evts, &ctos_write);
  evt_core_add_cat(&evts, &stoc_read);
  evt_core_add_cat(&evts, &stoc_write);

  struct evt_core_cat cat = {0};
  struct evt_core_fdinfo fdinfo = {0};
  fdinfo.cat = &cat;
  int err, sock = 0;

  sock = create_tcp_server ("0.0.0.0", "9050");
  if (sock < 0) return EXIT_FAILURE;
  err = listen(sock, SOMAXCONN);
  if (err != 0) return EXIT_FAILURE;
  fdinfo.cat->name = "socks5-listen";
  fdinfo.fd = sock;
  fdinfo.url = "socks5:listen:9050";
  evt_core_add_fd(&evts, &fdinfo);

  sock = create_tcp_server ("0.0.0.0", "9051");
  if (sock < 0) return EXIT_FAILURE;
  err = listen(sock, SOMAXCONN);
  if (err != 0) return EXIT_FAILURE;
  fdinfo.cat->name = "control-listen";
  fdinfo.fd = sock;
  fdinfo.url = "control:listen:9051";
  evt_core_add_fd(&evts, &fdinfo);

  init_timer (&evts);
  socks5_server_init(&evts);
  tor_ctl_server_init (&evts);

  evt_core_loop (&evts);

  return EXIT_SUCCESS;
}