This is working (very basic) proxy.

I've broken it down into server/session classes.
I've added notes on things to fix/update in this version.
And design ideas...

CMakeLists.txt

@@ -30,6 +30,6 @@ set(CMAKE_CXX_EXTENSIONS ON)
 FIND_PACKAGE( Boost 1.60 COMPONENTS program_options REQUIRED )
 INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIR} )
 
-ADD_EXECUTABLE( twproxy twproxy.cpp config.cpp)
+ADD_EXECUTABLE( twproxy twproxy.cpp config.cpp session.cpp session.h )
 TARGET_LINK_LIBRARIES( twproxy ${Boost_LIBRARIES} pthread )
 

TradeWars Proxy Notes.md

@@ -0,0 +1,15 @@
+# TradeWars Proxy ++
+
+## Things to Improve / Fix
+
+* Moving anywhere should be done in a safe manner.  (Single step and density scan.)
+* 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?]
+* 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
+  * will have "echo" value -- so we can hide things (if we want) from the client.  [Like loading ports and warps!]
+  * Will have line (to process the most recent received line), and prompt (the most recent / current complete prompt from the server). 
+  * There will be obvious clear ways to send to client and server.
+  * 
+* Storage.  (We store a lot of data.)  In python, we used JSON.  I'm thinking right now that we should use sqlite.  It's lightweight and mostly quick.  (Maybe have dirty bit option so we can save only things that have changed?)  This is OK up to the point where we have multiple users running through the proxy.  Then what happens?
+* When upgrading the planet, cargo is bought at full price.  (Haggle there as well.)
+* When trading, we sometimes get "We're not interested".  Figure out what we can adjust to get that to not happen.

session.cpp

