Working activate (and only one activation).

I also have working callback/notify/post.

dispatchers.cpp

@@ -1,28 +1,88 @@
-#include "dispatchers.h"
+#include <boost/format.hpp>
 
+#include "dispatchers.h"
 #include "logging.h"
 
-Dispatch::Dispatch(Session &s) : sess{s} {};
+Dispatch::Dispatch(Session *s) : sess{s} {};
+
+Dispatch::~Dispatch(){};
+
+void Dispatch::to_server(const std::string &send) { sess->to_server(send); }
+void Dispatch::to_client(const std::string &send) { sess->to_client(send); }
+const std::string &Dispatch::get_prompt(void) { return sess->get_prompt(); }
+
+void Dispatch::setNotify(notifyFunc nf) { notify_ = nf; }
+
+void Dispatch::notify(void) {
+  if (notify_) {
+    sess->post(notify_);
+    notify_ = nullptr;
+  }
+}
+
+MainDispatch::MainDispatch(Session *s) : Dispatch{s} {
+  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->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");
+}
 
-Dispatch::~Dispatch() {};
+void MainDispatch::deactivate(void) {
+  // Since we're the main thing there --
+  sess->emit_server_line = nullptr;
+  sess->emit_server_prompt = nullptr;
+  sess->emit_client_input = nullptr;
+  sess->show_client = true;
+  sess->talk_direct = true;
+  sess->set_prompt(old_prompt);
+  notify();
+}
 
-// virtuals
-/*
-void Dispatch::server_line(const std::string &line){};
-void Dispatch::server_prompt(const std::string &prompt){};
-void Dispatch::client_input(const std::string &input){};
-*/
+void MainDispatch::server_line(const std::string &line) {
+  BUGZ_LOG(info) << "MDSL: " << line;
+  to_client("SL: ");
+  to_client(line);
+  to_client("\n\r");
+}
 
-void Dispatch::to_server(const std::string &send) { sess.to_server(send); }
-void Dispatch::to_client(const std::string &send) { sess.to_client(send); }
-const std::string &Dispatch::get_prompt(void) { return sess.get_prompt(); }
+void MainDispatch::server_prompt(const std::string &prompt) {
+  BUGZ_LOG(info) << "MDSP: " << prompt;
+}
+
+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();
+
+  // Serious problem when the input = "\x1b" ESC.  The output gets gummed/locked
+  // up.
+  if (input == "\x1b") {
+    return;
+  }
+
+  ++count;
+  std::string output = str(boost::format("MSG %1%: [%2%]\n\r") % count % input);
+  to_client(output);
+  if (count >= 5) {
+    to_client("And we're outta here!\n\r");
+    deactivate();
+  }
+}
 
