#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <signal.h>

#include <fcntl.h>

#include <ctype.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <sys/time.h>

#include <unistd.h>

static pid_t kid = 0;

static int want_debug = 0;

static char *command = NULL;

static int command_buflen = 0;

static int command_length = 0;

static int current_request = 0;

static char *program_name = NULL;

static int arg_count = 0;

static char **arg_list = NULL;

#define COMMAND_TERMINATOR '\0'

static struct SignalTable {

  char *sig_name;

  int sig_num;

} signal_table[] = {

  { "HUP", SIGHUP },

  { "INT", SIGINT },

  { "QUIT", SIGQUIT },

  { "ILL", SIGILL },

  { "TRAP", SIGTRAP },

  { "ABRT", SIGABRT },

  { "IOT", SIGIOT },

  { "BUS", SIGBUS },

  { "FPE", SIGFPE },

  { "KILL", SIGKILL },

  { "USR1", SIGUSR1 },

  { "SEGV", SIGSEGV },

  { "USR2", SIGUSR2 },

  { "PIPE", SIGPIPE },

  { "ALRM", SIGALRM },

  { "TERM", SIGTERM },

  { "CHLD", SIGCHLD },

  { "CONT", SIGCONT },

  { "STOP", SIGSTOP },

  { "TSTP", SIGTSTP },

  { "TTIN", SIGTTIN },

  { "TTOU", SIGTTOU },

  { "URG", SIGURG },

  { "XCPU", SIGXCPU },

  { "XFSZ", SIGXFSZ },

  { "VTALRM", SIGVTALRM },

  { "PROF", SIGPROF },

  { "WINCH", SIGWINCH },

  { "IO", SIGIO },

  { NULL, 0 }

};

void append_command_char(int ch) {

  if (command_length >= command_buflen) {

    int delta = 1024;

    command = realloc(command, command_buflen + delta);

    command_buflen += delta;

  }

  command[command_length++] = ch;

}

int read_command(void) {

  int ch;

  command_length = 0;

  while (1) {

    ch = fgetc(stdin);

    if ((ch == EOF) || (ch == COMMAND_TERMINATOR)) {

      break;

    }

    append_command_char(ch);

  }

  append_command_char(0);

  command_length--; /* don't count the trailing nul */

  return command_length;

}

void write_response(char *code, char *arg) {

  if (want_debug) fprintf(stderr, "response: %d:%s,%s\n", current_request, code, arg);

  fprintf(stdout, "%d:%s,%s", current_request, code, arg);

  fputc(COMMAND_TERMINATOR, stdout);

  fflush(stdout);

}

char *num_buf(int n) {

  static char buf[32];

  sprintf(buf, "%d", n);

  return buf;

}

void errno_response() {

  int e = errno;

  write_response("errno", num_buf(e));

}

void handle_program(char *cmd, char *arg) {

  if (program_name != NULL) {

    free(program_name);

  }

  program_name = strdup(arg);

  write_response("ok", arg);

}

void handle_argc(char *cmd, char *arg) {

  int i;

  if (arg_count > 0) {

    for (i = 0; i < arg_count; i++) {

      if (arg_list[i] != NULL) {

	free(arg_list[i]);

      }

    }

    free(arg_list);

  }

  arg_count = (int) strtoul(arg, NULL, 10);

  /* Allocate arg_count+2 slots because execv wants a

     NULL-terminated array and we copy the program name into the 0th

     arg slot before execing */

  arg_list = calloc(arg_count + 2, sizeof(char *));

  write_response("ok", arg);

}

void handle_arg(char *cmd, char *arg) {

  char *val = strchr(arg, ',');

  int index;

  if (arg == NULL) {

    val = "";

  } else {

    *val = '\0';

    val++;

  }

  index = (int) strtoul(arg, NULL, 10);

  if (index < 0 || index >= arg_count) {

    write_response("bad", arg);

  } else {

    if (arg_list[index + 1] != NULL) {

      free(arg_list[index + 1]);

    }

    arg_list[index + 1] = strdup(val);

    write_response("ok", arg);

  }

}

