Updated classes to Classes.

I've updated my notes on one idea of how to do things.
Unfortunately, it would be pretty horrible!
I'd have functions and global variables to manage things.

:cat_scream:  So, I'm not going to do that.

I'm going to try to work on having a base class (dispatch),
and see how it goes with it.

TradeWars Proxy Notes.md

@@ -1,8 +1,18 @@
 # TradeWars Proxy ++
 
+## TODO
+
+* ~~Setup the prompt timeout.  Display prompt + prompt_raw (to verify that this is working)~~
+* ~~On the prompt, if there's a \r throw it away and everything left of it.~~
+* define the functions (server_line, server_prompt [default to null/not set], client_input).  And defaults "to_client, to_server" -- but those won't ever change.  
+* factory of shared_ptr of "director" ? (from dispatcher) so it gets parent / auto saves on ctor.  Sounds like a complete mess.  :(
+* BUG:  Things like "Activate Proxy" -- needs a timer in order to be able to send " " every so often to keep the game alive.
+* 
+
 ## Things to Improve / Fix
 
 * Moving anywhere should be done in a safe manner.  (Single step and density scan -- unless we just don't have any scanner!)
+* Trading -- know what we have as cargo and know what the ports are buying/selling.  [AVOID: They don't want what we have -- going to the other port.]  Possibly have an option to automatically jettison the cargo!
 * Any sectors with a high > 500 > 1000 density should be stored somewhere as "dangerous/of interest".  [How will we handle sectors that have our own fighters/planets in them then?]  Possibly do density scanner, and save those results as well...
 * The dispatcher should use a stack (FILO).  We should be able to create something (SafeMove) and give it a sector number.  It will then be placed on the stack.  Once it is done, it will be able to return "something" to signal success/failure.  (Maybe have a selectable "callback" with the results?)   "Something" being struct { int value, std::string text }.
 * Dispatcher

session.cpp

@@ -7,6 +7,7 @@
 
 #include <regex>
 
+#include "config.h"
 #include "session.h"
 
 #include <string>
@@ -61,33 +62,32 @@ std::string clean_string(const std::string &source) {
   return clean;
 }
 
-session::session(boost::asio::ip::tcp::socket socket,
+Session::Session(boost::asio::ip::tcp::socket socket,
                  boost::asio::io_service &io_service, std::string hostname,
                  std::string port)
     : socket_(std::move(socket)),
       io_service_{io_service}, resolver_{io_service}, server_{io_service},
       timer_{io_service}, host{hostname}, port{port} {
   server_sent = 0;
+  time_ms = stoi(from_config("prompt_timeout", "50"));
 }
 
-void session::start(void) {
+void Session::start(void) {
   // BOOST_LOG_NAMED_SCOPE();
 
   // If I want the file and line number information, here's how to do it:
   // BUGZ_LOG(info) << boost::format("(%1%:%2%) ") % __FILE__ % __LINE__
-  
-  BUGZ_LOG(info) << "session::start()";
+
+  BUGZ_LOG(info) << "Session::start()";
   auto self(shared_from_this());
   // read_buffer.reserve(1024);
   // do_write("Welcome!\n");
   client_read();
 }
 
-session::~session() {
-  BUGZ_LOG(info) << "~session";
-}
+Session::~Session() { BUGZ_LOG(info) << "~Session"; }
 
-void session::parse_auth(void) {
+void Session::parse_auth(void) {
   // how many nulls should I be seeing?
   // \0user\0pass\0terminal/SPEED\0
   // If I don't have a proper rlogin value here, it isn't going
@@ -99,9 +99,9 @@ void session::parse_auth(void) {
     rlogin_name = "?";
 }
 
-void session::on_connect(const boost::system::error_code error) {
+void Session::on_connect(const boost::system::error_code error) {
   // We've connected to the server!  WOOT WOOT!
-  // BOOST_LOG_NAMED_SCOPE("session");
+  // BOOST_LOG_NAMED_SCOPE("Session");
 
   if (!error) {
     BUGZ_LOG(info) << "Connected to " << host;
@@ -129,11 +129,11 @@ void session::on_connect(const boost::system::error_code error) {
   }
 }
 
-void session::dispatch_line(std::string line) {
+void Session::dispatch_line(std::string line) {
   // Does this have \n\r still on it?  I don't want them.
 
   std::string temp = clean_string(line);
-  BUGZ_LOG(info) << "SL: " << temp; 
+  BUGZ_LOG(info) << "SL: " << temp;
 }
 
 /*
@@ -146,7 +146,7 @@ what was just added to server_prompt.
 What about \r, \b ?  Should that "reset" the server_prompt?
 
  */
-void session::process_lines(std::string &received) {
+void Session::process_lines(std::string &received) {
   // break server_prompt into lines and send/process one by one.
 
   size_t pos, rpos;
@@ -198,9 +198,13 @@ void session::process_lines(std::string &received) {
 
     // How should I handle \r in lines?  For now, remove it
     // but LOG that we did.
+
+    replace(part, "\r", "");
+    /*
     if (replace(part, "\r", "")) {
       BUGZ_LOG(warning) << "\\r removed from line";
     }
+    */
 
     dispatch_line(part);
   }
@@ -213,9 +217,45 @@ void session::process_lines(std::string &received) {
       // std::string clean = clean_string(received);
       // BUGZ_LOG(error) << "show_client/leftovers:" << clean;
     }
+
+  // check the server prompt here:
+  if ((pos = server_prompt.rfind('\r')) != std::string::npos) {
+    // server_prompt contains \r, remove it.
+    server_prompt = server_prompt.substr(pos + 1);
+  }
+
+  if (!server_prompt.empty()) {
+    // We have something remaining -- start the timer!
+    set_timer();
+  }
+}
+
+void Session::set_timer(void) {
+  timer_.expires_after(std::chrono::milliseconds(time_ms));
+  timer_.async_wait(
+      boost::bind(&Session::on_timer, this, boost::asio::placeholders::error));
+}
+
+void Session::reset_timer(void) { timer_.cancel(); }
+void Session::on_timer(const boost::system::error_code error) {
+  if (error != boost::asio::error::operation_aborted) {
+    // Ok, VALID timeout
+    if (!server_prompt.empty()) {
+      // Here's what is happening:
+      // SP: [ESC[2JESC[H]
+      // which after clean_string is empty.
+
+      std::string clean = clean_string(server_prompt);
+      if (!clean.empty()) {
+        BUGZ_LOG(warning) << "SP: [" << clean << "]";
+        // emit
+      }
+      // BUGZ_LOG(trace) << "SP: [" << server_prompt << "]";
+    }
+  }
 }
 
-void session::server_read(void) {
+void Session::server_read(void) {
   auto self(shared_from_this());
 
   boost::asio::async_read(
@@ -250,7 +290,7 @@ void session::server_read(void) {
       });
 }
 
-void session::on_resolve(
+void Session::on_resolve(
     const boost::system::error_code error,
     const boost::asio::ip::tcp::resolver::results_type results) {
   //
@@ -261,12 +301,12 @@ void session::on_resolve(
     boost::asio::ip::tcp::endpoint const &endpoint = *results;
 
     server_.async_connect(endpoint,
-                          boost::bind(&session::on_connect, this,
+                          boost::bind(&Session::on_connect, this,
                                       boost::asio::placeholders::error));
 
   } else {
     // TO DO:
-    // BOOST_LOG_NAMED_SCOPE("session");
+    // BOOST_LOG_NAMED_SCOPE("Session");
     BUGZ_LOG(error) << "Unable to resolve: " << host;
     std::string output =
         str(boost::format("Unable to resolve: %1%\n\r") % host);
@@ -276,7 +316,7 @@ void session::on_resolve(
   }
 }
 
-void session::client_read(void) {
+void Session::client_read(void) {
   auto self(shared_from_this());
 
   boost::asio::async_read( // why can't I async_read_some here?
@@ -301,19 +341,19 @@ void session::client_read(void) {
 
             /* // this fails, and I'm not sure why.  I've used code like this
                before. resolver_.async_resolve( host, port, std::bind(
-               &session::on_resolve, this, _1, _2)); */
+               &Session::on_resolve, this, _1, _2)); */
 
             // This example shows using boost::bind, which WORKS.
             // https://stackoverflow.com/questions/6025471/bind-resolve-handler-to-resolver-async-resolve-using-boostasio
             resolver_.async_resolve(
                 host, port,
-                boost::bind(&session::on_resolve, this,
+                boost::bind(&Session::on_resolve, this,
                             boost::asio::placeholders::error,
                             boost::asio::placeholders::iterator));
 
           } else if (length) {
             // Proxy Active?
-            // BOOST_LOG_NAMED_SCOPE("session");
+            // BOOST_LOG_NAMED_SCOPE("Session");
 
             if (talk_direct)
               to_server(read_buffer);
@@ -325,14 +365,14 @@ void session::client_read(void) {
         } else {
           BUGZ_LOG(warning) << "C: read_failed";
           if (connected) {
-            BUGZ_LOG(warning) << "server.shutdown()";
+            BUGZ_LOG(warning) << "Server.shutdown()";
             server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
           }
         }
       });
 }
 
-void session::to_client(std::string message) {
+void Session::to_client(std::string message) {
   auto self(shared_from_this());
   // output the cleaned string (so I can see what we're sending in the
   // logs)
@@ -346,17 +386,16 @@ void session::to_client(std::string message) {
         if (!ec) {
 
         } else {
-          BUGZ_LOG(warning)
-              << "C: write failed? closed? server.shutdown()";
+          BUGZ_LOG(warning) << "C: write failed? closed? Server.shutdown()";
           if (connected) {
-            BUGZ_LOG(warning) << "server.shutdown()";
+            BUGZ_LOG(warning) << "Server.shutdown()";
             server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
           }
         }
       });
 }
 
-void session::to_server(std::string message) {
+void Session::to_server(std::string message) {
   auto self(shared_from_this());
   boost::asio::async_write(
       server_, boost::asio::buffer(message),
@@ -364,14 +403,13 @@ void session::to_server(std::string message) {
         if (!ec) {
 
         } else {
-          BUGZ_LOG(warning)
-              << "S: write failed? closed? socket.shutdown()";
+          BUGZ_LOG(warning) << "S: write failed? closed? socket.shutdown()";
           socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
         }
       });
 }
 
-server::server(boost::asio::io_service &io_service,
+Server::Server(boost::asio::io_service &io_service,
                const boost::asio::ip::tcp::endpoint &endpoint, std::string host,
                std::string port)
     : io_service_{io_service}, acceptor_{io_service_, endpoint}, host_{host},
@@ -386,12 +424,12 @@ server::server(boost::asio::io_service &io_service,
  * session to automatically clean up when it is no longer active/has anything
  * running in the reactor.
  */
-void server::do_accept(void) {
+void Server::do_accept(void) {
   acceptor_.async_accept([this](boost::system::error_code ec,
                                 boost::asio::ip::tcp::socket socket) {
     if (!ec) {
-      BUGZ_LOG(info) << "server::do_accept()";
-      std::make_shared<session>(std::move(socket), io_service_, host_, port_)
+      BUGZ_LOG(info) << "Server::do_accept()";
+      std::make_shared<Session>(std::move(socket), io_service_, host_, port_)
           ->start();
     }
 
@@ -401,13 +439,13 @@ void server::do_accept(void) {
 
 /**
  * Clean up the trailing ../ in __FILE__
- * 
+ *
  * This is used by the logging macro.
- * 
- * @param filepath 
- * @return const char* 
+ *
+ * @param filepath
+ * @return const char*
  */
-const char * trim_path( const char * filepath ) {
+const char *trim_path(const char *filepath) {
   if (strncmp(filepath, "../", 3) == 0) {
     filepath += 3;
   }

session.h

@@ -4,9 +4,59 @@
 #include <boost/asio.hpp>
 #include <boost/asio/ip/basic_resolver.hpp>
 #include <string>
+#include <map>
 
 #define MAX_BUFFER 256
 
+/*
+My ideas on how to do this.
+ */
+
+struct Request {
+  int x, y;
+  std::string str;
+};
+
+struct Result {
+  int x;
+  std::string str;
+};
+
+typedef std::function<void (const struct Result&)> ResultCallbackFunc;
+typedef std::function<void (const struct Request&, ResultCallbackFunc)> CommandFunc;
+
+// Yes, this needs to be in session.cpp (not the header)  Whoops!
+// std::map<std::string, CommandFunc> commands;
+
+// call_command("goto", Request{1, 0, ""}, my_callback );
+void register_command(const std::string name, CommandFunc command);
+bool call_command(const std::string name, const struct Request &param, ResultCallbackFunc callback);
+// look up name, if found, call it with params, callback.  return true (success)
+// otherwise fail (false).
+
+typedef std::function<void (const std::string &)> StringFunc;
+
+class OldState {
+  StringFunc server_line;
+  StringFunc server_prompt;
+  StringFunc client_input;
+  bool server_to_client;
+  bool client_to_server;  
+};
+
+class Dispatcher {
+
+  std::function<void (std::string)> server_line;
+  std::function<void (std::string)> server_prompt;
+  std::function<void (std::string)> client_input;
+  bool server_to_client;
+  bool client_to_server;
+
+  OldState save_state(void);
+  void restore_state(OldState);
+};
+
+
 /*
 Dispatch Manager:
 
@@ -42,18 +92,18 @@ It seems like the director wants to be the session, or at least parts of it.
  */
 
 /*
-The session:
+The Session:
 
  */
 
-class session : public std::enable_shared_from_this<session> {
+class Session : public std::enable_shared_from_this<Session> {
 public:
-  session(boost::asio::ip::tcp::socket socket,
+  Session(boost::asio::ip::tcp::socket socket,
           boost::asio::io_service &io_service, std::string hostname,
           std::string port);
   void start(void);
 
-  ~session();
+  ~Session();
 
   void parse_auth(void);
   void on_connect(const boost::system::error_code error);
@@ -61,7 +111,7 @@ public:
   void server_read(void);
   void on_resolve(const boost::system::error_code error,
                   const boost::asio::ip::tcp::resolver::results_type results);
-  void do_read(void);
+  void client_read(void);
   void to_client(std::string message);
   void to_server(std::string message);
   void on_shutdown(boost::system::error_code ec);
@@ -70,6 +120,11 @@ public:
   void process_lines(std::string &received);
 
 private:
+  void set_timer(void);
+  void reset_timer(void);
+  void on_timer(const boost::system::error_code error);
+  int time_ms;
+
   // FOR NOW:  These will go into the director
   bool show_client = true;
   bool talk_direct = true;
@@ -161,10 +216,10 @@ so I probably won't move that just yet.  [NNY!]
 
 */
 
-class server {
+class Server {
 
 public:
-  server(boost::asio::io_service &io_service,
+  Server(boost::asio::io_service &io_service,
          const boost::asio::ip::tcp::endpoint &endpoint, std::string host,
          std::string port);
 
@@ -184,13 +239,17 @@ private:
   std::string port_;
 };
 
-// The simple way to get the boost logging to log file and line number information.
-#include <string.h>
+// The simple way to get the boost logging to log file and line number
+// information.
 #include <iomanip>
+#include <string.h>
 
 // I don't gain anything from this being constexpr
-const char * trim_path( const char * filepath );
+const char *trim_path(const char *filepath);
 
-#define BUGZ_LOG(severity) BOOST_LOG_TRIVIAL(severity) << "(" << std::setw(15) << trim_path( __FILE__ ) << ":" << std::setw(4) << std::left << __LINE__ << ") "
+#define BUGZ_LOG(severity)                                                     \
+  BOOST_LOG_TRIVIAL(severity)                                                  \
+      << "(" << std::setw(15) << trim_path(__FILE__) << ":" << std::setw(4)    \
+      << std::left << __LINE__ << ") "
 
 #endif

twproxy.cpp

@@ -105,7 +105,7 @@ int main(int argc, char *argv[]) {
     boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(),
                                             port); // std::atoi(argv[i]));
     // connect to the game server
-    server s(io_service, endpoint, CONFIG["host"], CONFIG["port"]);
+    Server s(io_service, endpoint, CONFIG["host"], CONFIG["port"]);
     
     io_service.run();
   } catch (std::exception &e) {