@@ -0,0 +1,206 @@
+#include <boost/bind.hpp>
+#include <iostream>
+
+#include "session.h"
+
+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} {}
+
+void session::start(void) {
+  std::cout << "session" << std::endl;
+  auto self(shared_from_this());
+  // read_buffer.reserve(1024);
+  // do_write("Welcome!\n");
+  do_read();
+}
+
+session::~session() { std::cout << "~session destructed" << std::endl; }
+
+void session::parse_auth(void) {
+  // how many nulls should I be seeing?
+  // \0user\0pass\0terminal/SPEED\0
+  // Maybe in the future I'll care about parsing this out.  I don't right now.
+
+  // Ok, yes I do!  If I don't have a proper rlogin value here, it isn't going
+  // to work when I try to connect to the rlogin server.
+
+  if (rlogin_auth.size() > 10)
+    rlogin_name = rlogin_auth.c_str() + 1;
+  else
+    rlogin_name = "?";
+}
+
+void session::on_connect(const boost::system::error_code error) {
+  // We've connected to the server!  WOOT WOOT!
+  if (!error) {
+    std::cout << "Connected to server!" << std::endl;
+    do_write("Connected...\n\r");
+    connected = true;
+    if (rlogin_auth[0] != 0) {
+      // Ok, the rlogin information was junk --
+      do_write("Let me make up some rlogin for you...\n\r");
+      char temp[] = "\0test\0test\0terminal/9600\0";
+      std::string tmp(temp, sizeof(temp));
+      server_write(tmp);
+    } else {
+      server_write(rlogin_auth);
+    }
+
+    server_read();
+  } else {
+    // TODO:
+    std::string output = "Failed to connect : ";
+    output += host;
+    output += " : ";
+    output += port;
+    output += "\n\r";
+    do_write(output);
+
+    std::cout << "Failed to connect to server." << std::endl;
+    std::cout << "SHUTDOWN..." << std::endl;
+    socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+  }
+}
+
+void session::server_read(void) {
+  auto self(shared_from_this());
+
+  boost::asio::async_read(
+      server_, boost::asio::buffer(server_buffer, sizeof(server_buffer) - 1),
+      boost::asio::transfer_at_least(1),
+      [this, self](boost::system::error_code ec, std::size_t length) {
+        if (!ec) {
+          server_buffer[length] = 0;
+
+          if (length) {
+            // std::cout << length << std::endl;
+            std::cout << "S: " << server_buffer << std::endl;
+            do_write(server_buffer);
+          }
+          server_read();
+        } else {
+          std::cout << "S: read_failed: connection closed" << std::endl;
+          socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+          // socket_.async_shutdown(boost::bind(&session::on_shutdown, this,
+          // boost::asio::placeholders::error));
+        }
+      });
+}
+
+void session::on_resolve(
+    const boost::system::error_code error,
+    const boost::asio::ip::tcp::resolver::results_type results) {
+  //
+  auto self(shared_from_this());
+
+  if (!error) {
+    // Take the first endpoint.
+    boost::asio::ip::tcp::endpoint const &endpoint = *results;
+
+    server_.async_connect(endpoint,
+                          boost::bind(&session::on_connect, this,
+                                      boost::asio::placeholders::error));
+
+  } else {
+    // TO DO:
+    std::string output = "Unable to resolve: ";
+    output += host;
+    output += "\n\r";
+    do_write(output);
+    std::cout << "Unable to resolve?" << std::endl;
+    std::cout << "SHUTDOWN ..." << std::endl;
+    socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+  }
+}
+
+void session::do_read(void) {
+  auto self(shared_from_this());
+
+  boost::asio::async_read( // why can't I async_read_some here?
+      socket_, boost::asio::buffer(read_buffer, sizeof(read_buffer) - 1),
+      boost::asio::transfer_at_least(1),
+      [this, self](boost::system::error_code ec, std::size_t length) {
+        if (!ec) {
+          read_buffer[length] = 0;
+          if (rlogin_auth.empty()) {
+            // first read should be rlogin information
+            rlogin_auth.assign(read_buffer, length);
+
+            // parse authentication information
+            parse_auth();
+            do_write(std::string(1, 0));
+
+            do_write("Welcome, ");
+            do_write(rlogin_name);
+            do_write("\n\r");
+
+            // Activate the connection to the server
+
+            /* // 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)); */
+
+            // 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::asio::placeholders::error,
+                            boost::asio::placeholders::iterator));
+
+          } else if (length) {
+            // std::cout << length << std::endl;
+            server_write(read_buffer);
+            std::cout << "C: " << read_buffer << std::endl;
+            // do_write(output);
+          }
+          do_read();
+        } else {
+          std::cout << "C: read_failed: connection closed" << std::endl;
+          if (connected)
+            server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+          // server_.async_shutdown(boost::bind(&session::on_shutdown, this,
+          // boost::asio::placeholders::error));
+        }
+      });
+}
+
+void session::do_write(std::string message) {
+  auto self(shared_from_this());
+  boost::asio::async_write(
+      socket_, boost::asio::buffer(message),
+      [this, self](boost::system::error_code ec, std::size_t /*length*/) {
+        if (!ec) {
+
+        } else {
+          std::cout << "write failed? closed?" << std::endl;
+          server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+          // server_.async_shutdown(boost::bind(&session::on_shutdown, this,
+          // boost::asio::placeholders::error));
+        }
+      });
+}
+
+void session::server_write(std::string message) {
+  auto self(shared_from_this());
+  boost::asio::async_write(
+      server_, boost::asio::buffer(message),
+      [this, self](boost::system::error_code ec, std::size_t /*length*/) {
+        if (!ec) {
+
+        } else {
+          std::cout << "write failed? closed?" << std::endl;
+          socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+          // socket_.async_shutdown(boost::bind(&session::on_shutdown, this,
+          // boost::asio::placeholders::error));
+        }
+      });
+}
+
+void session::on_shutdown(boost::system::error_code ec) {
+  std::cout << "shutdown." << std::endl;
+}

session.h

