Updated: working input, only allow keep alive

when the proxy is active.

dispatchers.cpp

@@ -1,4 +1,5 @@
 #include <boost/format.hpp>
+#include <cctype>
 
 #include "dispatchers.h"
 #include "logging.h"
@@ -20,20 +21,44 @@ void Dispatch::notify(void) {
   }
 }
 
-MainDispatch::MainDispatch(Session *s) : Dispatch{s} {
+MainDispatch::MainDispatch(Session *s) : Dispatch{s}, id{s} {
   BUGZ_LOG(warning) << "MainDispatch()";
 }
 
+MainDispatch::~MainDispatch() { BUGZ_LOG(warning) << "~MainDispatch()"; }
+
 void MainDispatch::activate(void) {
   // how to set this event to our method?
   sess->emit_server_line = [this](const std::string &s) { server_line(s); };
   sess->emit_server_prompt = [this](const std::string &s) { server_prompt(s); };
-  sess->emit_client_input = [this](const std::string &s) { client_input(s); };
+  sess->emit_client_input = nullptr;
+  // sess->emit_client_input = [this](const std::string &s) { client_input(s);
+  // };
   sess->show_client = false; // don not auto-send server to client
   sess->talk_direct = false; // do not auto-send client to server
   count = 0;
   old_prompt = sess->get_prompt();
   to_client("\n\r\x1b[1;34mWELCOME!  You are now in the proxy zone...\n\r");
+  id.prompt = "Proxy Main :=> ";
+  id.max_length = 25;
+  id.setNotify([this]() { this->have_input(); });
+  id.activate();
+}
+
+void MainDispatch::have_input(void) {
+  ++count;
+  std::string output =
+      str(boost::format("Your Input (%2%): [%1%]\n\r") % id.input % count);
+
+  to_client(output);
+  if (count >= 5) {
+    to_client("Returning you to the game...\n\r");
+    deactivate();
+  } else {
+    // prompt it again, sam.
+    id.setNotify([this]() { this->have_input(); });
+    id.activate();
+  }
 }
 
 void MainDispatch::deactivate(void) {
@@ -58,6 +83,7 @@ void MainDispatch::server_prompt(const std::string &prompt) {
   BUGZ_LOG(info) << "MDSP: " << prompt;
 }
 
+#ifdef NEVERMORE
 void MainDispatch::client_input(const std::string &input) {
   // I don't care what the old prompt looked liked at this point.
   BUGZ_LOG(warning) << "Got: " << input; //  << " prompt=" << get_prompt();
@@ -76,11 +102,73 @@ void MainDispatch::client_input(const std::string &input) {
     deactivate();
   }
 }
+#endif
+
+InputDispatch::InputDispatch(Session *s) : Dispatch(s) {
+  BUGZ_LOG(warning) << "InputDispatch()";
+}
 
+void InputDispatch::activate(void) {
+  ds = sess->save_settings();
+  sess->emit_server_line = [this](const std::string &s) { server_line(s); };
+  sess->emit_server_prompt =
+      nullptr; // [this](const std::string &s) { server_prompt(s); };
+  sess->emit_client_input = [this](const std::string &s) { client_input(s); };
+  sess->show_client = false; // don not auto-send server to client
+  sess->talk_direct = false; // do not auto-send client to server
+
+  input.clear();
+  to_client(prompt);
+}
+
+void InputDispatch::deactivate(void) {
+  sess->restore_settings(ds);
+  notify();
+}
+
+void InputDispatch::server_line(const std::string &line) {}
+// void InputDispatch::server_prompt(const std::string &prompt) {}
+
+void InputDispatch::client_input(const std::string &cinput) {
+  for (const char ch : cinput) {
+    if (isprint(ch)) {
+      // Ok!
+      if (input.length() < max_length) {
+        to_client(std::string(1, ch));
+        input += ch;
+      }
+    } else if ((ch == '\b') || (ch == 0x7f)) {
+      // Backspace or rubout
+      if (input.length() > 0) {
+        to_client("\b \b");
+        input.erase(input.size() - 1);
+      }
+    } else if (ch == '\r') {
+      // Ok, we're done!
+      BUGZ_LOG(info) << "InputDispatch done: " << input;
+      to_client("\n\r");
+      deactivate();
+    }
+  }
+}
+
+/*
+ * CoreDispatch:  This is an example class that does dispatch.
+ * Copy this and make changes from there...
+ */
 CoreDispatch::CoreDispatch(Session *s) : Dispatch{s} {
   BUGZ_LOG(warning) << "CoreDispatch()";
 }
 
+void CoreDispatch::activate(void) {
+  // save things, set things
+}
+
+void CoreDispatch::deactivate(void) {
+  // restore things
+  notify();
+}
+
 void CoreDispatch::server_line(const std::string &line) {}
 void CoreDispatch::server_prompt(const std::string &prompt) {}
 void CoreDispatch::client_input(const std::string &input) {

dispatchers.h

@@ -1,12 +1,7 @@
 #ifndef DISPATCHERS_H
 #define DISPATCHERS_H
 
-
-
-#include <functional>
-
-typedef std::function<void(const std::string &)> StringFunc;
-typedef std::function<void(void)> notifyFunc;
+#include "session_common.h"
 
 /*
 Item of the day:
@@ -17,21 +12,20 @@ class Result {
 
 }
 
- How does this call another?  
+ How does this call another?
  How does it return a result?
 
 possibly:  io_service::post( DONE );  !
 
  */
 
-
 class Session;
 
-
 class Dispatch {
 protected:
   Session *sess;
   notifyFunc notify_;
+
 public:
   Dispatch(Session *);
   virtual ~Dispatch();
@@ -39,31 +33,93 @@ public:
   void setNotify(notifyFunc nf);
   void notify(void);
 
+  virtual void activate(void) = 0;
+  virtual void deactivate(void) = 0;
+
   const std::string &get_prompt(void);
   void to_server(const std::string &send);
   void to_client(const std::string &send);
 };
 
+
+
+class InputDispatch : public Dispatch {
+private:
+  DispatchSettings ds;
+
+public:
+  InputDispatch(Session *);
+
+  std::string prompt;
+  size_t max_length;
+  std::string input;
+
+  void activate(void) override;
+  void deactivate(void) override;
+
+  // optional here
+  void server_line(const std::string &line);
+  // void server_prompt(const std::string &prompt);
+  void client_input(const std::string &cinput);
+};
+
+
+/**
+ * The main/first proxy Dispatcher.
+ * 
+ * Don't follow this as an example.  On disable,
+ * it resets everything back to nothing active.
+ * (Which is likely not what you want.)
+ * 
+ */
+
 class MainDispatch : public Dispatch {
+private:
+  InputDispatch id;
+
 public:
-  MainDispatch(Session*);
+  MainDispatch(Session *);
+  ~MainDispatch();
+
+  void activate(void) override;
+  void deactivate(void) override;
 
-  void activate(void);
-  void deactivate(void);
+  void have_input(void);
 
   void server_line(const std::string &line);
   void server_prompt(const std::string &prompt);
-  void client_input(const std::string &input);
+  // void client_input(const std::string &input);
+
 private:
-  int count;  
+  int count;
   std::string old_prompt;
 };
 
+
+
+class MenuDispatch : public Dispatch {
+public:
+  MenuDispatch(Session *);
+
+  void activate(void) override;
+  void deactivate(void) override;
+
+  // optional here
+  void server_line(const std::string &line);
+  void server_prompt(const std::string &prompt);
+  void client_input(const std::string &input);
+};
+
+
+
 class CoreDispatch : public Dispatch {
 public:
   CoreDispatch(Session *);
 
+  void activate(void) override;
+  void deactivate(void) override;
 
+  // optional here
   void server_line(const std::string &line);
   void server_prompt(const std::string &prompt);
   void client_input(const std::string &input);

session.cpp

@@ -535,8 +535,23 @@ void Session::client_input(const std::string &input) {
   }
 }
 
+DispatchSettings Session::save_settings(void) {
+  DispatchSettings ss{emit_server_line, emit_server_prompt, emit_client_input,
+                      show_client, talk_direct};
+  return ss;
+}
+
+void Session::restore_settings(const DispatchSettings &ss) {
+  emit_server_line = ss.server_line;
+  emit_server_prompt = ss.server_prompt;
+  emit_client_input = ss.client_input;
+  show_client = ss.show_client;
+  talk_direct = ss.talk_direct;
+}
+
 void Session::proxy_activate(void) {
   active = true;
+  start_keepin_alive(); // kickstart the keepalive timer
   main.setNotify([this](void) { this->proxy_deactivate(); });
   main.activate();
 }
@@ -639,6 +654,12 @@ void Session::to_server(const std::string &message) {
         }
       });
 
+  if (active) {
+    start_keepin_alive();
+  }
+}
+
+void Session::start_keepin_alive(void) {
   // keep alive timer
   keep_alive_.expires_after(std::chrono::seconds(keepalive_secs));
   keep_alive_.async_wait(boost::bind(&Session::stayin_alive, this,
@@ -648,8 +669,10 @@ void Session::to_server(const std::string &message) {
 void Session::stayin_alive(const boost::system::error_code error) {
   if (error != boost::asio::error::operation_aborted) {
     // stayin' alive, stayin' alive...
-    to_server(" ");
-    BUGZ_LOG(warning) << "Session::stayin_alive()";
+    if (active) {
+      to_server(" ");
+      BUGZ_LOG(warning) << "Session::stayin_alive()";
+    }
   }
 }
 

session.h

@@ -6,12 +6,7 @@
 #include <map>
 #include <string>
 
-#include <stack>
-#include <vector>
-#include <functional>
-
-typedef std::function<void(const std::string &)> StringFunc;
-typedef std::function<void(void)> notifyFunc;
+#include "session_common.h"
 
 #include "dispatchers.h"
 
@@ -22,6 +17,7 @@ The Session:
 
  */
 
+
 class Session : public std::enable_shared_from_this<Session> {
 public:
   Session(boost::asio::ip::tcp::socket socket,
@@ -37,6 +33,9 @@ public:
   void to_client(const std::string &message);
   void to_server(const std::string &message);
 
+  DispatchSettings save_settings(void);
+  void restore_settings(const DispatchSettings &ss);
+
   // what uses these? how do you use these?
   StringFunc emit_server_line;
   StringFunc emit_server_prompt;
@@ -44,7 +43,7 @@ public:
   bool show_client = true;
   bool talk_direct = true;
 
-  void post( notifyFunc nf );
+  void post(notifyFunc nf);
 
 private:
   void on_server_line(const std::string &line);
@@ -65,12 +64,12 @@ private:
   void split_lines(std::string line);
   void process_lines(std::string &received);
 
-
 private:
   void set_prompt_timer(void);
   void reset_prompt_timer(void);
   void on_prompt_timeout(const boost::system::error_code error);
   void stayin_alive(const boost::system::error_code error);
+  void start_keepin_alive(void);
   int time_ms;
   int keepalive_secs;