melonvpn/src/impl/daemon/main.c

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include <threads.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>

#include "states.h"
#include "unix_sockets.h"
#include "melon_vpn_sock.h"
#include "config_file.h"
#include "popen2.h"

#define vpnconfig "/etc/melonvpn/client.cfg"
#define daemonconfig "/etc/melonvpn/daemon.cfg"

char *vpnserver = "";
char *devicename = "unknown";
bool restartvpn = false;

char *storedpeers;
pid_t vpn_process = -1;
States currentstate;

int start_daemon_server(void*);
int start_peers_server(void*);
void send_to_client(char*, ssize_t);

int start_vpn_process();
void stop_vpn_process();

thrd_t daemonthr;
thrd_t peersthr;

void read_vpn_config();
void read_daemon_config();
void write_daemon_config();

int main(int argc, char **argv) {
  currentstate = DISCONNECTED;

  printf("Reading config files...\n");
  read_vpn_config();
  read_daemon_config();

  printf("VPN server:  %s\n", vpnserver);
  printf("Device name: %s\n", devicename);
  printf("Restart VPN: %s\n", restartvpn ? "true" : "false");

  printf("Create folder for sockets\n");

  // why check stat first its slower?
  char sock_wrapper_path[100] = SV_WRAPPER_SOCK_PATH;
  umask(0);

  // Try removing sockets
  unlink(SV_CLIENT_SOCK_PATH);
  unlink(SV_DAEMON_SOCK_PATH);
  unlink(SV_RPEERS_SOCK_PATH);

  // Remove wrapping directory and make a new one
  rmdir(sock_wrapper_path);
  int mkdirout = mkdir(sock_wrapper_path, 0777); // user: rw, group: rw, everyone: w
  if(mkdirout!=0) {
    fprintf(stderr, "Failed to create directory for sockets (%d)\n",mkdirout);
    return 1;
  }

  thrd_create(&daemonthr, start_daemon_server, NULL);
  thrd_create(&peersthr, start_peers_server, NULL);

  thrd_join(daemonthr, NULL);
  thrd_join(peersthr, NULL);
}

void incoming_request(char *request) {
  fprintf(stderr, "Incoming request: %s\n",request);
  char *a = strtok(request, "\1");

  if(strcmp(a,"daemon")==0) {
    char *b = strtok(NULL, "\1");

    if(strcmp(b,"status")==0) {
      send_vpn_status();
    } else if(strcmp(b,"connect")==0) {
      if(start_vpn_process()==0) {
        currentstate = CONNECTED;
      } else {
        currentstate = DISCONNECTED;
      }
      send_vpn_status();
    } else if(strcmp(b,"disconnect")==0) {
      stop_vpn_process();
      currentstate = DISCONNECTED;
      send_vpn_status();
    } else if(strcmp(b,"isrestart")==0) {
      send_is_restart_status();
    } else if(strcmp(b,"restart")==0) {
      char *c = strtok(NULL, "\1");
      restartvpn=strcmp(c,"on")==0;
      write_daemon_config();
    }
  }
}

void incoming_peers(char *peers) {
  storedpeers = peers;
  send_to_client(peers, strlen(peers));
}

void send_vpn_status() {
  char *msgprefix = "client\1status\1";
  int prefixl = strlen(msgprefix);
  char *msgsuffix = string_state(currentstate);
  int suffixl = strlen(msgsuffix);
  int total = prefixl+suffixl;
  char msg[total+1];
  strcpy(msg, msgprefix);
  msg[prefixl] = 0;
  strcat(msg, msgsuffix);
  msg[total] = 0;
  send_to_client(msg, total+1);
}

void send_is_restart_status() {
  char *msgprefix = "client\1isrestart\1";
  int prefixl = strlen(msgprefix);
  char *msgsuffix = restartvpn ? "on" : "off";
  int suffixl = strlen(msgsuffix);
  int total = prefixl+suffixl;
  char msg[total+1];
  strcpy(msg, msgprefix);
  msg[prefixl]=0;
  strcat(msg, msgsuffix);
  msg[total]=0;
  send_to_client(msg, total+1);
}