@@ -0,0 +1,83 @@
+#ifndef SESSION_H
+#define SESSION_H
+
+#include <boost/asio.hpp>
+#include <boost/asio/ip/basic_resolver.hpp>
+#include <string>
+
+class session : public std::enable_shared_from_this<session> {
+public:
+  session(boost::asio::ip::tcp::socket socket,
+          boost::asio::io_service &io_service, std::string hostname,
+          std::string port);
+  void start(void);
+
+  ~session();
+
+  void parse_auth(void);
+  void on_connect(const boost::system::error_code error);
+
+  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 do_write(std::string message);
+  void server_write(std::string message);
+  void on_shutdown(boost::system::error_code ec);
+
+private:
+  boost::asio::ip::tcp::socket socket_;
+  boost::asio::io_service &io_service_;
+  boost::asio::ip::tcp::resolver resolver_;
+  boost::asio::ip::tcp::socket server_;
+  boost::asio::high_resolution_timer timer_;
+
+  // std::string read_buffer;
+  char read_buffer[257];
+  char server_buffer[257];
+
+  std::string rlogin_auth;
+  std::string rlogin_name;
+  std::string host;
+  std::string port;
+  bool connected = false;
+};
+
+/*
+maybe move the resolver part to the server, so I don't need io_service?
+
+I'm not sure what the socket connection part is going to need just yet,
+so I probably won't move that just yet.  [NNY!]
+
+*/
+
+class server {
+
+public:
+  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},
+        port_{port} {
+    do_accept();
+  }
+
+private:
+  void do_accept() {
+    acceptor_.async_accept([this](boost::system::error_code ec,
+                                  boost::asio::ip::tcp::socket socket) {
+      if (!ec) {
+        std::make_shared<session>(std::move(socket), io_service_, host_, port_)
+            ->start();
+      }
+
+      do_accept();
+    });
+  }
+  boost::asio::io_service &io_service_;
+  boost::asio::ip::tcp::acceptor acceptor_;
+  std::string host_;
+  std::string port_;
+};
+
+#endif

twproxy.cpp

@@ -9,258 +9,13 @@
 //
 
 #include <boost/asio.hpp>
-#include <boost/asio/ip/basic_resolver.hpp>
-#include <boost/bind.hpp>
 #include <cstdlib>
 #include <iostream>
+#include <string>
+#include <map>
 
 #include "config.h"
