horrible-harry/hharry.cpp

#include "terminal.h"
#include "utils.h"
#include "wordplay.h"
#include <ctype.h>
#include <fcntl.h>
#include <fstream>
#include <iostream>
#include <pty.h>
#include <sstream>
#include <stdio.h>
#include <stdlib.h> // random()
#include <string.h>
#include <string>
#include <strings.h> // strcasecmp
#include <sys/select.h>
#include <sys/wait.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>

struct console_details console;

/*
We get the username/fullname from tailing the node logs,
and reading the user.dat file.
 */
std::string username;
std::string fullname;

// #include <signal.h> // handle Ctrl-C/SIGINT

/* Log level guideline:
 * - ZF_LOG_FATAL - happened something impossible and absolutely unexpected.
 *   Process can't continue and must be terminated.
 *   Example: division by zero, unexpected modifications from other thread.
 * - ZF_LOG_ERROR - happened something possible, but highly unexpected. The
 *   process is able to recover and continue execution.
 *   Example: out of memory (could also be FATAL if not handled properly).
 * - ZF_LOG_WARN - happened something that *usually* should not happen and
 *   significantly changes application behavior for some period of time.
 *   Example: configuration file not found, auth error.
 * - ZF_LOG_INFO - happened significant life cycle event or major state
 *   transition.
 *   Example: app started, user logged in.
 * - ZF_LOG_DEBUG - minimal set of events that could help to reconstruct the
 *   execution path. Usually disabled in release builds.
 * - ZF_LOG_VERBOSE - all other events. Usually disabled in release builds.
 *
 * *Ideally*, log file of debugged, well tested, production ready application
 * should be empty or very small. Choosing a right log level is as important as
 * providing short and self descriptive log message.
 */
/*
#define ZF_LOG_VERBOSE 1
#define ZF_LOG_DEBUG   2
#define ZF_LOG_INFO    3
#define ZF_LOG_WARN    4
#define ZF_LOG_ERROR   5
#define ZF_LOG_FATAL   6
*/

// When debugging low-level, use this:
// #define ZF_LOG_LEVEL ZF_LOG_VERBOSE
// Except this doesn't work.  It needs to be anywere the
// zf_log.h is included.

// LOGGING with file output

#include "zf_log.h"

FILE *g_log_file;

static void file_output_callback(const zf_log_message *msg, void *arg) {
  (void)arg;
  *msg->p = '\n';
  fwrite(msg->buf, msg->p - msg->buf + 1, 1, g_log_file);
  fflush(g_log_file);
}

static void file_output_close(void) { fclose(g_log_file); }

static int file_output_open(const char *const log_path) {
  g_log_file = fopen(log_path, "a");
  if (!g_log_file) {
    ZF_LOGW("Failed to open log file %s", log_path);
    return 0;
  }
  atexit(file_output_close);
  zf_log_set_output_v(ZF_LOG_PUT_STD, 0, file_output_callback);
  return 1;
}

void log_flush(void) { fflush(g_log_file); }

// END LOGGING

/*
What is the name of the actual, real Mystic executable
that we'll be executing and mangling?
*/

#define TARGET "./mySTIC"
// Size of our input and output buffers.
#define BSIZE 1024

/*
    These are harry "timeout" events.

    These happen when we've been sitting around awhile.

 */

int node;

/*
This only works for those few idiots that use the
horribly broken SSH crap that Mystic uses.
 */
int locate_user(const char *alias) {
  FILE *user;
  char buffer[0x600];
  char temp[100];

  user = fopen("data/users.dat", "rb");
  if (user == NULL)
    return 0;

  // Carry on!
  while (fread(buffer, 0x600, 1, user) == 1) {
    pcopy(buffer + 0x6d, temp);
    if (strcasecmp(temp, username.c_str()) == 0) {
      pcopy(buffer + 0x8c, temp);
      fullname.assign(temp);
      break;
    }
    /*
    printf("Alias: %s\n", temp);
    pcopy(buffer + 0x8c, temp );
    printf("Full Name: %s\n", temp );
    */
  }
  fclose(user);
  return 1;
}

