twproxy2/twproxy.cpp

//
// 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 "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}, 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.

    // 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_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_;
  boost::asio::ip::tcp::socket server_;
  
  // std::string read_buffer;
  char read_buffer[1024];
  std::string rlogin_auth;
  std::string rlogin_name;
  std::string host;
  std::string port;
};

/*
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_;
};

int main(int argc, char *argv[]) {
  // boost::json::json_value config;

  if (argc != 2) {
    std::cerr << "Usage: twproxy <filename>" << std::endl;
    return EXIT_FAILURE;
  }

  std::map<std::string, std::string> config = yaml_parse(argv[1]);

  /*
  try {
    // Parse the file as JSON
    config = yaml_parse( argv[1] );

  } catch (std::exception const &e) {
    std::cerr << "Caught exception: " << e.what() << std::endl;
    return EXIT_FAILURE;
  }
  */

  bool config_ok = true;

  for (const char *key : {"server", "host", "port"}) {
    auto pos = config.find(key);
    if (pos == config.end()) {
      config_ok = false;
      std::cout << "Config file missing: " << key << std::endl;
    }
  }
  if (!config_ok)
    return 2;

  int port = std::stoi(config["server"]);
  // 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, config["host"], config["port"]);
    //"127.0.0.1", "2023");

    io_service.run();
  } catch (std::exception &e) {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return EXIT_SUCCESS;
}