-
-class session : public std::enable_shared_from_this<session> {
-public:
-  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}, host{hostname}, port{port} {
-  }
-  void start(void) {
-    std::cout << "session" << std::endl;
-    auto self(shared_from_this());
-    // read_buffer.reserve(1024);
-    // do_write("Welcome!\n");
-    do_read();
-  }
-
-  ~session() { std::cout << "~session destructed" << std::endl; }
-
-  void parse_auth(void) {
-    // how many nulls should I be seeing?
-    // \0user\0pass\0terminal/SPEED\0
-    // Maybe in the future I'll care about parsing this out.  I don't right now.
-
-    // Ok, yes I do!  If I don't have a proper rlogin value here, it isn't going
-    // to work when I try to connect to the rlogin server.
-
-    if (rlogin_auth.size() > 10)
-      rlogin_name = rlogin_auth.c_str() + 1;
-    else
-      rlogin_name = "?";
-  }
-
-  void on_connect(const boost::system::error_code error) {
-    // We've connected to the server!  WOOT WOOT!
-    if (!error) {
-      std::cout << "Connected to server!" << std::endl;
-      do_write("Connected...\n\r");
-      connected = true;
-      server_read();
-    } else {
-      // TODO:
-      std::string output = "Failed to connect : ";
-      output += host;
-      output += " : ";
-      output += port;
-      output += "\n\r";
-      do_write(output);
-      
-      std::cout << "Failed to connect to server." << std::endl;
-      std::cout << "SHUTDOWN..." << std::endl;
-      socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
-    }
-  }
-
-  void server_read(void) {
-    auto self(shared_from_this());
-
-    boost::asio::async_read(
-        server_, boost::asio::buffer(server_buffer, sizeof(server_buffer) - 1),
-        boost::asio::transfer_at_least(1),
-        [this, self](boost::system::error_code ec, std::size_t length) {
-          if (!ec) {
-            server_buffer[length] = 0;
-
-            if (length) {
-              // std::cout << length << std::endl;
-              std::cout << "S: " << server_buffer << std::endl;
-              do_write(server_buffer);
-            }
-            server_read();
-          } else {
-            std::cout << "S: read_failed: connection closed" << std::endl;
-            socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
-            // socket_.async_shutdown(boost::bind(&session::on_shutdown, this,
-            // boost::asio::placeholders::error));
-          }
-        });
-  }
-
-  void on_resolve(const boost::system::error_code error,
-                  const boost::asio::ip::tcp::resolver::results_type results) {
-    //
-    auto self(shared_from_this());
-
-    if (!error) {
-      // Take the first endpoint.
-      boost::asio::ip::tcp::endpoint const &endpoint = *results;
-
-      server_.async_connect(endpoint,
-                            boost::bind(&session::on_connect, this,
-                                        boost::asio::placeholders::error));
-
-    } else {
-      // TO DO:
-      std::string output = "Unable to resolve: ";
-      output += host;
-      output += "\n\r";
-      do_write(output); 
-      std::cout << "Unable to resolve?" << std::endl;
-      std::cout << "SHUTDOWN ..." << std::endl;
-      socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
-    }
-  }
-
-  void do_read(void) {
-    auto self(shared_from_this());
-
-    boost::asio::async_read( // why can't I async_read_some here?
-        socket_, boost::asio::buffer(read_buffer, sizeof(read_buffer) - 1),
-        boost::asio::transfer_at_least(1),
-        [this, self](boost::system::error_code ec, std::size_t length) {
-          if (!ec) {
-            read_buffer[length] = 0;
-            if (rlogin_auth.empty()) {
-              // first read should be rlogin information
-              rlogin_auth.assign(read_buffer, length);
-
-              // parse authentication information
-              parse_auth();
-              do_write(std::string(1, 0));
-
-              do_write("Welcome, ");
-              do_write(rlogin_name);
-              do_write("\n\r");
-
-              // Activate the connection to the server
-
-              /* // 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)); */
-
-              // 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::asio::placeholders::error,
-                              boost::asio::placeholders::iterator));
-
-            } else if (length) {
-              // std::cout << length << std::endl;
-              server_write(read_buffer);
-              std::cout << "C: " << read_buffer << std::endl;
-              // do_write(output);
-            }
-            do_read();
-          } else {
-            std::cout << "C: read_failed: connection closed" << std::endl;
-            if (connected)
-              server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
-            // server_.async_shutdown(boost::bind(&session::on_shutdown, this,
-            // boost::asio::placeholders::error));
-          }
-        });
-  }
-
-  void do_write(std::string message) {
-    auto self(shared_from_this());
-    boost::asio::async_write(
-        socket_, boost::asio::buffer(message),
-        [this, self](boost::system::error_code ec, std::size_t /*length*/) {
-          if (!ec) {
-
-          } else {
-            std::cout << "write failed? closed?" << std::endl;
-            server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
-            // server_.async_shutdown(boost::bind(&session::on_shutdown, this,
-            // boost::asio::placeholders::error));
-          }
-        });
-  }
-
-  void server_write(std::string message) {
-    auto self(shared_from_this());
-    boost::asio::async_write(
-        server_, boost::asio::buffer(message),
-        [this, self](boost::system::error_code ec, std::size_t /*length*/) {
-          if (!ec) {
-
-          } else {
-            std::cout << "write failed? closed?" << std::endl;
-            socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
-            // socket_.async_shutdown(boost::bind(&session::on_shutdown, this,
-            // boost::asio::placeholders::error));
-          }
-        });
-  }
-
-  void on_shutdown(boost::system::error_code ec) {
-    std::cout << "shutdown." << std::endl;
-  }
-
-private:
-  boost::asio::ip::tcp::socket socket_;
-  boost::asio::io_service &io_service_;
-  boost::asio::ip::tcp::resolver resolver_;
-  boost::asio::ip::tcp::socket server_;
-
-  // std::string read_buffer;
-  char read_buffer[1024];
-  char server_buffer[1024];
-
-  std::string rlogin_auth;
-  std::string rlogin_name;
-  std::string host;
-  std::string port;
-  bool connected = false;
-};
-
-/*
-maybe move the resolver part to the server, so I don't need io_service?
-
-I'm not sure what the socket connection part is going to need just yet,
-so I probably won't move that just yet.  [NNY!]
-
-*/
-
-class server {
-
-public:
-  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},
-        port_{port} {
-    do_accept();
-  }
-
-private:
-  void do_accept() {
-    acceptor_.async_accept([this](boost::system::error_code ec,
-                                  boost::asio::ip::tcp::socket socket) {
-      if (!ec) {
-        std::make_shared<session>(std::move(socket), io_service_, host_, port_)
-            ->start();
-      }
-
-      do_accept();
-    });
-  }
-  boost::asio::io_service &io_service_;
-  boost::asio::ip::tcp::acceptor acceptor_;
-  std::string host_;
-  std::string port_;
-};
+#include "session.h"
 
 int main(int argc, char *argv[]) {
   // boost::json::json_value config;