Channel tracking (needs mutex guard).

CMakeLists.txt

@@ -0,0 +1,61 @@
+cmake_minimum_required(VERSION 3.0)
+project(ircdoor
+  VERSION 0.1
+  LANGUAGES CXX C)
+
+###########
+# 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)
+
+set(THREADS_PREFER_PTHEAD_FLAG ON)
+
+set(BOOST_THREAD_DYN_LINK ON) # I don't think this is seen
+set(Boost_USE_STATIC_LIBS OFF)
+set(Boost_USE_MULTITHREADED ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
+find_package(Boost COMPONENTS system thread REQUIRED)
+find_package(Threads REQUIRED)
+find_package(OpenSSL REQUIRED)
+
+set(LINK_LIBS ${Boost_LIBRARIES} ${Boost_SYSTEM_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${OPENSSL_LIBRARIES})
+
+
+if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/door++)
+  message("***")
+  message("*** ERROR/MISSING *** please run: git clone https://github.com/stevet11/door.git door++")
+  message("*** (Or whatever git clone you need for door++)")
+  message("***")
+endif()
+
+add_subdirectory(door++)
+
+if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp)
+  message("***")
+  message("*** ERROR/MISSING *** please run: git clone https://github.com/jbeder/yaml-cpp.git --depth 1")
+  message("***")
+endif()
+
+add_subdirectory(yaml-cpp)
+
+add_executable(irc-door main.cpp irc.h irc.cpp)
+target_link_libraries(irc-door door++ pthread ${LINK_LIBS} dl yaml-cpp)
+

irc.cpp