-CoreDispatch::CoreDispatch(Session &s) : Dispatch{s} {
-    BUGZ_LOG(warning) << "CoreDispatch()";
+CoreDispatch::CoreDispatch(Session *s) : Dispatch{s} {
+  BUGZ_LOG(warning) << "CoreDispatch()";
 }
 
 void CoreDispatch::server_line(const std::string &line) {}
 void CoreDispatch::server_prompt(const std::string &prompt) {}
 void CoreDispatch::client_input(const std::string &input) {
-    BUGZ_LOG(warning) << "Got: " << input << " prompt=" << get_prompt();
+  BUGZ_LOG(warning) << "Got: " << input << " prompt=" << get_prompt();
 }

dispatchers.h

@@ -1,37 +1,74 @@
 #ifndef DISPATCHERS_H
 #define DISPATCHERS_H
 
-class Dispatch;
-#include "session.h"
 
-// How does this call another?  
-// How does it return a result?
+
+#include <functional>
+
+typedef std::function<void(const std::string &)> StringFunc;
+typedef std::function<void(void)> notifyFunc;
+
+/*
+Item of the day:
+class Result {
+    // holds unique_ptr or shared_ptr to the "dispatcher"
+    // when I'm done -- delete the result, cleaning up
+    // the dispatcher
+
+}
+
+ How does this call another?  
+ How does it return a result?
+
+possibly:  io_service::post( DONE );  !
+
+ */
+
+
+class Session;
 
 
 class Dispatch {
 protected:
-  Session &sess;
-
+  Session *sess;
+  notifyFunc notify_;
 public:
-  Dispatch(Session &);
+  Dispatch(Session *);
   virtual ~Dispatch();
 
-  virtual void server_line(const std::string &line) = 0;
-  virtual void server_prompt(const std::string &prompt) = 0;
-  virtual void client_input(const std::string &input) = 0;
+  void setNotify(notifyFunc nf);
+  void notify(void);
 
   const std::string &get_prompt(void);
   void to_server(const std::string &send);
   void to_client(const std::string &send);
 };
 
+class MainDispatch : public Dispatch {
+public:
+  MainDispatch(Session*);
+
+  void activate(void);
+  void deactivate(void);
+
+  void server_line(const std::string &line);
+  void server_prompt(const std::string &prompt);
+  void client_input(const std::string &input);
+private:
+  int count;  
+  std::string old_prompt;
+};
+
 class CoreDispatch : public Dispatch {
 public:
-  CoreDispatch(Session &);
+  CoreDispatch(Session *);
+
 
-  void server_line(const std::string &line) override;
-  void server_prompt(const std::string &prompt) override;
-  void client_input(const std::string &input) override;
+  void server_line(const std::string &line);
+  void server_prompt(const std::string &prompt);
+  void client_input(const std::string &input);
 };
 
+#include "session.h"
+
 #endif

session.cpp

@@ -76,7 +76,7 @@ std::string clean_string(const std::string &source) {
 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},
+    : main(this), socket_(std::move(socket)), io_service_{io_service},
       resolver_{io_service}, server_{io_service}, prompt_timer_{io_service},
       keep_alive_{io_service}, host{hostname}, port{port} {
   // server_sent = 0;
@@ -111,6 +111,16 @@ Session::~Session() { BUGZ_LOG(info) << "~Session"; }
  * @return const std::string&
  */
 const std::string &Session::get_prompt(void) { return server_prompt; }
+void Session::set_prompt(const std::string &prompt) { server_prompt = prompt; }
+
+void Session::post(notifyFunc nf) {
+  if (nf) {
+    BUGZ_LOG(info) << "Session::post()";
+    io_service_.post(nf);
+  } else {
+    BUGZ_LOG(error) << "Session::post( nullptr )";
+  }
+}
 
 void Session::parse_auth(void) {
   // how many nulls should I be seeing?
@@ -452,9 +462,6 @@ void Session::on_resolve(
 void Session::client_input(const std::string &input) {
 
   BUGZ_LOG(info) << "CI: " << input;
-  if (emit_client_input) {
-    emit_client_input(input);
-  }
 
   // Is "proxy" active
   if (active) {
@@ -495,6 +502,8 @@ void Session::client_input(const std::string &input) {
       if (prompt.substr(0, 9) == "Command [") {
         int len = prompt.length();
         if (prompt.substr(len - 14) == "] (?=Help)? : ") {
+          proxy_activate();
+          /*
           to_client("\n\r\x1b[1;34mWELCOME!  This is where the proxy would "
                     "activate.\n\r");
           // active = true;
@@ -503,19 +512,40 @@ void Session::client_input(const std::string &input) {
 
           // but we aren't activating (NNY)
           to_client(get_prompt());
+          */
           return;
         }
       }
 
       // eat this input.
+      BUGZ_LOG(warning) << "CI: unable to activate, prompt was: [" << prompt
+                        << "]";
       return;
     }
   }
 
   // as the above code matures, talk_direct might get changed.
   // keep this part here (and not above).
-  if (talk_direct)
+  if (talk_direct) {
     to_server(input);
+  }
+
+  if (emit_client_input) {
+    emit_client_input(input);
+  }
+}
+
+void Session::proxy_activate(void) {
+  active = true;
+  main.setNotify([this](void) { this->proxy_deactivate(); });
+  main.activate();
+}
+
+void Session::proxy_deactivate(void) {
+  // Ok, how do we return?
+  active = false;
+  to_client(get_prompt());
+  // to_client(" \b");
 }
 
 void Session::client_read(void) {

session.h

@@ -8,16 +8,15 @@
 
 #include <stack>
 #include <vector>
+#include <functional>
+
+typedef std::function<void(const std::string &)> StringFunc;
+typedef std::function<void(void)> notifyFunc;
 
-class Session;
 #include "dispatchers.h"
 
 #define MAX_BUFFER 256
 
-#include <functional>
-
-typedef std::function<void(const std::string &)> StringFunc;
-
 /*
 The Session:
 
@@ -34,6 +33,7 @@ public:
   void start(void);
 
   const std::string &get_prompt(void);
+  void set_prompt(const std::string &prompt);
   void to_client(const std::string &message);
   void to_server(const std::string &message);
 
@@ -41,6 +41,10 @@ public:
   StringFunc emit_server_line;
   StringFunc emit_server_prompt;
   StringFunc emit_client_input;
+  bool show_client = true;
+  bool talk_direct = true;
+
+  void post( notifyFunc nf );
 
 private:
   void on_server_line(const std::string &line);
@@ -61,6 +65,7 @@ private:
   void split_lines(std::string line);
   void process_lines(std::string &received);
 
+
 private:
   void set_prompt_timer(void);
   void reset_prompt_timer(void);
@@ -69,11 +74,12 @@ private:
   int time_ms;
   int keepalive_secs;
 
+  MainDispatch main;
+  void proxy_activate(void);
+  void proxy_deactivate(void);
+
   // std::stack<Dispatch *> director;
 
-  // FOR NOW:  These will go into the director
-  bool show_client = true;
-  bool talk_direct = true;
   bool active = false;
 
   /**