void handle_execv(char *cmd, char *arg) {

  if (kid != 0) {

    write_response("bad", "already");

    return;

  }

  if (command_length == 0) {

    write_response("bad", "command");

    return;

  }

  if (arg_list == NULL) {

    write_response("bad", "args");

    return;

  }

  arg_list[0] = strdup(program_name);

  kid = fork();

  if (kid == 0) {

    int nullfd = open("/dev/null", O_RDWR, 0777);

    close(0); dup2(nullfd, 0);

    close(1); dup2(nullfd, 1);

    close(2); dup2(nullfd, 2);

    close(nullfd);

    if (execv(program_name, arg_list) == -1) {

      exit(1);

    }

  } else {

    write_response("pid", num_buf((int) kid));

  }

}

int lookup_signal(char *name) {

  struct SignalTable *entry;

  for (entry = &signal_table[0]; entry->sig_name != NULL; entry++) {

    if (!strcasecmp(name, entry->sig_name)) {

      return entry->sig_num;

    }

  }

  return 0;

}

void handle_sendsig(char *cmd, char *arg) {

  int signum;

  if (isdigit(arg[0])) {

    signum = (int) strtoul(arg, NULL, 10);

  } else {

    signum = lookup_signal(arg);

  }

  if (signum == 0) {

    write_response("bad", "invalid");

    return;

  }

  if (kid == 0) {

    write_response("bad", "not_running");

    return;

  }

  if (kill(kid, signum) == 0) {

    write_response("ok","");

  } else {

    errno_response();

  }

}

struct CommandTableEntry {

  char *name;

  void (*handler)(char *cmd, char *arg);

} cmd_table[] = {

  {"program", handle_program},

  {"argc", handle_argc},

  {"arg", handle_arg},

  {"execv", handle_execv},

  {"sendsig", handle_sendsig},

  {NULL, NULL}

};

void eval_command(void) {

  char *reqnumstr, *cmd, *arg;

  struct CommandTableEntry *cte;

  reqnumstr = command;

  cmd = strchr(command, ':');

  if (cmd == NULL) {

    exit(1);

  } else {

    *cmd = '\0';

    cmd++;

  }

  current_request = (int) strtoul(reqnumstr, NULL, 10);

  if (current_request == 0) {

    exit(1);

  }

  arg = strchr(cmd, ',');

  if (arg == NULL) {

    arg = "";

  } else {

    *arg = '\0';

    arg++;

  }

  if (want_debug) fprintf(stderr, "command: %d:%s,%s\n", current_request, cmd, arg);

  for (cte = &cmd_table[0]; cte->name != NULL; cte++) {

    if (!strcmp(cte->name, cmd)) {

      cte->handler(cmd, arg);

      current_request = 0;

      return;

    }

  }

  write_response("bad_command", cmd);

  current_request = 0;

}

int main(int argc, char *argv[]) {

  fd_set fds;

  int keep_going = 1;

  want_debug = (argc > 1) && (!strcmp(argv[1], "-debug"));

  if (want_debug) fprintf(stderr, "execdaemon starting.\n");

  while (keep_going) {

    struct timeval timeout;

    timeout.tv_sec = 0;

    timeout.tv_usec = 100000; /* 100 ms */

    FD_ZERO(&fds);

    FD_SET(0, &fds);

    switch (select(1, &fds, NULL, NULL, &timeout)) {

      case 1: {

	if (!read_command()) {

	  keep_going = 0;

	} else {

	  eval_command();

	}

	break;

      }

      case 0:

	break;

      case -1:

	perror("select");

	exit(1);

    }

    if (kid != 0) {

      int pidstatus;

      pid_t result = waitpid(kid, &pidstatus, WNOHANG);

      if (result != 0) {

	if (WIFEXITED(pidstatus)) {

	  write_response("exit", num_buf(WEXITSTATUS(pidstatus)));

	} else if (WIFSIGNALED(pidstatus)) {

	  write_response("signal", num_buf(WTERMSIG(pidstatus)));

	} else {

	  write_response("died", "");

	}

	kid = 0;

      }

    }

  }

  if (want_debug) fprintf(stderr, "execdaemon exiting.\n");

  return 0;

}