@@ -0,0 +1,489 @@
+#include "irc.h"
+
+#include <boost/algorithm/string.hpp>
+#include <iostream>
+
+void string_toupper(std::string &str) {
+  std::transform(str.begin(), str.end(), str.begin(), ::toupper);
+}
+
+/**
+ * @brief remove channel modes (op,voice,hop,...)
+ *
+ * @param nick
+ */
+void remove_channel_modes(std::string &nick) {
+  // ~&@%+
+  std::string remove("~&@%+");
+  std::string::size_type pos;
+  do {
+    pos = remove.find(nick[0]);
+    if (pos != std::string::npos)
+      nick.erase(0, 1);
+  } while (pos != std::string::npos);
+}
+
+/**
+ * @brief split on spaces, with limit
+ *
+ * max is the maximum number of splits we will do.
+ * default -1 is split all.
+ *
+ * "this is a test", 3  => [this][is][a test]
+ *
+ * @param text
+ * @param max
+ * @return std::vector<std::string>
+ */
+std::vector<std::string> split_limit(std::string &text, int max) {
+  std::vector<std::string> ret;
+  int t = 0;
+  boost::split(ret, text, [&t, max](char c) {
+    if (c == ' ') {
+      ++t;
+      return ((max == -1) or (t < max));
+    };
+    return false;
+  });
+  return ret;
+}
+
+/**
+ * @brief irc split
+ *
+ * If it doesn't start with a ':', split into two parts.
+ * Otherwise 4 parts
+ * [from] [command] [to] [message]
+ *
+ * @param text
+ * @return std::vector<std::string>
+ */
+std::vector<std::string> irc_split(std::string &text) {
+  if (text[0] != ':')
+    return split_limit(text, 2);
+  return split_limit(text, 4);
+}
+
+/**
+ * @brief parse_nick
+ *
+ * Parse out the nick from nick!username@host
+ *
+ * @param name
+ * @return std::string
+ */
+std::string parse_nick(std::string &name) {
+  std::string to = name;
+  if (to[0] == ':')
+    to.erase(0, 1);
+  size_t pos = to.find('!');
+  if (pos != std::string::npos) {
+    to.erase(pos);
+  }
+  return to;
+}
+
+// namespace io = boost::asio;
+// namespace ip = io::ip;
+// using tcp = boost::asio::ip; // ip::tcp;
+
+using error_code = boost::system::error_code;
+using namespace std::placeholders;
+
+// #define DEBUG_OUTPUT
+
+typedef std::function<void(std::string &)> receiveFunction;
+
+ircClient::ircClient(boost::asio::io_context &io_context)
+    : resolver{io_context}, ssl_context{boost::asio::ssl::context::tls},
+      socket{io_context, ssl_context}, context{io_context} {
+  registered = false;
+  nick_retry = 1;
+  shutdown = false;
+  logging = false;
+}
+
+std::ofstream &ircClient::log(void) {
+  std::time_t t = std::time(nullptr);
+  std::tm tm = *std::localtime(&t);
+  debug_file << std::put_time(&tm, "%c ");
+  return debug_file;
+}
+
+void ircClient::begin(void) {
+  original_nick = nick;
+  resolver.async_resolve(hostname, port,
+                         std::bind(&ircClient::on_resolve, this, _1, _2));
+  if (!debug_output.empty()) {
+    debug_file.open(debug_output.c_str(),
+                    std::ofstream::out | std::ofstream::app);
+    logging = true;
+  }
+}
+
+void ircClient::write(std::string output) {
+  if (logging) {
+    log() << "<< " << output << std::endl;
+  }
+  error_code error;
+  socket.write_some(boost::asio::buffer(output + "\r\n"), error);
+  if (error) {
+    if (logging) {
+      log() << "Write: " << error.message() << std::endl;
+    }
+  }
+}
+
+void ircClient::buffer_append(std::vector<std::string> &data) {
+  lock.lock();
+  buffer.push_back(data);
+  lock.unlock();
+}
+
+int ircClient::buffer_size(void) {
+  lock.lock();
+  int size = buffer.size();
+  lock.unlock();
+  return size;
+}
+
+std::vector<std::string> ircClient::buffer_pop(void) {
+  lock.lock();
+  std::vector<std::string> ret = buffer.front();
+  buffer.erase(buffer.begin());
+  lock.unlock();
+  return ret;
+}
+
+boost::optional<std::vector<std::string>> ircClient::buffer_maybe_pop(void) {
+  lock.lock();
+  if (buffer.empty()) {
+    lock.unlock();
+    return boost::optional<std::vector<std::string>>{};
+  }
+  std::vector<std::string> ret = buffer.front();
+  buffer.erase(buffer.begin());
+  lock.unlock();
+  return ret;
+}
+
+void ircClient::on_resolve(
+    error_code error, boost::asio::ip::tcp::resolver::results_type results) {
+  if (logging) {
+    log() << "Resolve: " << error.message() << std::endl;
+  }
+  boost::asio::async_connect(socket.next_layer(), results,
+                             std::bind(&ircClient::on_connect, this, _1, _2));
+}
+
+void ircClient::on_connect(error_code error,
+                           boost::asio::ip::tcp::endpoint const &endpoint) {
+  if (logging) {
+    log() << "Connect: " << error.message() << ", endpoint: " << endpoint
+          << std::endl;
+  }
+  socket.async_handshake(boost::asio::ssl::stream_base::client,
+                         std::bind(&ircClient::on_handshake, this, _1));
+}
+
+void ircClient::on_handshake(error_code error) {
+  if (logging) {
+    log() << "Handshake: " << error.message() << std::endl;
+  }
+  std::string request = registration();
+  boost::asio::async_write(socket, boost::asio::buffer(request),
+                           std::bind(&ircClient::on_write, this, _1, _2));
+  // socket.async_shutdown(std::bind(&ircClient::on_shutdown, this, _1));
+}
+
+void ircClient::on_write(error_code error, std::size_t bytes_transferred) {
+  if ((error) and (logging)) {
+    log() << "Write: " << error.message() << std::endl;
+  }
+
+  // << ", bytes transferred: " << bytes_transferred << "\n";
+  boost::asio::async_read_until(
+      socket, response, '\n', std::bind(&ircClient::read_until, this, _1, _2));
+}
+
+void ircClient::on_shutdown(error_code error) {
+  if (logging) {
+    log() << "SHUTDOWN: " << error.message() << std::endl;
+  }
+  shutdown = true;
+  context.stop();
+}
+
+void ircClient::read_until(error_code error, std::size_t bytes) {
+  // std::cout << "Read: " << bytes << ", " << error << "\n";
+  // auto data = response.data();
+  if (bytes == 0) {
+    if (logging) {
+      log() << "Read 0 bytes, shutdown..." << std::endl;
+    }
+    socket.async_shutdown(std::bind(&ircClient::on_shutdown, this, _1));
+    return;
+  };
+
+  // Only try to get the data -- if we're read some bytes.
+  auto data = response.data();
+  response.consume(bytes);
+  std::string text{(const char *)data.data(), bytes};
+
+  while ((text[text.size() - 1] == '\r') or (text[text.size() - 1] == '\n'))
+    text.erase(text.size() - 1);
+
+  receive(text);
+
+  // repeat until closed
+
+  boost::asio::async_read_until(
+      socket, response, '\n', std::bind(&ircClient::read_until, this, _1, _2));
+}
+
+void ircClient::message(std::string msg) {
+  std::vector<std::string> vs;
+  vs.push_back(msg);
+  buffer_append(vs);
+}
+
+void ircClient::receive(std::string &text) {
+  std::vector<std::string> parts = irc_split(text);
+
+  if (logging) {
+    // this also shows our parser working
+    std::ofstream &l = log();
+    l << ">> ";
+    for (auto &s : parts) {
+      l << "[" << s << "] ";
+    }
+    l << std::endl;
+  }
+
+  // INTERNAL IRC PARSING/TRACKING
+
+  if (parts.size() == 2) {
+    // hide PING / PONG messages
+    if (parts[0] == "PING") {
+      std::string output = "PONG " + parts[1];
+      write(output);
+      return;
+    }
+  }
+
+  if (parts.size() >= 3) {
+    std::string source = parse_nick(parts[0]);
+    std::string cmd = parts[1];
+    std::string msg_to = parts[2];
+
+    std::string msg;
+    if (parts.size() == 4) {
+      msg = parts[3];
+    }
+
+    if (cmd == "JOIN") {
+      msg_to.erase(0, 1); // channel
+
+      if (nick == source) {
+        // yes, we are joining
+        std::string output =
+            "You have joined " + msg_to + " [talkto = " + msg_to + "]";
+        message(output);
+        talkto = msg_to;
+        // insert empty set here.
+        std::set<std::string> empty;
+        channels[msg_to] = empty;
+      } else {
+        // Someone else is joining
+        std::string output = source + " has joined " += msg_to;
+        message(output);
+        channels[msg_to].insert(source);
+      }
+    }
+
+    if (cmd == "PART") {
+      msg_to.erase(0, 1); // channel
+
+      if (nick == source) {
+        std::string output = "You left " + msg_to;
+
+        channels.erase(msg_to);
+        if (!channels.empty()) {
+          talkto = channels.begin()->first;
+          output += " [talkto = " + talkto + "]";
+        } else {
+          talkto = "";
+        }
+        message(output);
+
+      } else {
+        std::string output = source + " has left " + msg_to;
+        if (!msg.empty()) {
+          output += " " + msg;
+        }
+        message(output);
+        channels[msg_to].erase(source);
+      }
+    }
+
+    if (cmd == "353") {
+      // NAMES list for channel
+      std::vector<std::string> names_list = split_limit(msg);
+      names_list.erase(names_list.begin());
+      std::string channel = names_list.front();
+      names_list.erase(names_list.begin());
+
+      if ((names_list.size() > 0) and (names_list[0][0] == ':')) {
+        names_list[0].erase(0, 1);
+      }
+
+      if (channels.find(channel) == channels.end()) {
+        // does not exist
+        channels.insert({channel, std::set<std::string>{}});
+      }
+
+      for (auto name : names_list) {
+        remove_channel_modes(name);
+        channels[channel].insert(name);
+      }
+    }
+
+    if (cmd == "PRIVMSG") {
+      // Possibly a CTCP request.  Let's see
+      std::string message = msg;
+      if ((message[0] == ':') and (message[1] == '\x01') and
+          (message[message.size() - 1] == '\x01')) {
+        // CTCP MESSAGE FOUND  strip \x01's
+        message.erase(0, 2);
+        message.erase(message.size() - 1);
+
+        if (message == "VERSION") {
+          std::string reply_to = parse_nick(parts[0]);
+          boost::format fmt =
+              boost::format("NOTICE %1% :\x01VERSION Bugz IRC thing V0.1\x01") %
+              reply_to;
+          std::string response = fmt.str();
+          write(response);
+          return;
+        }
+
+        if (message.substr(0, 5) == "PING ") {
+          message.erase(0, 5);
+          boost::format fmt = boost::format("NOTICE %1% :\x01PING %2%\x01") %
+                              parse_nick(parts[0]) % message;
+          std::string response = fmt.str();
+          write(response);
+          return;
+        }
+
+        if (message == "TIME") {
+          auto now = std::chrono::system_clock::now();
+          auto in_time_t = std::chrono::system_clock::to_time_t(now);
+          std::string datetime = boost::lexical_cast<std::string>(
+              std::put_time(std::localtime(&in_time_t), "%c"));
+
+          boost::format fmt = boost::format("NOTICE %1% :\x01TIME %2%\x01") %
+                              parse_nick(parts[0]) % datetime;
+          std::string response = fmt.str();
+          write(response);
+          return;
+        }
+
+        if (message.substr(0, 7) == "ACTION ") {
+          message.erase(0, 7);
+          parts[1] = "ACTION"; // change PRIVMSG to ACTION
+          parts[3] = message;
+        } else {
+          // Removed the : and leading/trailing \x01
+          std::string msg = "CTCP " + message + " from " + parse_nick(parts[0]);
+          this->message(msg);
+          if (logging) {
+            log() << "CTCP : [" << message << "]" << std::endl;
+          }
+        };
+
+        // I have this parsed this far, now what can I do with it?!
+      }
+    }
+  }
+
+  /*
+    if (parts[1] == "JOIN") {
+      // Are we joining?
+      std::string guest = parse_nick(parts[0]);
+      if (guest == nick) {
+        // yes, it is us!
+        std::string temp = parts[2];
+        temp.erase(0, 1);
+        talkto = temp;
+        std::string msg = "You have joined " + temp;
+        message(msg);
+      } else {
+        std::string temp = parts[2];
+        temp.erase(0, 1);
+        std::string msg = parse_nick(parts[0]) + " has joined " + temp;
+        message(msg);
+      }
+    }
+  */
+
+  // CTCP handler
+  // NOTE:  When sent to a channel, the response is sent to the sender.
+
+  if (!registered) {
+    // We're not registered yet
+    if (parts[1] == "433") {
+      // nick collision!  Nick already in use
+      if (nick == original_nick) {
+        // try something basic
+        nick += "_";
+        std::string output = "NICK " + nick;
+        write(output);
+        return;
+      } else {
+        // Ok, go advanced
+        nick = original_nick + "_" + std::to_string(nick_retry);
+        ++nick_retry;
+        std::string output = "NICK " + nick;
+        write(output);
+        return;
+      }
+    }
+
+    /*
+        if (parts[1] == "372") {
+          // MOTD
+          std::string msg = parts[3];
+          msg.erase(0, 1);
+          motd.push_back(msg);
+        }
+    */
+
+    if ((parts[1] == "376") or (parts[1] == "422")) {
+      // END MOTD, or MOTD MISSING
+      registered = true;
+      if (!autojoin.empty()) {
+        std::string msg = "JOIN " + autojoin;
+        write(msg);
+      }
+    }
+  }
+
+  if (parts[0] == "ERROR") {
+    // we're outta here.  :O
+    // std::cout << "BANG!" << std::endl;
+  }
+
+  buffer_append(parts);
+
+  // :FROM command TO :rest and ':' is optional
+
+  // std::cout << text << "\n";
+}
+
+std::string ircClient::registration(void) {
+  std::string text;
+  text = "NICK " + nick + "\r\n" + "USER " + username + " 0 * :" + realname +
+         "\r\n";
+  return text;
+}

