Initial setup.

This listens to a port.
When you connect (it expects rlogin),
it kicks off an async_resolve to the host/port.

This is getting an answer back.  (Finally!)
Not sure why std::bind fails, and boost::bind works...

Next step:  Initiate a connection to the resolved address.
(And display a message.)

CMakeLists.txt

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.0)
+project(ex1
+  VERSION 0.1
+  LANGUAGES CXX)
+
+###########
+# Debug or Release
+###########
+if (NOT CMAKE_BUILD_TYPE)
+  ## set default to Debug
+  set(CMAKE_BUILD_TYPE RelWithDebInfo)  # override with -DCMAKE_BUILD_TYPE=Release
+  message("==> CMAKE_BUILD_TYPE empty. Changing it to Debug.")
+else()
+  message("==> CMAKE_BUILD_TYPE == ${CMAKE_BUILD_TYPE}.")
+endif()
+
+## https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html
+## During Debug, use debug version of libstdc++ (asserts on access to invalid iterators, etc!)
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+
+##############
+# C++ Standard
+##############
+set(CMAKE_CXX_STANDARD   14)
+# set(CMAKE_CXX_STANDARD   17)
+set(CMAKE_CXX_EXTENSIONS ON)
+
+
+FIND_PACKAGE( Boost 1.60 COMPONENTS program_options REQUIRED )
+INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIR} )
+
+ADD_EXECUTABLE( twproxy twproxy.cpp)
+TARGET_LINK_LIBRARIES( twproxy ${Boost_LIBRARIES} pthread )
+

twproxy.cpp

@@ -0,0 +1,245 @@
+//
+// client.cpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/asio.hpp>
+#include <boost/asio/ip/basic_resolver.hpp>
+#include <boost/bind.hpp>
+#include <cstdlib>
+#include <iostream>
+
+// #include <boost/json.hpp>
+// #include <boost/json/src.hpp>
+
+// <boost/json.hpp>
+#ifdef WORKING_JSON
+json::value parse_file(char const *filename) {
+  file f(filename, "r");
+  json::stream_parser p;
+  json::error_code ec;
+  do {
+    char buf[4096];
+    auto const nread = f.read(buf, sizeof(buf));
+    p.write(buf, nread, ec);
+  } while (!f.eof());
+  if (ec)
+    return nullptr;
+  p.finish(ec);
+  if (ec)
+    return nullptr;
+  return p.release();
+}
+#endif
+
+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}, 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" << 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.
+    if (rlogin_auth.size() > 10)
+      rlogin_name = rlogin_auth.c_str() + 1;
+    else
+      rlogin_name = "?";
+  }
+
+  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) {
+      for (boost::asio::ip::tcp::endpoint const &endpoint : results) {
+        std::cout << "GOT: " <<  endpoint << "\n";
+      }
+    } else {
+      std::cout << "Unable to resolve?" << std::endl;
+    }
+  }
+
+  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 works!
+              /*
+              boost::system::error_code ec;
+              boost::asio::ip::tcp::resolver::results_type results =
+                  self->resolver_.resolve("google.com", "80", ec);
+
+              for (boost::asio::ip::tcp::endpoint const &endpoint : results) {
+                std::cout << endpoint << "\n";
+              }
+*/
+              // resolver_.async_resolve(host, port, on_resolve);
+
+              // This works, but I can't std::bind to a callback?
+
+              /*
+                            resolver_.async_resolve(
+                                host, port,
+                                [&](boost::system::error_code ec,
+                                    boost::asio::ip::tcp::resolver::results_type
+                 results) { if (!ec) { for (const boost::asio::ip::tcp::endpoint
+                 &endpoint : results) { std::cout << endpoint << "\n";
+                                    }
+                                  } else {
+                                    std::cerr << "Something went wrong";
+                                  }
+                                });
+              */
+              /*
+                            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;
+              std::cout << read_buffer << std::endl;
+              std::string output = "Got [";
+              output += read_buffer;
+              output += "]\n";
+              do_write(output);
+            }
+            do_read();
+          } else {
+            std::cout << "read_failed: connection closed" << std::endl;
+          }
+        });
+  }
+
+  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;
+          }
+        });
+  }
+
+private:
+  boost::asio::ip::tcp::socket socket_;
+  boost::asio::io_service &io_service_;
+  boost::asio::ip::tcp::resolver resolver_;
+
+  // std::string read_buffer;
+  char read_buffer[1024];
+  std::string rlogin_auth;
+  std::string rlogin_name;
+  std::string host;
+  std::string port;
+};
+
+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_;
+};
+
+int main(int argc, char *argv[]) {
+  // boost::json::json_value config;
+
+  if (argc != 2) {
+    std::cerr << "Usage: twproxy <filename>" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  try {
+    // Parse the file as JSON
+    // config = parse_file( argv[1] );
+
+  } catch (std::exception const &e) {
+    std::cerr << "Caught exception: " << e.what() << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  int port = 9999; // 2002;
+
+  try {
+
+    boost::asio::io_service io_service;
+
+    boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(),
+                                            port); // std::atoi(argv[i]));
+    // connect to the BBS
+    server s(io_service, endpoint, "127.0.0.1", "2023");
+
+    io_service.run();
+  } catch (std::exception &e) {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return EXIT_SUCCESS;
+}