twproxy2/session.h

#ifndef SESSION_H
#define SESSION_H

#include <boost/asio.hpp>
#include <boost/asio/ip/basic_resolver.hpp>
#include <string>
#include <map>

#define MAX_BUFFER 256

/*
My ideas on how to do this.
 */

struct Request {
  int x, y;
  std::string str;
};

struct Result {
  int x;
  std::string str;
};

typedef std::function<void (const struct Result&)> ResultCallbackFunc;
typedef std::function<void (const struct Request&, ResultCallbackFunc)> CommandFunc;

// Yes, this needs to be in session.cpp (not the header)  Whoops!
// std::map<std::string, CommandFunc> commands;

// call_command("goto", Request{1, 0, ""}, my_callback );
void register_command(const std::string name, CommandFunc command);
bool call_command(const std::string name, const struct Request &param, ResultCallbackFunc callback);
// look up name, if found, call it with params, callback.  return true (success)
// otherwise fail (false).

typedef std::function<void (const std::string &)> StringFunc;

class OldState {
  StringFunc server_line;
  StringFunc server_prompt;
  StringFunc client_input;
  bool server_to_client;
  bool client_to_server;  
};

class Dispatcher {

  std::function<void (std::string)> server_line;
  std::function<void (std::string)> server_prompt;
  std::function<void (std::string)> client_input;
  bool server_to_client;
  bool client_to_server;

  OldState save_state(void);
  void restore_state(OldState);
};


/*
Dispatch Manager:


Handles:
  [ ] Does whatever we received from the server get sent to the client?
      [SHOW-CLIENT]
  [ ] Where does client input go? [CLIENT]
  [ ] Client input go directly to the server? [TALK-DIRECT]
  [ ] Where does server input go? [SERVER-LINE] [SERVER-PROMPT]

I'm thinking a dispatcher would know how to:
  [ ] Save the current state (and current dispatcher/setup).
  [ ] Set itself up with the director.
  [ ] Restore the previous state (when destructing -- but only if it is the
      current active receiver).
  [ ] Take a command [goto SECTOR][trade FOE] (fuel organics equipment),
      and return a result.  [1 SUCCESS][0 FAIL][-1 USER ABORTED]
  [ ] Tell director where results should go (callback).
  [ ] Tell director where callback messages/events should go.  (dynamic)


Director:
  [ ] Handles server lines, server prompt, client input.
  [ ] Has to_client, to_server.
  [ ] Has low-level flags for show_client, talk-direct
  [ ] Has a std::stack of dispatchers.  Uses .top() for calls.
  [ ] Reset -- would pop all but the last/master dispatchers.


It seems like the director wants to be the session, or at least parts of it.

 */

/*
The Session:

 */

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 client_read(void);
  void to_client(std::string message);
  void to_server(std::string message);
  void on_shutdown(boost::system::error_code ec);

  void dispatch_line(std::string line);
  void process_lines(std::string &received);

private:
  void set_timer(void);
  void reset_timer(void);
  void on_timer(const boost::system::error_code error);
  int time_ms;

  // FOR NOW:  These will go into the director
  bool show_client = true;
  bool talk_direct = true;

  /**
   * The client's socket
   */
  boost::asio::ip::tcp::socket socket_;
  boost::asio::io_service &io_service_;
  boost::asio::ip::tcp::resolver resolver_;
  /**
   * The server's socket
   */
  boost::asio::ip::tcp::socket server_;

  /**
   * The time that we'll use to fire off the "prompt" event.
   *
   * The idea being that we'd receive chars, processing lines.
   * And if we have something in server_prompt start the timer.
   * If we receive more, process lines, if !server_prompt.empty()
   * reset the timer.
   *
   * If the timer fires (and isn't aborted), fire off the prompt.
   *
   * I'm not so sure about this -- because this adds delay to the
   * proxy.  [It might be better to just fire off "some" text, and
   * have it ignored, rather then adding a delay.]  Or, this might
   * not matter at all, I'm thinking milliseconds here!
   */
  boost::asio::high_resolution_timer timer_;

  /**
   * What characters have been received from the server,
   * that weren't \n terminated?
   *
   * This needs to be reset/cleared if there's a \r (carriage return).
   */
  std::string server_prompt;
  /**
   * FAIL-WHALE: This was supposed to hold the number of characters
   * already sent to the user at this point in time, but I'm having
   * a hard time tracking those.
   *
   */
  int server_sent;

  /**
   * The client read buffer.
   *
   * This is too big, we don't get that many characters from the client.
   *
   */
  char read_buffer[MAX_BUFFER + 1];
  /**
   * The server read buffer.
   * This is MAX_BUFFER + 1 (to store the \0 to terminate the string)
   */
  char server_buffer[MAX_BUFFER + 1];

  /**
   * The rlogin information received from the client.
   *
   * We check this, and if it isn't valid, we spoof some rlogin
   * connection.
   */
  std::string rlogin_auth;
  /**
   * The username passed in via rlogin.  We need this so we know what
   * name we need to store the data under.
   */
  std::string rlogin_name;
  std::string host;
  std::string port;

  /**
   * Are we connected to the server?
   *
   * Don't shutdown the server socket if we aren't connected.
   */
  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);

private:
  void do_accept(void);

  boost::asio::io_service &io_service_;
  boost::asio::ip::tcp::acceptor acceptor_;
  /**
   * The host to connect to (from config)
   */
  std::string host_;
  /**
   * The port to connect to (from config)
   *
   */
  std::string port_;
};

// The simple way to get the boost logging to log file and line number
// information.
#include <iomanip>
#include <string.h>

// I don't gain anything from this being constexpr
const char *trim_path(const char *filepath);

#define BUGZ_LOG(severity)                                                     \
  BOOST_LOG_TRIVIAL(severity)                                                  \
      << "(" << std::setw(15) << trim_path(__FILE__) << ":" << std::setw(4)    \
      << std::left << __LINE__ << ") "

#endif