irc.h

@@ -0,0 +1,110 @@
+#ifndef IRC_H
+#define IRC_H
+#include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
+
+#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/optional.hpp>
+#include <boost/signals2/mutex.hpp>
+#include <chrono>
+#include <iomanip> // put_time
+#include <string>
+// #include <vector>
+#include <algorithm>
+#include <fstream>
+#include <set>
+
+void string_toupper(std::string &str);
+
+std::vector<std::string> split_limit(std::string &text, int max = -1);
+std::vector<std::string> irc_split(std::string &text);
+std::string parse_nick(std::string &name);
+void remove_channel_modes(std::string &nick);
+
+// using error_code = boost::system::error_code;
+
+class ircClient {
+  using error_code = boost::system::error_code;
+
+public:
+  ircClient(boost::asio::io_context &io_context);
+
+  // async startup
+  void begin(void);
+
+  // thread-safe write to IRC
+  void write(std::string output);
+
+  // configuration
+  std::string hostname;
+  std::string port;
+  std::string nick;
+  std::string username = "bzbz";
+  std::string realname;
+  std::string autojoin;
+
+  // filename to use for logfile
+  std::string debug_output;
+  std::ofstream debug_file;
+
+  std::string talkto;
+
+  // channels / users
+  std::map<std::string, std::set<std::string>> channels;
+
+  /*
+    std::set<std::string> channels;
+    std::set<std::string> users;
+      std::vector<std::string> motd;
+  */
+
+  // thread-safe buffer access
+  void buffer_append(std::vector<std::string> &data);
+  int buffer_size(void);
+  std::vector<std::string> buffer_pop(void);
+  boost::optional<std::vector<std::string>> buffer_maybe_pop(void);
+  void message(std::string msg);
+  std::atomic<bool> shutdown;
+
+private:
+  boost::signals2::mutex lock;
+  std::vector<std::vector<std::string>> buffer;
+
+  bool registered;
+  std::string original_nick;
+  int nick_retry;
+
+  bool logging;
+  std::ofstream &log(void);
+
+  // async callbacks
+  void on_resolve(error_code error,
+                  boost::asio::ip::tcp::resolver::results_type results);
+  void on_connect(error_code error,
+                  boost::asio::ip::tcp::endpoint const &endpoint);
+
+  void on_handshake(error_code error);
+  void on_write(error_code error, std::size_t bytes_transferred);
+  void read_until(error_code error, std::size_t bytes);
+  void on_shutdown(error_code error);
+  // end async callback
+
+  void receive(std::string &text);
+
+  std::string registration(void);
+
+  // initialization order matters for socket, ssl_context!
+  //
+  // socket up here causes segmentation fault!
+  // boost::asio::ssl::stream<ip::tcp::socket> socket;
+
+  boost::asio::ip::tcp::resolver resolver;
+  boost::asio::ssl::context ssl_context;
+  boost::asio::streambuf response;
+  boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket;
+
+  boost::asio::io_context &context;
+};
+
+#endif