void read_vpn_config() {
  FILE *fp;
  fp = fopen(vpnconfig, "r");

  keyvaluepair_t result;
  while(true) {
    result = config_read(fp);
    if(!result.loop) break;

    if(strcmp(result.key, "vpn")==0) {
      vpnserver = malloc(strlen(result.value));
      strcpy(vpnserver, result.value);
    } else if(strcmp(result.key, "name")==0) {
      devicename = malloc(strlen(result.value));
      strcpy(devicename, result.value);
    }
  }

  fclose(fp);
}

void read_daemon_config() {
  FILE *fp;
  fp = fopen(daemonconfig, "r");

  keyvaluepair_t result;
  while(true) {
    result = config_read(fp);
    if(!result.loop) break;

    if(strcmp(result.key, "restart")==0) {
      restartvpn = strcmp(result.value, "true")==0;
    }
  }

  fclose(fp);
}

void write_daemon_config() {
  FILE *fp;
  fp = fopen(daemonconfig, "w");

  config_write(fp, "restart", restartvpn?"true":"false");

  fclose(fp);
}

int start_vpn_process() {
  fprintf(stderr, "ready to start: %d\n", vpn_process);
  if(vpn_process != -1) return;

  // Command line arguments for simple-vpn
  char* const command[] = {"simple-vpn", "client", vpnconfig, NULL};

  fprintf(stderr, "Attempting to start simple-vpn.\n");

  int a;
  int b;
  pid_t pp = popen2(command, &a, &b);
  if(pp < 0){
    fprintf(stderr, "Could not start simple-vpn.\n");
    return 1;
  }

  vpn_process = pp;
  return 0;
}

void stop_vpn_process() {
  if(vpn_process < 0) return;
  fprintf(stderr, "Stopping simple-vpn (%d)\n", vpn_process);

  kill(vpn_process, SIGTERM);
  waitpid(vpn_process,NULL,0);
  vpn_process = -1;
}

int start_daemon_server(void *thr_data) {
  (void)thr_data;

  int sfd = unix_socket_server_start(SV_DAEMON_SOCK_PATH);

  ssize_t numRead;
  char buf[BUF_SIZE];
  int MAX_PEERS_LEN = 1000;
  int total = 0;
  char msg[MAX_PEERS_LEN];

  for(;;) {
    int cfd = accept(sfd, NULL, NULL);

    total = 0;
    strcpy(msg, "");
    strcpy(buf, "");

    while ((numRead = read(cfd, buf, BUF_SIZE)) > 0) {
      if(total > MAX_PEERS_LEN-1) break;
      total+=numRead;

      // Append buf to msg then clear buf
      strcat(msg, buf);
      strcpy(buf, "");
      msg[total]=0;
    }

    incoming_request(msg);
  }

  return 0;
}

int start_peers_server(void *thr_data) {
  (void)thr_data;

  int sfd = unix_socket_server_start(SV_RPEERS_SOCK_PATH);

  ssize_t numRead;
  int MAX_PEERS_LEN = 1000;
  char msg[MAX_PEERS_LEN];
  char buf[BUF_SIZE];
  int total = 0;

  for(;;) {
    int cfd = accept(sfd, NULL, NULL);

    strcpy(msg, "");
    strcpy(buf, "");
    total = 0;

    while ((numRead = read(cfd, buf, BUF_SIZE)) > 0) {
      if(total > MAX_PEERS_LEN-1) break;
      total+=numRead;
      strcat(msg, buf);
      msg[MAX_PEERS_LEN-1]=0;
    }

    incoming_peers(msg);
  }

  return 0;
}

void send_to_client(char *buf, ssize_t n) {
  int sfd = unix_socket_client_start(SV_CLIENT_SOCK_PATH);
  if(sfd==-1) {
    return;
  }

  write(sfd, buf, n);
  close(sfd);

  fprintf(stderr, "Closed connection to socket\n");
}