std::ifstream logfile;
std::streampos log_pos;

void open_mystic_log(void) {
  std::string mystic_logfile;
  {
    std::ostringstream buffer;

    buffer << "logs/node" << node << ".log";
    mystic_logfile = buffer.str();
  };
  logfile.open(mystic_logfile, std::ios_base::in | std::ios_base::ate);
  // Ok, we're at the end of the file.  Or should be.
  if (logfile.is_open()) {
    ZF_LOGD("Log %s open", (const char *)mystic_logfile.c_str());
    log_pos = logfile.tellg();
  } else {
    ZF_LOGE("Failed to open: %s", (const char *)mystic_logfile.c_str());
  }
}

void scan_mystic_log(void) {

  if (logfile.is_open()) {
    int again = 0;
    do {
      std::string line = find_new_text(logfile, log_pos);
      if (line.empty())
        return;
      again = 1;

      ZF_LOGD("mystic log: %s", (const char *)line.c_str());
      // Ok, we have a line, look for interesting details
      if (line.find("New user application") != std::string::npos) {
        ZF_LOGE("New User");
      }

      size_t pos;
      pos = line.find("Created Account: ");
      if (pos != std::string::npos) {
        pos += 18 - 1;
        // Ok, find the end '#'
        size_t len = line.find('#', pos);
        if (len != std::string::npos) {
          username = line.substr(pos, len - pos - 1);
          ZF_LOGE("New User: %s", (const char *)username.c_str());
          // once we know this works -- lookup user's record
          locate_user(username.c_str());
          ZF_LOGD("Username: [%s] A.K.A. [%s]", (const char *)username.c_str(),
                  (const char *)fullname.c_str());
        }
      }
      pos = line.find(" logged in");
      if (pos != std::string::npos) {
        --pos;
        size_t len = line.rfind(' ', pos);
        if (len != std::string::npos) {
          len++;
          username = line.substr(len, pos + 1 - len);
          ZF_LOGE("User: %s", (const char *)username.c_str());
          // verify this works, lookup
          locate_user(username.c_str());
          ZF_LOGD("Username: [%s] A.K.A. [%s]", (const char *)username.c_str(),
                  (const char *)fullname.c_str());
        }
      }
    } while (again);
  }
}

/*

This is done.  :D  My buffering system works with stack'em.

TO FIX:  Stop using c strings, must use char * buffer + int length.
MAY CONTAIN NULL VALUES.

Rework some things here.

Here's the "plan":

  if buffer is EMPTY:
      time_idle = 1;
      // setup for "random timeout value mess"
        // we're in luck!  The last parameter is time interval/timeout.  :D
      timeout.tv_sec = 10; // randrange(10-25)
      timeout.tv_usec = 0;

  NOT EMPTY:
      // we're in luck!  The last parameter is time interval/timeout.  :D
      timeout.tv_sec = 0;
      timeout.tv_usec = 10;   // Wild Guess Here?  Maybe higher, maybe
lower? time_idle = 0;

  ON READ:
    read/append to current buffer.
    We can't use nulls -- what if they are using ZModem, there's nulls in
the file! Look for trailing  / the very last "\r\n".

    (I could mangle/chunk it line by line.  But I'm not sure I'd need to do
that.)

    Optional "mangle" buffer up to that very point -- and send up to that
point.

    Option #2:  Maybe we send everything if program has been running for
under 20 seconds.  This would allow the ANSI detect to not get screwed up by
this new idea.

  ON TIMEOUT:
    if time_idle:
      Activate funny harry timeout events.
    else:
      Ok, we *STILL* haven't received any more characters into the buffer --
      even after waiting.  (Maybe we haven't waited long enough?)
      send the pending information in the buffer and clear it out.
      Maybe this is a prompt, and there won't be a \r\n.

This allows for cleaner process of "lines" of buffer.  We shouldn't break
in the midDLE OF A WORD.  Downside is that we sit on buffer contents a
little while / some amount of time -- which will add some lag to prompts
showing up.

(LAG?  Are you kidding?)


ZModem:

    start:  "rz^M**"...

    05-12 18:12:15.916 >> rz^M**^XB00000000000000^M<8A>^Q
    05-12 18:12:15.928 << **\x18B0100000023be50\r\n\x11
    05-12 18:12:15.928 >> *^XC^D
    05-12 18:12:15.939 << **\x18B0900000000a87c\r\n\x11
    05-12 18:12:15.940 >> *^XC
    # Start of PK zipfile.
    05-12 18:12:15.941 >> PK^C^D^T

    end:
    05-12 18:26:38.700 << **\x18B0100000023be50\r\n\x11
    05-12 18:26:38.700 >> **^XB0823a77600344c^M<8A>
    05-12 18:26:38.711 << **\x18B0800000000022d\r\n
    05-12 18:26:38.712 >> OO^MESC[0m

 */