main.cpp

@@ -0,0 +1,214 @@
+
+#include <chrono>
+#include <iostream>
+#include <string>
+#include <thread> // sleep_for
+
+#include "door.h"
+#include "irc.h"
+#include "yaml-cpp/yaml.h"
+
+#include <boost/asio.hpp>
+// #include <boost/thread.hpp>
+
+YAML::Node config;
+std::function<std::ofstream &(void)> get_logger;
+
+bool file_exists(const std::string name) {
+  std::ifstream f(name.c_str());
+  return f.good();
+}
+
+int main(int argc, char *argv[]) {
+  using namespace std::chrono_literals;
+
+  boost::asio::io_context io_context;
+  ircClient irc(io_context);
+
+  door::Door door("irc-door", argc, argv);
+  get_logger = [&door]() -> ofstream & { return door.log(); };
+
+  if (file_exists("irc-door.yaml")) {
+    config = YAML::LoadFile("irc-door.yaml");
+  }
+
+  bool update_config = false;
+
+  if (!config["hostname"]) {
+    config["hostname"] = "127.0.0.1";
+    update_config = true;
+  }
+
+  if (!config["port"]) {
+    config["port"] = "6697";
+    update_config = true;
+  }
+
+  if (!config["autojoin"]) {
+    config["autojoin"] = "#bugz";
+    update_config = true;
+  }
+
+  if (!config["realname"]) {
+    config["realname"] = "A poor soul on BZBZ BBS...";
+    update_config = true;
+  }
+
+  if (!config["username"]) {
+    config["username"] = "bzbz";
+    update_config = true;
+  }
+
+  if (update_config) {
+    std::ofstream fout("irc-door.yaml");
+    fout << config << std::endl;
+  }
+
+  // configure
+  irc.nick = door.handle;
+  irc.realname = config["realname"].as<std::string>();
+  irc.hostname = config["hostname"].as<std::string>();
+  irc.port = config["port"].as<std::string>();
+  irc.username = config["username"].as<std::string>();
+  irc.autojoin = config["autojoin"].as<std::string>();
+
+  irc.debug_output = "irc.log";
+
+  irc.begin(); // start the initial request so io_context has work to do
+  // boost::thread thread(boost::bind(&boost::asio::io_service::run,
+  // &io_context));
+  // thread Thread(boost::bind(&boost::asio::io_service::run, &io_context));
+  thread Thread([&io_context]() -> void { io_context.run(); });
+
+  door << "Welcome to the IRC chat door." << door::nl;
+
+  // main "loop" -- not the proper way to do it.
+  bool in_door = true;
+  while (in_door) {
+    if (door.haskey()) {
+      door << ">> ";
+      std::string input = door.input_string(100);
+      door << door::nl;
+      if (!input.empty()) {
+        if (input == "/q") {
+          irc.write("QUIT :What other doors on BZ&BZ BBS work...");
+          in_door = false;
+        }
+        if (input[0] == '/') {
+          input.erase(0, 1);
+          irc.write(input);
+        } else {
+          if (irc.talkto.empty()) {
+            door << " talkto is empty?  Whaat?" << door::nl;
+          } else {
+            std::string output = "PRIVMSG " + irc.talkto + " :" + input;
+            irc.write(output);
+          }
+        }
+      }
+    }
+
+    boost::optional<std::vector<std::string>> msg;
+
+    // hold list of users -- until end names received.
+    // std::vector<std::string> names;
+
+    do {
+      msg = irc.buffer_maybe_pop();
+      if (msg) {
+        std::vector<std::string> m = *msg;
+
+        if (m.size() == 1) {
+          // system message
+          door << "(" << m[0] << ")" << door::nl;
+          continue;
+        }
+
+        std::string cmd = m[1];
+
+        /* this should be tracked by ircClient class
+        if (cmd == "353") {
+          // NAMES list for channel, parse them out and append to names.
+          std::vector<std::string> names_list = split_limit(m[3], 999);
+          names_list.erase(names_list.begin());
+          names_list.erase(names_list.begin());
+          for (auto &name : names_list) {
+            if (name[0] == ':')
+              name.erase(0, 1);
+            names.push_back(name);
+          }
+        }
+        */
+        if (cmd == "366") {
+          // end of names, output and clear
+          std::string channel = split_limit(m[3], 2)[0];
+
+          door << "* users on " << channel << " : ";
+          for (auto name : irc.channels[channel]) {
+            door << name << " ";
+          }
+          door << door::nl;
+          // names.clear();
+        }
+
+        // 400 and 500 are errors?  should show those.
+        if ((cmd[0] == '4') or (cmd[0] == '5')) {
+          std::string tmp = m[3];
+          tmp.erase(0, 1);
+
+          door << "* " << tmp << door::nl;
+        }
+
+        if (cmd == "NOTICE") {
+          std::string tmp = m[3];
+          tmp.erase(0, 1);
+
+          door << parse_nick(m[0]) << " NOTICE " << tmp << door::nl;
+        }
+
+        if (cmd == "ACTION") {
+          if (m[2][0] == '#') {
+            door << "* " << parse_nick(m[0]) << "/" << m[2] << " " << m[3]
+                 << door::nl;
+          } else {
+            door << "* " << parse_nick(m[0]) << " " << m[3] << door::nl;
+          }
+        }
+
+        if (cmd == "TOPIC") {
+          std::string tmp = m[3];
+          tmp.erase(0, 1);
+
+          door << parse_nick(m[0]) << " set topic of " << m[2] << " to " << tmp
+               << door::nl;
+        }
+
+        if (cmd == "PRIVMSG") {
+          if (m[2][0] == '#') {
+            std::string tmp = m[3];
+            tmp.erase(0, 1);
+
+            door << parse_nick(m[0]) << "/" << m[2] << " " << tmp << door::nl;
+          } else {
+            std::string tmp = m[3];
+            tmp.erase(0, 1);
+
+            door << parse_nick(m[0]) << " " << tmp << door::nl;
+          }
+        }
+      }
+    } while (msg);
+
+    std::this_thread::sleep_for(200ms);
+    if (irc.shutdown)
+      in_door = false;
+  }
+
+  io_context.stop();
+  Thread.join();
+
+  door << "Returning to the BBS..." << door::nl;
+
+  // std::this_thread::sleep_for(2s);
+  return 0;
+}