// TODO:  Get everything above this -- into another file.

int main(int argc, char *argv[]) {
  int master;
  pid_t pid;
  node = -1;

  init_harry();
  srandom(time(NULL));

  // ./mystic -TID7 -IP192.168.0.1 -HOSTUnknown -ML1 -SL0 -ST2 -CUnknown
  // -Ubugz -PUWISHPASSWORD
  // ./mystic -TID7 -IP192.168.0.1 -HOSTUnknown -ML0 -SL0 -ST0 -CUnknown

  // ./mystic -TID7 -IP192.168.0.1 -HOSTUnknown -ML1 -SL0 -ST2 -CUnknown
  // -Ubugz -PUWISH
  // ./mystic -TID7 -IP192.168.0.1 -HOSTUnknown -ML0 -SL0 -ST0 -CUnknown

  // ./mystic -TID7 -IP192.168.0.1 -HOSTUnknown -ML0 -SL0 -ST0 -CUnknown
  // ./mystic -TID9 -IP192.168.0.1 -HOSTUnknown -ML0 -SL1 -ST0 -CUnknown

  // ./mystic -TID7 -IP192.168.0.1 -HOSTUnknown -ML1 -SL0 -ST2 -CUnknown
  // -Ubugz -PDUMBWAYTODOTHIS
  // ./mystic -TID9 -IP192.168.0.1 -HOSTUnknown -ML1 -SL1 -ST2 -CUnknown
  // -Ubugz -PIDONTUSEPASCAL

  // SSH:  -ML1 -ST2
  // Telnet: -ML0 -ST0

  // Locate username (if given) in the command line
  // -U<username>
  for (int x = 0; x < argc; x++) {
    /*
    // This doesn't work:  You can give username + wrong password.
    // You will be identified as the wrong user at the login screen!
    if (strncmp("-U", argv[x], 2) == 0) {
      username.assign(argv[x] + 2);
    }
    */
    /* Changed in latest version
    if (strncmp("-SL", argv[x], 3) == 0) {
      node = atoi(argv[x] + 3) + 1;
    }
    */
    // -TID7, -TID9, -TID11 for node 1, 2, 3
    if (strncmp("-TID", argv[x], 4) == 0) {
      node = (atoi(argv[x] + 4) - 5) / 2;
    }
  }

  if (node == -1) {
    // likely this is someone trying to run something
    char *args[20]; // max 20 args
    int x;
    char new_exec[] = TARGET;

    // build new args list
    args[0] = new_exec;

    for (x = 1; x < argc; x++) {
      args[x] = argv[x];
    };

    // null term the list
    args[x] = NULL;

    // run Mystic, run!
    execvp(TARGET, args);
    return 2;
  }

  std::string logfile;
  {
    std::ostringstream buffer;

    buffer << "horrible_harry_" << node << ".log";
    logfile = buffer.str();
  };

  if (!file_output_open((const char *)logfile.c_str()))
    return 2;

  for (auto cit = CONFIG.begin(); cit != CONFIG.end(); ++cit) {
    ZF_LOGD("Config {%s}:{%s}", (const char *)cit->first.c_str(),
            (const char *)cit->second.c_str());
  }

  ZF_LOGI("Node: %d", node);
  if (!username.empty()) {
    locate_user(username.c_str());
    ZF_LOGD("Username: [%s] A.K.A. [%s]", (const char *)username.c_str(),
            (const char *)fullname.c_str());
  }
  open_mystic_log();

  pid = forkpty(&master, NULL, NULL, NULL);

  // impossible to fork
  if (pid < 0) {
    return 1;
  }

  // child
  else if (pid == 0) {
    char *args[20]; // max 20 args
    int x;
    char new_exec[] = TARGET;

    // build new args list
    args[0] = new_exec;

    for (x = 1; x < argc; x++) {
      args[x] = argv[x];
    };

    // null term the list
    args[x] = NULL;

    // run Mystic, run!
    execvp(TARGET, args);
  }

  // parent
  else {
    struct termios tios, orig1;
    struct timeval timeout;
    time_t last_logscan = time(NULL);

    ZF_LOGD("starting");

    tcgetattr(master, &tios);
    tios.c_lflag &= ~(ECHO | ECHONL | ICANON);
    /*
    tios.c_iflag &= ~(ICRNL | IXON | BRKINT);
    tios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
    tios.c_oflag &= ~(OPOST);
    */
    tcsetattr(master, TCSAFLUSH, &tios);

    tcgetattr(1, &orig1);
    tios = orig1;
    tios.c_iflag &= ~(ICRNL | IXON | BRKINT);
    tios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
    tios.c_oflag &= ~(OPOST);

    // https://viewsourcecode.org/snaptoken/kilo/02.enteringRawMode.html
    tcsetattr(1, TCSAFLUSH, &tios);

    /*
    This doesn't need to be static -- because it is part of
    main.  Once main ends, we're done.
    */
    std::string buffer;
    buffer.reserve(BSIZE * 2);
    std::string play;
    play.reserve(4096);

    int zmodem = 0;

    // int size = 0;  // use buffer.size() instead

    for (;;) {
      int time_idle;

      // define estruturas para o select, que serve para verificar qual
      // se tornou "pronto pra uso"
      fd_set read_fd;
      fd_set write_fd;
      fd_set except_fd;

      // inicializa as estruturas
      FD_ZERO(&read_fd);
      FD_ZERO(&write_fd);
      FD_ZERO(&except_fd);

      // atribui o descritor master, obtido pelo forkpty, ao read_fd
      FD_SET(master, &read_fd);
      // atribui o stdin ao read_fd
      FD_SET(STDIN_FILENO, &read_fd);

      // o descritor tem que ser unico para o programa, a documentacao
      // recomenda um calculo entre os descritores sendo usados + 1

      /*
       TODO:  Figure out how this would work.

       I'm thinking something like timeouts 30-50 seconds?
       And as we get closer, 15-25 seconds.

       if zmodem, buffer will always be empty -- we won't hold anything.
      */

      if (buffer.size() == 0) {
        // buffer is empty
        if (zmodem) {
          timeout.tv_sec = 5;
        } else {
          timeout.tv_sec = randrange(10, 20);
        };
        timeout.tv_usec = 0;
        time_idle = 1;
      } else {
        // buffer is not empty
        timeout.tv_sec = 0;
        timeout.tv_usec = 1;
        time_idle = 0;
      }

      if (last_logscan < time(NULL)) {
        scan_mystic_log();
        if (username.empty())
          last_logscan = time(NULL) + 2;
        else
          last_logscan = time(NULL) + 10;
      }

      if (select(master + 1, &read_fd, &write_fd, &except_fd, &timeout) == 0) {
        ZF_LOGI("TIMEOUT");
        // This means timeout!
        if (time_idle) {
          if (harry_level() && !zmodem)
            harry_idle_event(STDOUT_FILENO);
        } else {
          ZF_LOGV("TIMEOUT buffer: %s", logrepr(buffer.c_str()));
          /*
          ZF_LOGI_MEM(buffer.data(), buffer.size(), "TIMEOUT buffer size=%lu",
                      buffer.size());
          */
          play.assign(buffer);
          if (harry_level())
            mangle(STDOUT_FILENO, play);
          else {
            write(STDOUT_FILENO, play.data(), play.size());
            console_receive(&console, play);
          }

          /*
          ZF_LOGI("console_receive");
          console_receive(&console, buffer);
          ZF_LOGI("write buffer");
          write(STDOUT_FILENO, buffer.data(), buffer.size());
          */
          ZF_LOGI("buffer clear");
          buffer.clear();
          // size = 0;
          // buffer is empty now
        }
      }

      // read_fd esta atribuido com read_fd?
      if (FD_ISSET(master, &read_fd)) {
        // leia o que bc esta mandando
        // ZF_LOGD("read (%d) %d bytes", size, BSIZE - size);
        char read_buffer[BSIZE + 1];
        int total;

        // We may adjust this later on (adjusting read length).
        if ((total = read(master, read_buffer, BSIZE)) != -1) {

          // Ok, we've read more into the buffer.
          ZF_LOGV("Read %d bytes", total);
          buffer.append(read_buffer, total);

          if (zmodem) {
            // Ok, we're zmodem mode -- is it time to exit?
            size_t zend = buffer.find("\x1b[0m");
            if (zend != std::string::npos)
              zmodem = 0;
            zend = buffer.find("\x1b[1;1H");
            if (zend != std::string::npos)
              zmodem = 0;
            if (!zmodem)
              ZF_LOGD("Zmodem end");
          } else {
            // Should we be in zmodem mode?
            size_t zstart = buffer.find("**\x18"
                                        "B0");
            if (zstart != std::string::npos) {
              zmodem = 1;
              ZF_LOGD("Zmodem start");
            }
          }

          if (zmodem) {
            // ZF_LOGI("Buffer %lu bytes, zmodem...", buffer.size());

            write(STDOUT_FILENO, buffer.data(), buffer.size());
            // console_receive(&console, buffer);
            buffer.clear();
          } else {

            // ZF_LOGV_MEM(buffer + size, total, "Read %d bytes:", total);
            // size += total;
            // ZF_LOGV_MEM(buffer, size, "Buffer now:");

            size_t pos = buffer.rfind("\r\n");
            // rstrnstr(buffer, size, "\r\n");
            //  >= 0) {
            if (pos != std::string::npos) {
              // found something!

              pos += 2;
              // play = buffer.substr() wipes out play's reserve.
              // play = buffer.substr(0, pos);
              play.assign(buffer, 0, pos);
              ZF_LOGI("play %lu size, %lu cap", play.size(), play.capacity());
              // play.copy(buffer.data(), pos);
              //) = buffer.substr(0, pos);
              buffer.erase(0, pos);

              mangle(STDOUT_FILENO, play);

              // ZF_LOGD_MEM(buffer, pos, "mangle buffer %d bytes:", pos);
              // mangle(STDOUT_FILENO, buffer, pos);
              // memmove(buffer, buffer + pos, size - pos);
              // size -= pos;
              // } else {
              //   ZF_LOGV("position of /r/n not found.");
            }

            // Ok, we failed to find CR+NL.  What's the buffer size at?

            if (buffer.size() > BSIZE) {
              // Ok, there's something going on, and it doesn't look good
              // unsure if I want to feed this into the console
              // my guess at this point would be zmodem xfer
              ZF_LOGI("Buffer %lu bytes, write only...", buffer.size());

              write(STDOUT_FILENO, buffer.data(), buffer.size());
              console_receive(&console, buffer);
              buffer.clear();
            }
          }
        } else
          break;
      }

      // read_fd esta atribuido com a entrada padrao?
      if (FD_ISSET(STDIN_FILENO, &read_fd)) {
        // leia a entrada padrao
        char input[BSIZE];
        int r = read(STDIN_FILENO, &input, BSIZE);
        input[r] = 0;
        // e escreva no bc
        if (!zmodem) {
          if (r > 50) {
            ZF_LOGI("<< %d bytes", r);
          } else {
            ZF_LOGI("<< %s", repr(input));
          }
        }

        write(master, &input, r);

        // This is INPUT from the USER
        // ZF_LOGI_MEM( input, strlen(input), "<< ");
      }
    }

    // Restore terminal
    tcsetattr(1, TCSAFLUSH, &orig1);
    ZF_LOGD("exit");
  }

  return 0;
}