New upstream version 3.0upstream/3.0

25 files changed, 5259 insertions, 0 deletions

diff --git a/src/bridge/bridge.cpp b/src/bridge/bridge.cpp
new file mode 100644
index 0000000..17d3ec6
--- /dev/null
+++ b/src/bridge/bridge.cpp
@@ -0,0 +1,907 @@
+#include <bridge/bridge.hpp>
+#include <bridge/list_element.hpp>
+#include <xmpp/biboumi_component.hpp>
+#include <network/poller.hpp>
+#include <utils/empty_if_fixed_server.hpp>
+#include <utils/encoding.hpp>
+#include <utils/tolower.hpp>
+#include <logger/logger.hpp>
+#include <utils/revstr.hpp>
+#include <utils/split.hpp>
+#include <xmpp/jid.hpp>
+#include <database/database.hpp>
+
+using namespace std::string_literals;
+
+static const char* action_prefix = "\01ACTION ";
+
+
+static std::string in_encoding_for(const Bridge& bridge, const Iid& iid)
+{
+#ifdef USE_DATABASE
+  const auto jid = bridge.get_bare_jid();
+  auto options = Database::get_irc_channel_options_with_server_default(jid, iid.get_server(), iid.get_local());
+  return options.encodingIn.value();
+#else
+  return {"ISO-8859-1"};
+#endif
+}
+
+Bridge::Bridge(const std::string& user_jid, BiboumiComponent& xmpp, std::shared_ptr<Poller> poller):
+  user_jid(user_jid),
+  xmpp(xmpp),
+  poller(poller)
+{
+}
+
+/**
+ * Return the role and affiliation, corresponding to the given irc mode
+ */
+static std::tuple<std::string, std::string> get_role_affiliation_from_irc_mode(const char mode)
+{
+  if (mode == 'a' || mode == 'q'){
+    return std::make_tuple("moderator", "owner");}
+  else if (mode == 'o')
+    return std::make_tuple("moderator", "admin");
+  else if (mode == 'h')
+    return std::make_tuple("moderator", "member");
+  else if (mode == 'v')
+    return std::make_tuple("participant", "member");
+  else
+    return std::make_tuple("participant", "none");
+}
+
+void Bridge::shutdown(const std::string& exit_message)
+{
+  for (auto it = this->irc_clients.begin(); it != this->irc_clients.end(); ++it)
+  {
+    it->second->send_quit_command(exit_message);
+    it->second->leave_dummy_channel(exit_message);
+  }
+}
+
+void Bridge::clean()
+{
+  auto it = this->irc_clients.begin();
+  while (it != this->irc_clients.end())
+  {
+    IrcClient* client = it->second.get();
+    if (!client->is_connected() && !client->is_connecting() &&
+        !client->get_resolver().is_resolving())
+      it = this->irc_clients.erase(it);
+    else
+      ++it;
+  }
+}
+
+const std::string& Bridge::get_jid() const
+{
+  return this->user_jid;
+}
+
+std::string Bridge::get_bare_jid() const
+{
+  Jid jid(this->user_jid);
+  return jid.local + "@" + jid.domain;
+}
+
+Xmpp::body Bridge::make_xmpp_body(const std::string& str, const std::string& encoding)
+{
+  std::string res;
+  if (utils::is_valid_utf8(str.c_str()))
+    res = str;
+  else
+    res = utils::convert_to_utf8(str, encoding.data());
+  return irc_format_to_xhtmlim(res);
+}
+
+IrcClient* Bridge::make_irc_client(const std::string& hostname, const std::string& nickname)
+{
+  try
+    {
+      return this->irc_clients.at(hostname).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      auto username = nickname;
+      auto realname = nickname;
+      Jid jid(this->user_jid);
+      if (Config::get("realname_from_jid", "false") == "true")
+        {
+          username = jid.local;
+          realname = this->get_bare_jid();
+        }
+      this->irc_clients.emplace(hostname,
+                                std::make_shared<IrcClient>(this->poller, hostname,
+                                                            nickname, username,
+                                                            realname, jid.domain,
+                                                            *this));
+      std::shared_ptr<IrcClient> irc = this->irc_clients.at(hostname);
+      return irc.get();
+    }
+}
+
+IrcClient* Bridge::get_irc_client(const std::string& hostname)
+{
+  try
+    {
+      return this->irc_clients.at(hostname).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      throw IRCNotConnected(hostname);
+    }
+}
+
+IrcClient* Bridge::find_irc_client(const std::string& hostname)
+{
+  try
+    {
+      return this->irc_clients.at(hostname).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      return nullptr;
+    }
+}
+
+bool Bridge::join_irc_channel(const Iid& iid, const std::string& nickname, const std::string& password,
+                              const std::string& resource)
+{
+  const auto hostname = iid.get_server();
+  IrcClient* irc = this->make_irc_client(hostname, nickname);
+  this->add_resource_to_server(hostname, resource);
+  auto res_in_chan = this->is_resource_in_chan(ChannelKey{iid.get_local(), hostname}, resource);
+  if (!res_in_chan)
+    this->add_resource_to_chan(ChannelKey{iid.get_local(), hostname}, resource);
+  if (iid.get_local().empty())
+    { // Join the dummy channel
+      if (irc->is_welcomed())
+        {
+          if (irc->get_dummy_channel().joined)
+            return false;
+          // Immediately simulate a message coming from the IRC server saying that we
+          // joined the channel
+          const IrcMessage join_message(irc->get_nick(), "JOIN", {""});
+          irc->on_channel_join(join_message);
+          const IrcMessage end_join_message(std::string(iid.get_server()), "366",
+                                            {irc->get_nick(),
+                                                "", "End of NAMES list"});
+          irc->on_channel_completely_joined(end_join_message);
+        }
+      else
+        {
+          irc->get_dummy_channel().joining = true;
+          irc->start();
+        }
+      return true;
+    }
+  if (irc->is_channel_joined(iid.get_local()) == false)
+    {
+      irc->send_join_command(iid.get_local(), password);
+      return true;
+    } else if (!res_in_chan) {
+      this->generate_channel_join_for_resource(iid, resource);
+    }
+  return false;
+}
+
+void Bridge::send_channel_message(const Iid& iid, const std::string& body)
+{
+  if (iid.get_server().empty())
+    {
+      for (const auto& resource: this->resources_in_chan[iid.to_tuple()])
+        this->xmpp.send_stanza_error("message", this->user_jid + "/" + resource, std::to_string(iid), "",
+                                     "cancel", "remote-server-not-found",
+                                     std::to_string(iid) + " is not a valid channel name. "
+                                         "A correct room jid is of the form: #<chan>%<server>",
+                                     false);
+      return;
+    }
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+
+  // Because an IRC message cannot contain \n, we need to convert each line
+  // of text into a separate IRC message. For conveniance, we also cut the
+  // message into submessages on the XMPP side, this way the user of the
+  // gateway sees what was actually sent over IRC.  For example if an user
+  // sends “hello\n/me waves”, two messages will be generated: “hello” and
+  // “/me waves”. Note that the “command” handling (messages starting with
+  // /me, /mode, etc) is done for each message generated this way. In the
+  // above example, the /me will be interpreted.
+  std::vector<std::string> lines = utils::split(body, '\n', true);
+  if (lines.empty())
+    return ;
+  for (const std::string& line: lines)
+    {
+      if (line.substr(0, 5) == "/mode")
+        {
+          std::vector<std::string> args = utils::split(line.substr(5), ' ', false);
+          irc->send_mode_command(iid.get_local(), args);
+          continue;             // We do not want to send that back to the
+                                // XMPP user, that’s not a textual message.
+        }
+      else if (line.substr(0, 4) == "/me ")
+        irc->send_channel_message(iid.get_local(), action_prefix + line.substr(4) + "\01");
+      else
+        irc->send_channel_message(iid.get_local(), line);
+      for (const auto& resource: this->resources_in_chan[iid.to_tuple()])
+        this->xmpp.send_muc_message(std::to_string(iid), irc->get_own_nick(),
+                                    this->make_xmpp_body(line), this->user_jid + "/" + resource);
+    }
+}
+
+void Bridge::forward_affiliation_role_change(const Iid& iid, const std::string& nick,
+                                             const std::string& affiliation,
+                                             const std::string& role)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+  IrcChannel* chan = irc->get_channel(iid.get_local());
+  if (!chan || !chan->joined)
+    return;
+  IrcUser* user = chan->find_user(nick);
+  if (!user)
+    return;
+  // For each affiliation or role, we have a “maximal” mode that we want to
+  // set. We must remove any superior mode at the same time. For example if
+  // the user already has +o mode, and we set its affiliation to member, we
+  // remove the +o mode, and add +v.  For each “superior” mode (for example,
+  // for +v, the superior modes are 'h', 'a', 'o' and 'q') we check if that
+  // user has it, and if yes we remove that mode
+
+  std::size_t nb = 1;               // the number of times the nick must be
+                                    // repeated in the argument list
+  std::string modes;                // The string of modes to
+                                    // add/remove. For example "+v-aoh"
+  std::vector<char> modes_to_remove; // List of modes to check for removal
+  if (affiliation == "none")
+    {
+      modes = "";
+      nb = 0;
+      modes_to_remove = {'v', 'h', 'o', 'a', 'q'};
+    }
+  else if (affiliation == "member")
+    {
+      modes = "+v";
+      modes_to_remove = {'h', 'o', 'a', 'q'};
+    }
+  else if (role == "moderator")
+    {
+      modes = "+h";
+      modes_to_remove = {'o', 'a', 'q'};
+    }
+  else if (affiliation == "admin")
+    {
+      modes = "+o";
+      modes_to_remove = {'a', 'q'};
+    }
+  else if (affiliation == "owner")
+    {
+      modes = "+a";
+      modes_to_remove = {'q'};
+    }
+  else
+    return;
+  for (const char mode: modes_to_remove)
+    if (user->modes.find(mode) != user->modes.end())
+      {
+        modes += "-"s + mode;
+        nb++;
+      }
+  if (modes.empty())
+    return;
+  std::vector<std::string> args(nb, nick);
+  args.insert(args.begin(), modes);
+  irc->send_mode_command(iid.get_local(), args);
+}
+
+void Bridge::send_private_message(const Iid& iid, const std::string& body, const std::string& type)
+{
+  if (iid.get_local().empty() || iid.get_server().empty())
+    {
+      this->xmpp.send_stanza_error("message", this->user_jid, std::to_string(iid), "",
+                                    "cancel", "remote-server-not-found",
+                                    std::to_string(iid) + " is not a valid channel name. "
+                                    "A correct room jid is of the form: #<chan>%<server>",
+                                    false);
+      return;
+    }
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+  std::vector<std::string> lines = utils::split(body, '\n', true);
+  if (lines.empty())
+    return ;
+  for (const std::string& line: lines)
+    {
+      if (line.substr(0, 4) == "/me ")
+        irc->send_private_message(iid.get_local(), action_prefix + line.substr(4) + "\01", type);
+      else
+        irc->send_private_message(iid.get_local(), line, type);
+    }
+}
+
+void Bridge::send_raw_message(const std::string& hostname, const std::string& body)
+{
+  IrcClient* irc = this->get_irc_client(hostname);
+  irc->send_raw(body);
+}
+
+void Bridge::leave_irc_channel(Iid&& iid, std::string&& status_message, const std::string& resource)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+  const auto key = iid.to_tuple();
+  if (!this->is_resource_in_chan(key, resource))
+    return ;
+
+  const auto resources = this->number_of_resources_in_chan(key);
+  if (resources == 1)
+    {
+      irc->send_part_command(iid.get_local(), status_message);
+      // Since there are no resources left in that channel, we don't
+      // want to receive private messages using this room's JID
+      this->remove_all_preferred_from_jid_of_room(iid.get_local());
+    }
+  else
+    {
+      IrcChannel* chan = irc->get_channel(iid.get_local());
+      if (chan)
+        {
+          auto nick = chan->get_self()->nick;
+          this->remove_resource_from_chan(key, resource);
+          this->send_muc_leave(std::move(iid), std::move(nick),
+                               "Biboumi note: "s + std::to_string(resources - 1) + " resources are still in this channel.",
+          true, resource);
+          if (this->number_of_channels_the_resource_is_in(iid.get_server(), resource) == 0)
+            this->remove_resource_from_server(iid.get_server(), resource);
+        }
+    }
+}
+
+void Bridge::send_irc_nick_change(const Iid& iid, const std::string& new_nick)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+  irc->send_nick_command(new_nick);
+}
+
+void Bridge::send_irc_channel_list_request(const Iid& iid, const std::string& iq_id,
+                                           const std::string& to_jid)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+
+  irc->send_list_command();
+
+  std::vector<ListElement> list;
+
+  irc_responder_callback_t cb = [this, iid, iq_id, to_jid, list=std::move(list)](const std::string& irc_hostname,
+                                                           const IrcMessage& message) mutable -> bool
+    {
+      if (irc_hostname != iid.get_server())
+        return false;
+      if (message.command == "263" || message.command == "RPL_TRYAGAIN" ||
+          message.command == "ERR_TOOMANYMATCHES" || message.command == "ERR_NOSUCHSERVER")
+        {
+          std::string text;
+          if (message.arguments.size() >= 2)
+            text = message.arguments[1];
+          this->xmpp.send_stanza_error("iq", to_jid, std::to_string(iid), iq_id,
+                                        "wait", "service-unavailable", text, false);
+          return true;
+        }
+      else if (message.command == "322" || message.command == "RPL_LIST")
+        { // Add element to list
+          if (message.arguments.size() == 4)
+            list.emplace_back(message.arguments[1], message.arguments[2],
+                              message.arguments[3]);
+          return false;
+        }
+      else if (message.command == "323" || message.command == "RPL_LISTEND")
+        { // Send the iq response with the content of the list
+          this->xmpp.send_iq_room_list_result(iq_id, to_jid, std::to_string(iid), list);
+          return true;
+        }
+      return false;
+    };
+  this->add_waiting_irc(std::move(cb));
+}
+
+void Bridge::send_irc_kick(const Iid& iid, const std::string& target, const std::string& reason,
+                           const std::string& iq_id, const std::string& to_jid)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+
+  irc->send_kick_command(iid.get_local(), target, reason);
+  irc_responder_callback_t cb = [this, target, iq_id, to_jid, iid](const std::string& irc_hostname,
+                                                                   const IrcMessage& message) -> bool
+    {
+      if (irc_hostname != iid.get_server())
+        return false;
+      if (message.command == "KICK" && message.arguments.size() >= 2)
+        {
+          const std::string target_later = message.arguments[1];
+          const std::string chan_name_later = utils::tolower(message.arguments[0]);
+          if (target_later != target || chan_name_later != iid.get_local())
+            return false;
+          this->xmpp.send_iq_result(iq_id, to_jid, std::to_string(iid));
+        }
+      else if (message.command == "401" && message.arguments.size() >= 2)
+        {
+          const std::string target_later = message.arguments[1];
+          if (target_later != target)
+            return false;
+          std::string error_message = "No such nick";
+          if (message.arguments.size() >= 3)
+            error_message = message.arguments[2];
+          this->xmpp.send_stanza_error("iq", to_jid, std::to_string(iid), iq_id, "cancel", "item-not-found",
+                                        error_message, false);
+        }
+      else if (message.command == "482" && message.arguments.size() >= 2)
+        {
+          const std::string chan_name_later = utils::tolower(message.arguments[1]);
+          if (chan_name_later != iid.get_local())
+            return false;
+          std::string error_message = "You're not channel operator";
+          if (message.arguments.size() >= 3)
+            error_message = message.arguments[2];
+          this->xmpp.send_stanza_error("iq", to_jid, std::to_string(iid), iq_id, "cancel", "not-allowed",
+                                        error_message, false);
+        }
+      return true;
+    };
+  this->add_waiting_irc(std::move(cb));
+}
+
+void Bridge::set_channel_topic(const Iid& iid, const std::string& subject)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+  irc->send_topic_command(iid.get_local(), subject);
+}
+
+void Bridge::send_xmpp_version_to_irc(const Iid& iid, const std::string& name, const std::string& version, const std::string& os)
+{
+  std::string result(name + " " + version + " " + os);
+
+  this->send_private_message(iid, "\01VERSION "s + result + "\01", "NOTICE");
+}
+
+void Bridge::send_irc_ping_result(const Iid& iid, const std::string& id)
+{
+  this->send_private_message(iid, "\01PING "s + utils::revstr(id) + "\01", "NOTICE");
+}
+
+void Bridge::send_irc_user_ping_request(const std::string& irc_hostname, const std::string& nick,
+                                        const std::string& iq_id, const std::string& to_jid,
+                                        const std::string& from_jid)
+{
+  Iid iid(nick + "!" + irc_hostname);
+  this->send_private_message(iid, "\01PING " + iq_id + "\01");
+
+  irc_responder_callback_t cb = [this, nick=utils::tolower(nick), iq_id, to_jid, irc_hostname, from_jid](const std::string& hostname, const IrcMessage& message) -> bool
+    {
+      if (irc_hostname != hostname || message.arguments.size() < 2)
+        return false;
+      IrcUser user(message.prefix);
+      const std::string body = message.arguments[1];
+      if (message.command == "NOTICE" && utils::tolower(user.nick) == nick
+          && body.substr(0, 6) == "\01PING ")
+        {
+          const std::string id = body.substr(6, body.size() - 7);
+          if (id != iq_id)
+            return false;
+          this->xmpp.send_iq_result_full_jid(iq_id, to_jid, from_jid);
+          return true;
+        }
+      if (message.command == "401" && message.arguments[1] == nick)
+        {
+          std::string error_message = "No such nick";
+          if (message.arguments.size() >= 3)
+            error_message = message.arguments[2];
+          this->xmpp.send_stanza_error("iq", to_jid, from_jid, iq_id, "cancel", "service-unavailable",
+                                        error_message, true);
+          return true;
+        }
+
+      return false;
+    };
+  this->add_waiting_irc(std::move(cb));
+}
+
+void Bridge::send_irc_participant_ping_request(const Iid& iid, const std::string& nick,
+                                               const std::string& iq_id, const std::string& to_jid,
+                                               const std::string& from_jid)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+  IrcChannel* chan = irc->get_channel(iid.get_local());
+  if (!chan->joined)
+    {
+      this->xmpp.send_stanza_error("iq", to_jid, from_jid, iq_id, "cancel", "not-allowed",
+                                    "", true);
+      return;
+    }
+  if (chan->get_self()->nick != nick && !chan->find_user(nick))
+    {
+      this->xmpp.send_stanza_error("iq", to_jid, from_jid, iq_id, "cancel", "item-not-found",
+                                    "Recipient not in room", true);
+      return;
+    }
+
+  // The user is in the room, send it a direct PING
+  this->send_irc_user_ping_request(iid.get_server(), nick, iq_id, to_jid, from_jid);
+}
+
+void Bridge::on_gateway_ping(const std::string& irc_hostname, const std::string& iq_id, const std::string& to_jid,
+                             const std::string& from_jid)
+{
+  Jid jid(from_jid);
+  if (irc_hostname.empty() || this->find_irc_client(irc_hostname))
+    this->xmpp.send_iq_result(iq_id, to_jid, jid.local);
+  else
+    this->xmpp.send_stanza_error("iq", to_jid, from_jid, iq_id, "cancel", "service-unavailable",
+                                  "", true);
+}
+
+void Bridge::send_irc_version_request(const std::string& irc_hostname, const std::string& target,
+                                      const std::string& iq_id, const std::string& to_jid,
+                                      const std::string& from_jid)
+{
+  Iid iid(target + "!" + irc_hostname);
+  this->send_private_message(iid, "\01VERSION\01");
+  // TODO, add a timer to remove that waiting iq if the server does not
+  // respond with a matching command before n seconds
+  irc_responder_callback_t cb = [this, target, iq_id, to_jid, irc_hostname, from_jid](const std::string& hostname, const IrcMessage& message) -> bool
+    {
+      if (irc_hostname != hostname)
+        return false;
+      IrcUser user(message.prefix);
+      if (message.command == "NOTICE" && user.nick == target &&
+          message.arguments.size() >= 2 && message.arguments[1].substr(0, 9) == "\01VERSION ")
+        {
+          // remove the "\01VERSION " and the "\01" parts from the string
+          const std::string version = message.arguments[1].substr(9, message.arguments[1].size() - 10);
+          this->xmpp.send_version(iq_id, to_jid, from_jid, version);
+          return true;
+        }
+      if (message.command == "401" && message.arguments.size() >= 2
+          && message.arguments[1] == target)
+        {
+          std::string error_message = "No such nick";
+          if (message.arguments.size() >= 3)
+            error_message = message.arguments[2];
+          this->xmpp.send_stanza_error("iq", to_jid, from_jid, iq_id, "cancel", "item-not-found",
+                                        error_message, true);
+          return true;
+        }
+      return false;
+    };
+  this->add_waiting_irc(std::move(cb));
+}
+
+void Bridge::send_message(const Iid& iid, const std::string& nick, const std::string& body, const bool muc)
+{
+  const auto encoding = in_encoding_for(*this, iid);
+  if (muc)
+    {
+      for (const auto& resource: this->resources_in_chan[iid.to_tuple()])
+        {
+          this->xmpp.send_muc_message(std::to_string(iid), nick,
+                                      this->make_xmpp_body(body, encoding), this->user_jid + "/" + resource);
+        }
+    }
+  else
+    {
+      std::string target = std::to_string(iid);
+      const auto it = this->preferred_user_from.find(iid.get_local());
+      if (it != this->preferred_user_from.end())
+        {
+          const auto chan_name = Iid(Jid(it->second).local).get_local();
+          for (const auto& resource: this->resources_in_chan[ChannelKey{chan_name, iid.get_server()}])
+            this->xmpp.send_message(it->second, this->make_xmpp_body(body, encoding),
+                                    this->user_jid + "/" + resource, "chat", true);
+        }
+      else
+        {
+          for (const auto& resource: this->resources_in_server[iid.get_server()])
+            this->xmpp.send_message(std::to_string(iid), this->make_xmpp_body(body, encoding),
+                                    this->user_jid + "/" + resource, "chat", false);
+        }
+    }
+}
+
+void Bridge::send_presence_error(const Iid& iid, const std::string& nick,
+                                 const std::string& type, const std::string& condition,
+                                 const std::string& error_code, const std::string& text)
+{
+  this->xmpp.send_presence_error(std::to_string(iid), nick, this->user_jid, type, condition, error_code, text);
+}
+
+void Bridge::send_muc_leave(Iid&& iid, std::string&& nick, const std::string& message, const bool self, const std::string& resource)
+{
+  if (!resource.empty())
+    this->xmpp.send_muc_leave(std::to_string(iid), std::move(nick), this->make_xmpp_body(message), this->user_jid + "/" + resource,
+                              self);
+  else
+    for (const auto& res: this->resources_in_chan[iid.to_tuple()])
+      this->xmpp.send_muc_leave(std::to_string(iid), std::move(nick), this->make_xmpp_body(message), this->user_jid + "/" + res,
+                                self);
+  IrcClient* irc = this->find_irc_client(iid.get_server());
+  if (irc && irc->number_of_joined_channels() == 0)
+    irc->send_quit_command("");
+}
+
+void Bridge::send_nick_change(Iid&& iid,
+                              const std::string& old_nick,
+                              const std::string& new_nick,
+                              const char user_mode,
+                              const bool self)
+{
+  std::string affiliation;
+  std::string role;
+  std::tie(role, affiliation) = get_role_affiliation_from_irc_mode(user_mode);
+
+  for (const auto& resource: this->resources_in_chan[iid.to_tuple()])
+    this->xmpp.send_nick_change(std::to_string(iid),
+                                old_nick, new_nick, affiliation, role, this->user_jid + "/" + resource, self);
+}
+
+void Bridge::send_xmpp_message(const std::string& from, const std::string& author, const std::string& msg)
+{
+  std::string body;
+  if (!author.empty())
+    {
+      IrcUser user(author);
+      body = "\u000303"s + user.nick + (user.host.empty()?
+                                        "\u0003: ":
+                                        (" (\u000310" + user.host + "\u000303)\u0003: ")) + msg;
+    }
+  else
+    body = msg;
+
+  const auto encoding = in_encoding_for(*this, {from});
+  for (const auto& resource: this->resources_in_server[from])
+    {
+        this->xmpp.send_message(from, this->make_xmpp_body(body, encoding), this->user_jid + "/" + resource, "chat");
+    }
+}
+
+void Bridge::send_user_join(const std::string& hostname, const std::string& chan_name,
+                            const IrcUser* user, const char user_mode, const bool self)
+{
+  for (const auto& resource: this->resources_in_chan[ChannelKey{chan_name, hostname}])
+    this->send_user_join(hostname, chan_name, user, user_mode, self, resource);
+}
+
+void Bridge::send_user_join(const std::string& hostname, const std::string& chan_name,
+                       const IrcUser* user, const char user_mode,
+                       const bool self, const std::string& resource)
+{
+  std::string affiliation;
+  std::string role;
+  std::tie(role, affiliation) = get_role_affiliation_from_irc_mode(user_mode);
+
+  std::string encoded_chan_name(chan_name);
+  xep0106::encode(encoded_chan_name);
+
+  this->xmpp.send_user_join(encoded_chan_name + utils::empty_if_fixed_server("%" + hostname), user->nick, user->host,
+                            affiliation, role, this->user_jid + "/" + resource, self);
+}
+
+void Bridge::send_topic(const std::string& hostname, const std::string& chan_name, const std::string& topic, const std::string& who)
+{
+  for (const auto& resource: this->resources_in_chan[ChannelKey{chan_name, hostname}])
+    {
+      this->send_topic(hostname, chan_name, topic, who, resource);
+    }
+}
+
+void Bridge::send_topic(const std::string& hostname, const std::string& chan_name,
+                        const std::string& topic, const std::string& who,
+                        const std::string& resource)
+{
+  std::string encoded_chan_name(chan_name);
+  xep0106::encode(encoded_chan_name);
+  const auto encoding = in_encoding_for(*this, {encoded_chan_name + '%' + hostname});
+  this->xmpp.send_topic(encoded_chan_name + utils::empty_if_fixed_server(
+      "%" + hostname), this->make_xmpp_body(topic, encoding), this->user_jid + "/" + resource, who);
+
+}
+
+std::string Bridge::get_own_nick(const Iid& iid)
+{
+  IrcClient* irc = this->find_irc_client(iid.get_server());
+  if (irc)
+    return irc->get_own_nick();
+  return "";
+}
+
+size_t Bridge::active_clients() const
+{
+  return this->irc_clients.size();
+}
+
+void Bridge::kick_muc_user(Iid&& iid, const std::string& target, const std::string& reason, const std::string& author)
+{
+  for (const auto& resource: this->resources_in_chan[iid.to_tuple()])
+    this->xmpp.kick_user(std::to_string(iid), target, reason, author, this->user_jid + "/" + resource);
+}
+
+void Bridge::send_nickname_conflict_error(const Iid& iid, const std::string& nickname)
+{
+  for (const auto& resource: this->resources_in_chan[iid.to_tuple()])
+    this->xmpp.send_presence_error(std::to_string(iid), nickname, this->user_jid + "/" + resource, "cancel", "conflict", "409", "");
+}
+
+void Bridge::send_affiliation_role_change(const Iid& iid, const std::string& target, const char mode)
+{
+  std::string role;
+  std::string affiliation;
+
+  std::tie(role, affiliation) = get_role_affiliation_from_irc_mode(mode);
+  for (const auto& resource: this->resources_in_chan[iid.to_tuple()])
+    this->xmpp.send_affiliation_role_change(std::to_string(iid), target, affiliation, role, this->user_jid + "/" + resource);
+}
+
+void Bridge::send_iq_version_request(const std::string& nick, const std::string& hostname)
+{
+  const auto resources = this->resources_in_server[hostname];
+  if (resources.begin() != resources.end())
+    this->xmpp.send_iq_version_request(utils::tolower(nick) + "!" + utils::empty_if_fixed_server(hostname), this->user_jid + "/" + *resources.begin());
+}
+
+void Bridge::send_xmpp_ping_request(const std::string& nick, const std::string& hostname,
+                                    const std::string& id)
+{
+  // Use revstr because the forwarded ping to target XMPP user must not be
+  // the same that the request iq, but we also need to get it back easily
+  // (revstr again)
+  // Forward to the first resource (arbitrary, based on the “order” of the std::set) only
+  const auto resources = this->resources_in_server[hostname];
+  if (resources.begin() != resources.end())
+    this->xmpp.send_ping_request(utils::tolower(nick) + "!" + utils::empty_if_fixed_server(hostname), this->user_jid + "/" + *resources.begin(), utils::revstr(id));
+}
+
+void Bridge::set_preferred_from_jid(const std::string& nick, const std::string& full_jid)
+{
+  auto it = this->preferred_user_from.find(nick);
+  if (it == this->preferred_user_from.end())
+    this->preferred_user_from.emplace(nick, full_jid);
+  else
+    this->preferred_user_from[nick] = full_jid;
+}
+
+void Bridge::remove_preferred_from_jid(const std::string& nick)
+{
+  auto it = this->preferred_user_from.find(nick);
+  if (it != this->preferred_user_from.end())
+    this->preferred_user_from.erase(it);
+}
+
+void Bridge::remove_all_preferred_from_jid_of_room(const std::string& channel_name)
+{
+  for (auto it = this->preferred_user_from.begin(); it != this->preferred_user_from.end();)
+    {
+      Iid iid(Jid(it->second).local);
+      if (iid.get_local() == channel_name)
+        it = this->preferred_user_from.erase(it);
+      else
+        ++it;
+    }
+}
+
+void Bridge::add_waiting_irc(irc_responder_callback_t&& callback)
+{
+  this->waiting_irc.emplace_back(std::move(callback));
+}
+
+void Bridge::trigger_on_irc_message(const std::string& irc_hostname, const IrcMessage& message)
+{
+  auto it = this->waiting_irc.begin();
+  while (it != this->waiting_irc.end())
+    {
+      if ((*it)(irc_hostname, message) == true)
+        it = this->waiting_irc.erase(it);
+      else
+        ++it;
+    }
+}
+
+std::unordered_map<std::string, std::shared_ptr<IrcClient>>& Bridge::get_irc_clients()
+{
+  return this->irc_clients;
+}
+
+void Bridge::add_resource_to_chan(const Bridge::ChannelKey& channel, const std::string& resource)
+{
+  auto it = this->resources_in_chan.find(channel);
+  if (it == this->resources_in_chan.end())
+    this->resources_in_chan[channel] = {resource};
+  else
+    it->second.insert(resource);
+}
+
+void Bridge::remove_resource_from_chan(const Bridge::ChannelKey& channel, const std::string& resource)
+{
+  auto it = this->resources_in_chan.find(channel);
+  if (it != this->resources_in_chan.end())
+    {
+      it->second.erase(resource);
+      if (it->second.empty())
+        this->resources_in_chan.erase(it);
+    }
+}
+
+bool Bridge::is_resource_in_chan(const Bridge::ChannelKey& channel, const std::string& resource) const
+{
+  auto it = this->resources_in_chan.find(channel);
+  if (it != this->resources_in_chan.end())
+    if (it->second.count(resource) == 1)
+      return true;
+  return false;
+}
+
+void Bridge::add_resource_to_server(const Bridge::IrcHostname& irc_hostname, const std::string& resource)
+{
+  auto it = this->resources_in_server.find(irc_hostname);
+  if (it == this->resources_in_server.end())
+    this->resources_in_server[irc_hostname] = {resource};
+  else
+    it->second.insert(resource);
+}
+
+void Bridge::remove_resource_from_server(const Bridge::IrcHostname& irc_hostname, const std::string& resource)
+{
+  auto it = this->resources_in_server.find(irc_hostname);
+  if (it != this->resources_in_server.end())
+    {
+      it->second.erase(resource);
+      if (it->second.empty())
+        this->resources_in_server.erase(it);
+    }
+}
+
+bool Bridge::is_resource_in_server(const Bridge::IrcHostname& irc_hostname, const std::string& resource) const
+{
+  auto it = this->resources_in_server.find(irc_hostname);
+  if (it != this->resources_in_server.end())
+    if (it->second.count(resource) == 1)
+      return true;
+  return false;
+}
+
+std::size_t Bridge::number_of_resources_in_chan(const Bridge::ChannelKey& channel_key) const
+{
+  auto it = this->resources_in_chan.find(channel_key);
+  if (it == this->resources_in_chan.end())
+    return 0;
+  return it->second.size();
+}
+
+std::size_t Bridge::number_of_channels_the_resource_is_in(const std::string& irc_hostname, const std::string& resource) const
+{
+  std::size_t res = 0;
+  for (auto pair: this->resources_in_chan)
+    {
+      if (std::get<0>(pair.first) == irc_hostname && pair.second.count(resource) != 0)
+        res++;
+    }
+  return res;
+}
+
+void Bridge::generate_channel_join_for_resource(const Iid& iid, const std::string& resource)
+{
+  IrcClient* irc = this->get_irc_client(iid.get_server());
+  IrcChannel* channel = irc->get_channel(iid.get_local());
+  const auto self = channel->get_self();
+
+  // Send the occupant list
+  for (const auto& user: channel->get_users())
+    {
+      if (user->nick != self->nick)
+        {
+          log_debug(user->nick);
+          this->send_user_join(iid.get_server(), iid.get_encoded_local(),
+                               user.get(), user->get_most_significant_mode(irc->get_sorted_user_modes()),
+                               false, resource);
+        }
+    }
+  this->send_user_join(iid.get_server(), iid.get_encoded_local(),
+                       self, self->get_most_significant_mode(irc->get_sorted_user_modes()),
+                       true, resource);
+  this->send_topic(iid.get_server(), iid.get_encoded_local(), channel->topic, channel->topic_author, resource);
+}
diff --git a/src/bridge/bridge.hpp b/src/bridge/bridge.hpp
new file mode 100644
index 0000000..69b7bd5
--- /dev/null
+++ b/src/bridge/bridge.hpp
@@ -0,0 +1,293 @@
+#pragma once
+
+
+#include <irc/irc_message.hpp>
+#include <irc/irc_client.hpp>
+#include <bridge/colors.hpp>
+#include <irc/irc_user.hpp>
+#include <irc/iid.hpp>
+
+#include <unordered_map>
+#include <functional>
+#include <exception>
+#include <string>
+#include <memory>
+
+class BiboumiComponent;
+class Poller;
+
+/**
+ * A callback called for each IrcMessage we receive. If the message triggers
+ * a response, it must send ore or more iq and return true (in that case it
+ * is removed from the list), otherwise it must do nothing and just return
+ * false.
+ */
+using irc_responder_callback_t = std::function<bool(const std::string& irc_hostname, const IrcMessage& message)>;
+
+/**
+ * One bridge is spawned for each XMPP user that uses the component.  The
+ * bridge spawns IrcClients when needed (when the user wants to join a
+ * channel on a new server) and does the translation between the two
+ * protocols.
+ */
+class Bridge
+{
+public:
+  explicit Bridge(const std::string& user_jid, BiboumiComponent& xmpp, std::shared_ptr<Poller> poller);
+  ~Bridge() = default;
+
+  Bridge(const Bridge&) = delete;
+  Bridge(Bridge&& other) = delete;
+  Bridge& operator=(const Bridge&) = delete;
+  Bridge& operator=(Bridge&&) = delete;
+  /**
+   * QUIT all connected IRC servers.
+   */
+  void shutdown(const std::string& exit_message);
+  /**
+   * Remove all inactive IrcClients
+   */
+  void clean();
+  /**
+   * Return the jid of the XMPP user using this bridge
+   */
+  const std::string& get_jid() const;
+  std::string get_bare_jid() const;
+
+  static Xmpp::body make_xmpp_body(const std::string& str, const std::string& encoding = "ISO-8859-1");
+  /***
+   **
+   ** From XMPP to IRC.
+   **
+   **/
+
+  /**
+   * Try to join an irc_channel, does nothing and return true if the channel
+   * was already joined.
+   */
+  bool join_irc_channel(const Iid& iid, const std::string& nickname, const std::string& password, const std::string& resource);
+
+  void send_channel_message(const Iid& iid, const std::string& body);
+  void send_private_message(const Iid& iid, const std::string& body, const std::string& type="PRIVMSG");
+  void send_raw_message(const std::string& hostname, const std::string& body);
+  void leave_irc_channel(Iid&& iid, std::string&& status_message, const std::string& resource);
+  void send_irc_nick_change(const Iid& iid, const std::string& new_nick);
+  void send_irc_kick(const Iid& iid, const std::string& target, const std::string& reason,
+                     const std::string& iq_id, const std::string& to_jid);
+  void set_channel_topic(const Iid& iid, const std::string& subject);
+  void send_xmpp_version_to_irc(const Iid& iid, const std::string& name, const std::string& version,
+                                const std::string& os);
+  void send_irc_ping_result(const Iid& iid, const std::string& id);
+  void send_irc_version_request(const std::string& irc_hostname, const std::string& target,
+                                const std::string& iq_id, const std::string& to_jid,
+                                const std::string& from_jid);
+  void send_irc_channel_list_request(const Iid& iid, const std::string& iq_id,
+                                     const std::string& to_jid);
+  void forward_affiliation_role_change(const Iid& iid, const std::string& nick,
+                                       const std::string& affiliation, const std::string& role);
+  /**
+   * Directly send a CTCP PING request to the IRC user
+   */
+  void send_irc_user_ping_request(const std::string& irc_hostname, const std::string& nick,
+                                  const std::string& iq_id, const std::string& to_jid,
+                                  const std::string& from_jid);
+  /**
+   * First check if the participant is in the room, before sending a direct
+   * CTCP PING request to the IRC user
+   */
+  void send_irc_participant_ping_request(const Iid& iid, const std::string& nick,
+                                         const std::string& iq_id, const std::string& to_jid,
+                                         const std::string& from_jid);
+  /**
+   * Directly send back a result if it's a gateway ping or if we are
+   * connected to the given IRC server, an error otherwise.
+   */
+  void on_gateway_ping(const std::string& irc_hostname, const std::string& iq_id, const std::string& to_jid,
+                       const std::string& from_jid);
+
+  /***
+   **
+   ** From IRC to XMPP.
+   **
+   **/
+
+  /**
+   * Send a message corresponding to a server NOTICE, the from attribute
+   * should be juste the server hostname.
+   */
+  void send_xmpp_message(const std::string& from, const std::string& author, const std::string& msg);
+  /**
+   * Send the presence of a new user in the MUC.
+   */
+  void send_user_join(const std::string& hostname, const std::string& chan_name,
+                      const IrcUser* user, const char user_mode,
+                      const bool self, const std::string& resource);
+  void send_user_join(const std::string& hostname, const std::string& chan_name,
+                      const IrcUser* user, const char user_mode,
+                      const bool self);
+
+  /**
+   * Send the topic of the MUC to the user
+   */
+  void send_topic(const std::string& hostname, const std::string& chan_name, const std::string& topic, const std::string& who);
+  void send_topic(const std::string& hostname, const std::string& chan_name, const std::string& topic, const std::string& who, const std::string& resource);
+  /**
+   * Send a MUC message from some participant
+   */
+  void send_message(const Iid& iid, const std::string& nick, const std::string& body, const bool muc);
+  /**
+   * Send a presence of type error, from a room.
+   */
+  void send_presence_error(const Iid& iid, const std::string& nick, const std::string& type, const std::string& condition, const std::string& error_code, const std::string& text);
+  /**
+   * Send an unavailable presence from this participant
+   */
+  void send_muc_leave(Iid&& iid, std::string&& nick, const std::string& message, const bool self, const std::string& resource="");
+  /**
+   * Send presences to indicate that an user old_nick (ourself if self ==
+   * true) changed his nick to new_nick.  The user_mode is needed because
+   * the xmpp presence needs ton contain the role and affiliation of the
+   * user.
+   */
+  void send_nick_change(Iid&& iid,
+                        const std::string& old_nick,
+                        const std::string& new_nick,
+                        const char user_mode,
+                        const bool self);
+  void kick_muc_user(Iid&& iid, const std::string& target, const std::string& reason, const std::string& author);
+  void send_nickname_conflict_error(const Iid& iid, const std::string& nickname);
+  /**
+   * Send a role/affiliation change, matching the change of mode for that user
+   */
+  void send_affiliation_role_change(const Iid& iid, const std::string& target, const char mode);
+  /**
+   * Send an iq version request coming from nick!hostname@
+   */
+  void send_iq_version_request(const std::string& nick, const std::string& hostname);
+  /**
+   * Send an iq ping request coming from nick!hostname@
+   */
+  void send_xmpp_ping_request(const std::string& nick, const std::string& hostname,
+                              const std::string& id);
+  /**
+   * Misc
+   */
+  std::string get_own_nick(const Iid& iid);
+  /**
+   * Get the number of server to which this bridge is connected or connecting.
+   */
+  size_t active_clients() const;
+  /**
+   * Add (or replace the existing) <nick, jid> into the preferred_user_from map
+   */
+  void set_preferred_from_jid(const std::string& nick, const std::string& full_jid);
+  /**
+   * Remove the preferred jid for the given IRC nick
+   */
+  void remove_preferred_from_jid(const std::string& nick);
+  /**
+   * Given a channel_name, remove all preferred from_jid that come
+   * from this chan.
+   */
+  void remove_all_preferred_from_jid_of_room(const std::string& channel_name);
+  /**
+   * Add a callback to the waiting list of irc callbacks.
+   */
+  void add_waiting_irc(irc_responder_callback_t&& callback);
+  /**
+   * Iter over all the waiting_iq, call the iq_responder_filter_t for each,
+   * whenever one of them returns true: call the corresponding
+   * iq_responder_callback_t and remove the callback from the list.
+   */
+  void trigger_on_irc_message(const std::string& irc_hostname, const IrcMessage& message);
+  std::unordered_map<std::string, std::shared_ptr<IrcClient>>& get_irc_clients();
+
+private:
+  /**
+   * Returns the client for the given hostname, create one (and use the
+   * username in this case) if none is found, and connect that newly-created
+   * client immediately.
+   */
+  IrcClient* make_irc_client(const std::string& hostname, const std::string& nickname);
+  /**
+   * This version does not create the IrcClient if it does not exist, throws
+   * a IRCServerNotConnected error in that case.
+   */
+  IrcClient* get_irc_client(const std::string& hostname);
+  /**
+   * Idem, but returns nullptr if the server does not exist.
+   */
+  IrcClient* find_irc_client(const std::string& hostname);
+  /**
+   * The bare JID of the user associated with this bridge. Messages from/to this
+   * JID are only managed by this bridge.
+   */
+  const std::string user_jid;
+  /**
+   * One IrcClient for each IRC server we need to be connected to.
+   * The pointer is shared by the bridge and the poller.
+   */
+  std::unordered_map<std::string, std::shared_ptr<IrcClient>> irc_clients;
+  /**
+   * To communicate back with the XMPP component
+   */
+  BiboumiComponent& xmpp;
+  /**
+   * Poller, to give it the IrcClients that we spawn, to make it manage
+   * their sockets.
+   */
+  std::shared_ptr<Poller> poller;
+  /**
+   * A map of <nick, full_jid>. For example if this map contains <"toto",
+   * "#somechan%server@biboumi/ToTo">, whenever a private message is
+   * received from the user "toto", instead of forwarding it to XMPP with
+   * from='toto!server@biboumi', we use instead
+   * from='#somechan%server@biboumi/ToTo'
+   */
+  std::unordered_map<std::string, std::string> preferred_user_from;
+  /**
+   * A list of callbacks that are waiting for some IrcMessage to trigger a
+   * response.  We add callbacks in this list whenever we received an IQ
+   * request and we need a response from IRC to be able to provide the
+   * response iq.
+   */
+  std::vector<irc_responder_callback_t> waiting_irc;
+
+  /**
+   * Resources to IRC channel/server mapping:
+   */
+  using Resource = std::string;
+  using ChannelName = std::string;
+  using IrcHostname = std::string;
+  using ChannelKey = std::tuple<ChannelName, IrcHostname>;
+  std::map<ChannelKey, std::set<Resource>> resources_in_chan;
+  std::map<IrcHostname, std::set<Resource>> resources_in_server;
+  /**
+   * Manage which resource is in which channel
+   */
+  void add_resource_to_chan(const ChannelKey& channel_key, const std::string& resource);
+  void remove_resource_from_chan(const ChannelKey& channel_key, const std::string& resource);
+  bool is_resource_in_chan(const ChannelKey& channel_key, const std::string& resource) const;
+  std::size_t number_of_resources_in_chan(const ChannelKey& channel_key) const;
+
+  void add_resource_to_server(const IrcHostname& irc_hostname, const std::string& resource);
+  void remove_resource_from_server(const IrcHostname& irc_hostname, const std::string& resource);
+  bool is_resource_in_server(const IrcHostname& irc_hostname, const std::string& resource) const;
+  size_t number_of_channels_the_resource_is_in(const std::string& irc_hostname, const std::string& resource) const;
+
+  /**
+   * Generate all the stanzas to be sent to this resource, simulating a join on this channel.
+   * This means sending the whole user list, the topic, etc
+   * TODO: send message history
+   */
+  void generate_channel_join_for_resource(const Iid& iid, const std::string& resource);
+};
+
+struct IRCNotConnected: public std::exception
+{
+  IRCNotConnected(const std::string& hostname):
+    hostname(hostname) {}
+  const std::string hostname;
+};
+
+
diff --git a/src/bridge/colors.cpp b/src/bridge/colors.cpp
new file mode 100644
index 0000000..66f51ee
--- /dev/null
+++ b/src/bridge/colors.cpp
@@ -0,0 +1,170 @@
+#include <bridge/colors.hpp>
+#include <xmpp/xmpp_stanza.hpp>
+
+#include <algorithm>
+#include <iostream>
+
+#include <string.h>
+
+using namespace std::string_literals;
+
+static const char IRC_NUM_COLORS = 16;
+
+static const char* irc_colors_to_css[IRC_NUM_COLORS] = {
+  "white",
+  "black",
+  "blue",
+  "green",
+  "indianred",
+  "red",
+  "magenta",
+  "brown",
+  "yellow",
+  "lightgreen",
+  "cyan",
+  "lightcyan",
+  "lightblue",
+  "lightmagenta",
+  "gray",
+  "white",
+};
+
+#define XHTML_NS "http://www.w3.org/1999/xhtml"
+
+struct styles_t
+{
+  bool strong;
+  bool underline;
+  bool italic;
+  int fg;
+  int bg;
+};
+
+/** We keep the currently-applied CSS styles in a structure. Each time a tag
+ * is found, update this style list, then close the current span XML element
+ * (if it is open), then reopen it with all the new styles in it.  This is
+ * done this way because IRC formatting does not map well with XML
+ * (hierarchical tags), it’s a lot easier and cleaner to remove all styles
+ * and reapply them for each tag, instead of trying to keep a consistent
+ * hierarchy of span, strong, em etc tags.  The generated XML is one-level
+ * deep only.
+*/
+Xmpp::body irc_format_to_xhtmlim(const std::string& s)
+{
+  if (s.find_first_of(irc_format_char) == std::string::npos)
+    // there is no special formatting at all
+    return std::make_tuple(s, nullptr);
+
+  std::string cleaned;
+
+  styles_t styles = {false, false, false, -1, -1};
+
+  std::unique_ptr<XmlNode> result = std::make_unique<XmlNode>("body");
+  (*result)["xmlns"] = XHTML_NS;
+
+  std::unique_ptr<XmlNode> current_node_up;
+  XmlNode* current_node = result.get();
+
+  std::string::size_type pos_start = 0;
+  std::string::size_type pos_end;
+
+  while ((pos_end = s.find_first_of(irc_format_char, pos_start)) != std::string::npos)
+    {
+      const std::string txt = s.substr(pos_start, pos_end-pos_start);
+      cleaned += txt;
+      if (current_node->has_children())
+        current_node->get_last_child()->add_to_tail(txt);
+      else
+        current_node->add_to_inner(txt);
+
+      if (s[pos_end] == IRC_FORMAT_BOLD_CHAR)
+        styles.strong = !styles.strong;
+      else if (s[pos_end] == IRC_FORMAT_NEWLINE_CHAR)
+        {
+          current_node->add_child(std::make_unique<XmlNode>("br"));
+          cleaned += '\n';
+        }
+      else if (s[pos_end] == IRC_FORMAT_UNDERLINE_CHAR)
+        styles.underline = !styles.underline;
+      else if (s[pos_end] == IRC_FORMAT_ITALIC_CHAR)
+        styles.italic = !styles.italic;
+      else if (s[pos_end] == IRC_FORMAT_RESET_CHAR)
+        styles = {false, false, false, -1, -1};
+      else if (s[pos_end] == IRC_FORMAT_REVERSE_CHAR)
+        { }                      // TODO
+      else if (s[pos_end] == IRC_FORMAT_REVERSE2_CHAR)
+        { }                      // TODO
+      else if (s[pos_end] == IRC_FORMAT_FIXED_CHAR)
+        { }                      // TODO
+      else if (s[pos_end] == IRC_FORMAT_COLOR_CHAR)
+        {
+          size_t pos = pos_end + 1;
+          styles.fg = -1;
+          styles.bg = -1;
+          // get the first number following the format char
+          if (pos < s.size() && s[pos] >= '0' && s[pos] <= '9')
+            {                   // first digit
+              styles.fg = s[pos++] - '0';
+              if (pos < s.size() && s[pos] >= '0' && s[pos] <= '9')
+                // second digit
+                styles.fg = styles.fg * 10 + s[pos++] - '0';
+            }
+          if (pos < s.size() && s[pos] == ',')
+            {                   // get bg color after the comma
+              pos++;
+              if (pos < s.size() && s[pos] >= '0' && s[pos] <= '9')
+                {               // first digit
+                  styles.bg = s[pos++] - '0';
+                  if (pos < s.size() && s[pos] >= '0' && s[pos] <= '9')
+                    // second digit
+                    styles.bg = styles.bg * 10 + s[pos++] - '0';
+                }
+            }
+          pos_end = pos - 1;
+        }
+
+      // close opened span, if any
+      if (current_node != result.get())
+        {
+          result->add_child(std::move(current_node_up));
+          current_node = result.get();
+        }
+      // Take all currently-applied style and create a new span with it
+      std::string styles_str;
+      if (styles.strong)
+        styles_str += "font-weight:bold;";
+      if (styles.underline)
+        styles_str += "text-decoration:underline;";
+      if (styles.italic)
+        styles_str += "font-style:italic;";
+      if (styles.fg != -1)
+        styles_str += "color:"s +
+          irc_colors_to_css[styles.fg % IRC_NUM_COLORS] + ";";
+      if (styles.bg != -1)
+        styles_str += "background-color:"s +
+          irc_colors_to_css[styles.bg % IRC_NUM_COLORS] + ";";
+      if (!styles_str.empty())
+        {
+          current_node_up = std::make_unique<XmlNode>("span");
+          current_node = current_node_up.get();
+          (*current_node)["style"] = styles_str;
+        }
+
+      pos_start = pos_end + 1;
+    }
+
+  // If some text remains, without any format char, just append that text at
+  // the end of the current node
+  const std::string txt = s.substr(pos_start, pos_end-pos_start);
+  cleaned += txt;
+  if (current_node->has_children())
+    current_node->get_last_child()->add_to_tail(txt);
+  else
+    current_node->add_to_inner(txt);
+
+  if (current_node != result.get())
+    result->add_child(std::move(current_node_up));
+
+  Xmpp::body body_res = std::make_tuple(cleaned, std::move(result));
+  return body_res;
+}
diff --git a/src/bridge/colors.hpp b/src/bridge/colors.hpp
new file mode 100644
index 0000000..e2c8a87
--- /dev/null
+++ b/src/bridge/colors.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+
+/**
+ * A module handling the conversion between IRC colors and XHTML-IM, and
+ * vice versa.
+ */
+
+#include <string>
+#include <memory>
+#include <tuple>
+
+class XmlNode;
+
+namespace Xmpp
+{
+// Contains:
+// - an XMPP-valid UTF-8 body
+// - an XML node representing the XHTML-IM body, or null
+  using body = std::tuple<const std::string, std::unique_ptr<XmlNode>>;
+}
+
+#define IRC_FORMAT_BOLD_CHAR       '\x02' // done
+#define IRC_FORMAT_COLOR_CHAR      '\x03' // done
+#define IRC_FORMAT_RESET_CHAR      '\x0F' // done
+#define IRC_FORMAT_FIXED_CHAR      '\x11' // ??
+#define IRC_FORMAT_REVERSE_CHAR    '\x12' // maybe one day
+#define IRC_FORMAT_REVERSE2_CHAR   '\x16' // wat
+#define IRC_FORMAT_ITALIC_CHAR     '\x1D' // done
+#define IRC_FORMAT_UNDERLINE_CHAR  '\x1F' // done
+#define IRC_FORMAT_NEWLINE_CHAR    '\n'   // done
+
+static const char irc_format_char[] = {
+  IRC_FORMAT_BOLD_CHAR,
+  IRC_FORMAT_COLOR_CHAR,
+  IRC_FORMAT_RESET_CHAR,
+  IRC_FORMAT_FIXED_CHAR,
+  IRC_FORMAT_REVERSE_CHAR,
+  IRC_FORMAT_REVERSE2_CHAR,
+  IRC_FORMAT_ITALIC_CHAR,
+  IRC_FORMAT_UNDERLINE_CHAR,
+  IRC_FORMAT_NEWLINE_CHAR,
+  '\x00'
+};
+
+/**
+ * Convert the passed string into an XML tree representing the XHTML version
+ * of the message, converting the IRC colors symbols into xhtml-im
+ * formatting.
+ *
+ * Returns the body cleaned from any IRC formatting (but without any xhtml),
+ * and the body as XHTML-IM
+ */
+Xmpp::body irc_format_to_xhtmlim(const std::string& str);
+
+
diff --git a/src/bridge/list_element.hpp b/src/bridge/list_element.hpp
new file mode 100644
index 0000000..1eff2ee
--- /dev/null
+++ b/src/bridge/list_element.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+
+#include <string>
+
+struct ListElement
+{
+  ListElement(const std::string& channel, const std::string& nb_users,
+                 const std::string& topic):
+    channel(channel),
+    nb_users(nb_users),
+    topic(topic){}
+
+  std::string channel;
+  std::string nb_users;
+  std::string topic;
+};
+
+
diff --git a/src/database/database.cpp b/src/database/database.cpp
new file mode 100644
index 0000000..61e1b47
--- /dev/null
+++ b/src/database/database.cpp
@@ -0,0 +1,87 @@
+#include "biboumi.h"
+#ifdef USE_DATABASE
+
+#include <database/database.hpp>
+#include <logger/logger.hpp>
+#include <string>
+
+using namespace std::string_literals;
+
+std::unique_ptr<db::BibouDB> Database::db;
+
+void Database::open(const std::string& filename, const std::string& db_type)
+{
+  try
+    {
+      auto new_db = std::make_unique<db::BibouDB>(db_type,
+                                             "database="s + filename);
+      if (new_db->needsUpgrade())
+        new_db->upgrade();
+      Database::db.reset(new_db.release());
+    } catch (const litesql::DatabaseError& e) {
+      log_error("Failed to open database ", filename, ". ", e.what());
+      throw;
+    }
+}
+
+void Database::set_verbose(const bool val)
+{
+  Database::db->verbose = val;
+}
+
+db::IrcServerOptions Database::get_irc_server_options(const std::string& owner,
+                                                      const std::string& server)
+{
+  try {
+    auto options = litesql::select<db::IrcServerOptions>(*Database::db,
+                             db::IrcServerOptions::Owner == owner &&
+                             db::IrcServerOptions::Server == server).one();
+    return options;
+  } catch (const litesql::NotFound& e) {
+    db::IrcServerOptions options(*Database::db);
+    options.owner = owner;
+    options.server = server;
+    // options.update();
+    return options;
+  }
+}
+
+db::IrcChannelOptions Database::get_irc_channel_options(const std::string& owner,
+                                                        const std::string& server,
+                                                        const std::string& channel)
+{
+  try {
+    auto options = litesql::select<db::IrcChannelOptions>(*Database::db,
+                                                         db::IrcChannelOptions::Owner == owner &&
+                                                         db::IrcChannelOptions::Server == server &&
+                                                         db::IrcChannelOptions::Channel == channel).one();
+    return options;
+  } catch (const litesql::NotFound& e) {
+    db::IrcChannelOptions options(*Database::db);
+    options.owner = owner;
+    options.server = server;
+    options.channel = channel;
+    return options;
+  }
+}
+
+db::IrcChannelOptions Database::get_irc_channel_options_with_server_default(const std::string& owner,
+                                                                            const std::string& server,
+                                                                            const std::string& channel)
+{
+  auto coptions = Database::get_irc_channel_options(owner, server, channel);
+  auto soptions = Database::get_irc_server_options(owner, server);
+  if (coptions.encodingIn.value().empty())
+    coptions.encodingIn = soptions.encodingIn;
+  if (coptions.encodingOut.value().empty())
+    coptions.encodingOut = soptions.encodingOut;
+
+  return coptions;
+}
+
+void Database::close()
+{
+  Database::db.reset(nullptr);
+}
+
+#endif
diff --git a/src/database/database.hpp b/src/database/database.hpp
new file mode 100644
index 0000000..7173bcd
--- /dev/null
+++ b/src/database/database.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+
+#include <biboumi.h>
+#ifdef USE_DATABASE
+
+#include "biboudb.hpp"
+
+#include <memory>
+
+#include <litesql.hpp>
+
+class Database
+{
+public:
+  Database() = default;
+  ~Database() = default;
+
+  Database(const Database&) = delete;
+  Database(Database&&) = delete;
+  Database& operator=(const Database&) = delete;
+  Database& operator=(Database&&) = delete;
+
+  static void set_verbose(const bool val);
+
+  template<typename PersistentType>
+  static size_t count()
+  {
+    return litesql::select<PersistentType>(*Database::db).count();
+  }
+  /**
+   * Return the object from the db. Create it beforehand (with all default
+   * values) if it is not already present.
+   */
+  static db::IrcServerOptions get_irc_server_options(const std::string& owner,
+                                                     const std::string& server);
+  static db::IrcChannelOptions get_irc_channel_options(const std::string& owner,
+                                                       const std::string& server,
+                                                       const std::string& channel);
+  static db::IrcChannelOptions get_irc_channel_options_with_server_default(const std::string& owner,
+                                                                           const std::string& server,
+                                                                           const std::string& channel);
+
+  static void close();
+  static void open(const std::string& filename, const std::string& db_type="sqlite3");
+
+
+private:
+  static std::unique_ptr<db::BibouDB> db;
+};
+#endif /* USE_DATABASE */
+
+
diff --git a/src/irc/iid.cpp b/src/irc/iid.cpp
new file mode 100644
index 0000000..0e2841e
--- /dev/null
+++ b/src/irc/iid.cpp
@@ -0,0 +1,118 @@
+#include <utils/tolower.hpp>
+#include <config/config.hpp>
+
+#include <irc/iid.hpp>
+
+#include <utils/encoding.hpp>
+
+Iid::Iid(const std::string& iid):
+  is_channel(false),
+  is_user(false)
+{
+  const std::string fixed_irc_server = Config::get("fixed_irc_server", "");
+  if (fixed_irc_server.empty())
+    this->init(iid);
+  else
+    this->init_with_fixed_server(iid, fixed_irc_server);
+}
+
+
+void Iid::init(const std::string& iid)
+{
+  const std::string::size_type sep = iid.find_first_of("%!");
+  if (sep != std::string::npos)
+    {
+      if (iid[sep] == '%')
+        this->is_channel = true;
+      else
+        this->is_user = true;
+      this->set_local(iid.substr(0, sep));
+      this->set_server(iid.substr(sep + 1));
+    }
+  else
+    this->set_server(iid);
+}
+
+void Iid::init_with_fixed_server(const std::string& iid, const std::string& hostname)
+{
+  this->set_server(hostname);
+
+  const std::string::size_type sep = iid.find("!");
+
+  // Without any separator, we consider that it's a channel
+  if (sep == std::string::npos)
+    {
+      this->is_channel = true;
+      this->set_local(iid);
+    }
+  else // A separator can be present to differenciate a channel from a user,
+       // but the part behind it (the hostname) is ignored
+    {
+      this->set_local(iid.substr(0, sep));
+        this->is_user = true;
+    }
+}
+
+Iid::Iid():
+  is_channel(false),
+  is_user(false)
+{
+}
+
+void Iid::set_local(const std::string& loc)
+{
+  std::string local(utils::tolower(loc));
+  xep0106::decode(local);
+  this->local = local;
+}
+
+void Iid::set_server(const std::string& serv)
+{
+  this->server = utils::tolower(serv);
+}
+
+const std::string& Iid::get_local() const
+{
+  return this->local;
+}
+
+const std::string Iid::get_encoded_local() const
+{
+  std::string local(this->local);
+  xep0106::encode(local);
+  return local;
+}
+
+const std::string& Iid::get_server() const
+{
+  return this->server;
+}
+
+std::string Iid::get_sep() const
+{
+  if (this->is_channel)
+    return "%";
+  else if (this->is_user)
+    return "!";
+  return "";
+}
+
+namespace std {
+  const std::string to_string(const Iid& iid)
+  {
+    if (Config::get("fixed_irc_server", "").empty())
+      return iid.get_encoded_local() + iid.get_sep() + iid.get_server();
+    else
+      {
+        if (iid.get_sep() == "!")
+          return iid.get_encoded_local() + iid.get_sep();
+        else
+          return iid.get_encoded_local();
+      }
+  }
+}
+
+std::tuple<std::string, std::string> Iid::to_tuple() const
+{
+  return std::make_tuple(this->get_local(), this->get_server());
+}
diff --git a/src/irc/iid.hpp b/src/irc/iid.hpp
new file mode 100644
index 0000000..3b11470
--- /dev/null
+++ b/src/irc/iid.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+
+#include <string>
+
+/**
+ * A name representing an IRC channel on an IRC server, or an IRC user on an
+ * IRC server, or just an IRC server.
+ *
+ * The separator for an user is '!', for a channel it's '%'. If no separator
+ * is present, it's just an irc server.
+ * It’s possible to have an empty-string server, but it makes no sense in
+ * the biboumi context.
+ *
+ * #test%irc.example.org has :
+ * - local: "#test" (the # is part of the name, it could very well be absent, or & (for example) instead)
+ * - server: "irc.example.org"
+ * - is_channel: true
+ * - is_user: false
+ *
+ * %irc.example.org:
+ * - local: ""
+ * - server: "irc.example.org"
+ * - is_channel: true
+ * - is_user: false
+ * Note: this is the special empty-string channel, used internal in biboumi
+ * but has no meaning on IRC.
+ *
+ * foo!irc.example.org
+ * - local: "foo"
+ * - server: "irc.example.org"
+ * - is_channel: false
+ * - is_user: true
+ * Note: the empty-string user (!irc.example.org) has no special meaning in biboumi
+ *
+ * irc.example.org:
+ * - local: ""
+ * - server: "irc.example.org"
+ * - is_channel: false
+ * - is_user: false
+ */
+class Iid
+{
+public:
+  Iid(const std::string& iid);
+  Iid();
+  Iid(const Iid&) = default;
+
+  Iid(Iid&&) = delete;
+  Iid& operator=(const Iid&) = delete;
+  Iid& operator=(Iid&&) = delete;
+
+  void set_local(const std::string& loc);
+  void set_server(const std::string& serv);
+  const std::string& get_local() const;
+  const std::string get_encoded_local() const;
+  const std::string& get_server() const;
+
+  bool is_channel;
+  bool is_user;
+
+  std::string get_sep() const;
+
+  std::tuple<std::string, std::string> to_tuple() const;
+
+private:
+
+  void init(const std::string& iid);
+  void init_with_fixed_server(const std::string& iid, const std::string& hostname);
+
+  std::string local;
+  std::string server;
+};
+
+namespace std {
+  const std::string to_string(const Iid& iid);
+}
+
+
diff --git a/src/irc/irc_channel.cpp b/src/irc/irc_channel.cpp
new file mode 100644
index 0000000..e769245
--- /dev/null
+++ b/src/irc/irc_channel.cpp
@@ -0,0 +1,60 @@
+#include <irc/irc_channel.hpp>
+#include <algorithm>
+
+IrcChannel::IrcChannel():
+  joined(false),
+  self(nullptr)
+{
+}
+
+void IrcChannel::set_self(const std::string& name)
+{
+  this->self = std::make_unique<IrcUser>(name);
+}
+
+IrcUser* IrcChannel::add_user(const std::string& name,
+                              const std::map<char, char>& prefix_to_mode)
+{
+  this->users.emplace_back(std::make_unique<IrcUser>(name, prefix_to_mode));
+  return this->users.back().get();
+}
+
+IrcUser* IrcChannel::get_self() const
+{
+  return this->self.get();
+}
+
+IrcUser* IrcChannel::find_user(const std::string& name) const
+{
+  IrcUser user(name);
+  for (const auto& u: this->users)
+    {
+      if (u->nick == user.nick)
+        return u.get();
+    }
+  return nullptr;
+}
+
+void IrcChannel::remove_user(const IrcUser* user)
+{
+  const auto nick = user->nick;
+  const auto it = std::find_if(this->users.begin(), this->users.end(),
+                               [nick](const std::unique_ptr<IrcUser>& u)
+                               {
+                                 return nick == u->nick;
+                               });
+  if (it != this->users.end())
+    this->users.erase(it);
+}
+
+void IrcChannel::remove_all_users()
+{
+  this->users.clear();
+  this->self.reset();
+}
+
+DummyIrcChannel::DummyIrcChannel():
+  IrcChannel(),
+  joining(false)
+{
+}
diff --git a/src/irc/irc_channel.hpp b/src/irc/irc_channel.hpp
new file mode 100644
index 0000000..2bcefaf
--- /dev/null
+++ b/src/irc/irc_channel.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+
+#include <irc/irc_user.hpp>
+#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+
+/**
+ * Keep the state of a joined channel (the list of occupants with their
+ * informations (mode, etc), the modes, etc)
+ */
+class IrcChannel
+{
+public:
+  explicit IrcChannel();
+
+  IrcChannel(const IrcChannel&) = delete;
+  IrcChannel(IrcChannel&&) = delete;
+  IrcChannel& operator=(const IrcChannel&) = delete;
+  IrcChannel& operator=(IrcChannel&&) = delete;
+
+  bool joined;
+  std::string topic;
+  std::string topic_author;
+  void set_self(const std::string& name);
+  IrcUser* get_self() const;
+  IrcUser* add_user(const std::string& name,
+                    const std::map<char, char>& prefix_to_mode);
+  IrcUser* find_user(const std::string& name) const;
+  void remove_user(const IrcUser* user);
+  void remove_all_users();
+  const std::vector<std::unique_ptr<IrcUser>>& get_users() const
+  { return this->users; }
+
+protected:
+  std::unique_ptr<IrcUser> self;
+  std::vector<std::unique_ptr<IrcUser>> users;
+};
+
+/**
+ * A special channel that is not actually linked to any real irc
+ * channel. This is just a channel representing a connection to the
+ * server. If an user wants to maintain the connection to the server without
+ * having to be on any irc channel of that server, he can just join this
+ * dummy channel.
+ * It’s not actually dummy because it’s useful and it does things, but well.
+ */
+class DummyIrcChannel: public IrcChannel
+{
+public:
+  explicit DummyIrcChannel();
+  DummyIrcChannel(const DummyIrcChannel&) = delete;
+  DummyIrcChannel(DummyIrcChannel&&) = delete;
+  DummyIrcChannel& operator=(const DummyIrcChannel&) = delete;
+  DummyIrcChannel& operator=(DummyIrcChannel&&) = delete;
+
+  /**
+   * This flag is at true whenever the user wants to join this channel, but
+   * he is not yet connected to the server. When the connection is made, we
+   * check that flag and if it’s true, we inform the user that he has just
+   * joined that channel.
+   * If the user is already connected to the server when he tries to join
+   * the channel, we don’t use that flag, we just join it immediately.
+   */
+  bool joining;
+};
+
+
diff --git a/src/irc/irc_client.cpp b/src/irc/irc_client.cpp
new file mode 100644
index 0000000..dd83307
--- /dev/null
+++ b/src/irc/irc_client.cpp
@@ -0,0 +1,1120 @@
+#include <utils/timed_events.hpp>
+#include <database/database.hpp>
+#include <irc/irc_message.hpp>
+#include <irc/irc_client.hpp>
+#include <bridge/bridge.hpp>
+#include <irc/irc_user.hpp>
+
+#include <logger/logger.hpp>
+#include <config/config.hpp>
+#include <utils/tolower.hpp>
+#include <utils/split.hpp>
+#include <utils/string.hpp>
+
+#include <sstream>
+#include <iostream>
+#include <stdexcept>
+#include <cstring>
+
+#include <chrono>
+#include <string>
+
+#include "biboumi.h"
+#include "louloulibs.h"
+
+using namespace std::string_literals;
+using namespace std::chrono_literals;
+
+/**
+ * Define a map of functions to be called for each IRC command we can
+ * handle.
+ */
+using IrcCallback = void (IrcClient::*)(const IrcMessage&);
+
+static const std::unordered_map<std::string,
+                                std::pair<IrcCallback, std::pair<std::size_t, std::size_t>>> irc_callbacks = {
+  {"NOTICE", {&IrcClient::on_notice, {2, 0}}},
+  {"002", {&IrcClient::forward_server_message, {2, 0}}},
+  {"003", {&IrcClient::forward_server_message, {2, 0}}},
+  {"004", {&IrcClient::on_server_myinfo, {4, 0}}},
+  {"005", {&IrcClient::on_isupport_message, {0, 0}}},
+  {"RPL_LISTSTART", {&IrcClient::on_rpl_liststart, {0, 0}}},
+  {"321", {&IrcClient::on_rpl_liststart, {0, 0}}},
+  {"RPL_LIST", {&IrcClient::on_rpl_list, {0, 0}}},
+  {"322", {&IrcClient::on_rpl_list, {0, 0}}},
+  {"RPL_LISTEND", {&IrcClient::on_rpl_listend, {0, 0}}},
+  {"323", {&IrcClient::on_rpl_listend, {0, 0}}},
+  {"RPL_NOTOPIC", {&IrcClient::on_empty_topic, {0, 0}}},
+  {"331", {&IrcClient::on_empty_topic, {0, 0}}},
+  {"RPL_MOTDSTART", {&IrcClient::empty_motd, {0, 0}}},
+  {"375", {&IrcClient::empty_motd, {0, 0}}},
+  {"RPL_MOTD", {&IrcClient::on_motd_line, {2, 0}}},
+  {"372", {&IrcClient::on_motd_line, {2, 0}}},
+  {"RPL_MOTDEND", {&IrcClient::send_motd, {0, 0}}},
+  {"376", {&IrcClient::send_motd, {0, 0}}},
+  {"JOIN", {&IrcClient::on_channel_join, {1, 0}}},
+  {"PRIVMSG", {&IrcClient::on_channel_message, {2, 0}}},
+  {"353", {&IrcClient::set_and_forward_user_list, {4, 0}}},
+  {"332", {&IrcClient::on_topic_received, {2, 0}}},
+  {"TOPIC", {&IrcClient::on_topic_received, {2, 0}}},
+  {"333", {&IrcClient::on_topic_who_time_received, {4, 0}}},
+  {"RPL_TOPICWHOTIME", {&IrcClient::on_topic_who_time_received, {4, 0}}},
+  {"366", {&IrcClient::on_channel_completely_joined, {2, 0}}},
+  {"396", {&IrcClient::on_own_host_received, {2, 0}}},
+  {"432", {&IrcClient::on_erroneous_nickname, {2, 0}}},
+  {"433", {&IrcClient::on_nickname_conflict, {2, 0}}},
+  {"438", {&IrcClient::on_nickname_change_too_fast, {2, 0}}},
+  {"001", {&IrcClient::on_welcome_message, {1, 0}}},
+  {"PART", {&IrcClient::on_part, {1, 0}}},
+  {"ERROR", {&IrcClient::on_error, {1, 0}}},
+  {"QUIT", {&IrcClient::on_quit, {0, 0}}},
+  {"NICK", {&IrcClient::on_nick, {1, 0}}},
+  {"MODE", {&IrcClient::on_mode, {1, 0}}},
+  {"PING", {&IrcClient::send_pong_command, {1, 0}}},
+  {"PONG", {&IrcClient::on_pong, {0, 0}}},
+  {"KICK", {&IrcClient::on_kick, {3, 0}}},
+
+  {"401", {&IrcClient::on_generic_error, {2, 0}}},
+  {"402", {&IrcClient::on_generic_error, {2, 0}}},
+  {"403", {&IrcClient::on_generic_error, {2, 0}}},
+  {"404", {&IrcClient::on_generic_error, {2, 0}}},
+  {"405", {&IrcClient::on_generic_error, {2, 0}}},
+  {"406", {&IrcClient::on_generic_error, {2, 0}}},
+  {"407", {&IrcClient::on_generic_error, {2, 0}}},
+  {"408", {&IrcClient::on_generic_error, {2, 0}}},
+  {"409", {&IrcClient::on_generic_error, {2, 0}}},
+  {"410", {&IrcClient::on_generic_error, {2, 0}}},
+  {"411", {&IrcClient::on_generic_error, {2, 0}}},
+  {"412", {&IrcClient::on_generic_error, {2, 0}}},
+  {"414", {&IrcClient::on_generic_error, {2, 0}}},
+  {"421", {&IrcClient::on_generic_error, {2, 0}}},
+  {"422", {&IrcClient::on_generic_error, {2, 0}}},
+  {"423", {&IrcClient::on_generic_error, {2, 0}}},
+  {"424", {&IrcClient::on_generic_error, {2, 0}}},
+  {"431", {&IrcClient::on_generic_error, {2, 0}}},
+  {"436", {&IrcClient::on_generic_error, {2, 0}}},
+  {"441", {&IrcClient::on_generic_error, {2, 0}}},
+  {"442", {&IrcClient::on_generic_error, {2, 0}}},
+  {"443", {&IrcClient::on_generic_error, {2, 0}}},
+  {"444", {&IrcClient::on_generic_error, {2, 0}}},
+  {"446", {&IrcClient::on_generic_error, {2, 0}}},
+  {"451", {&IrcClient::on_generic_error, {2, 0}}},
+  {"461", {&IrcClient::on_generic_error, {2, 0}}},
+  {"462", {&IrcClient::on_generic_error, {2, 0}}},
+  {"463", {&IrcClient::on_generic_error, {2, 0}}},
+  {"464", {&IrcClient::on_generic_error, {2, 0}}},
+  {"465", {&IrcClient::on_generic_error, {2, 0}}},
+  {"467", {&IrcClient::on_generic_error, {2, 0}}},
+  {"470", {&IrcClient::on_generic_error, {2, 0}}},
+  {"471", {&IrcClient::on_generic_error, {2, 0}}},
+  {"472", {&IrcClient::on_generic_error, {2, 0}}},
+  {"473", {&IrcClient::on_generic_error, {2, 0}}},
+  {"474", {&IrcClient::on_generic_error, {2, 0}}},
+  {"475", {&IrcClient::on_generic_error, {2, 0}}},
+  {"476", {&IrcClient::on_generic_error, {2, 0}}},
+  {"477", {&IrcClient::on_generic_error, {2, 0}}},
+  {"481", {&IrcClient::on_generic_error, {2, 0}}},
+  {"482", {&IrcClient::on_generic_error, {2, 0}}},
+  {"483", {&IrcClient::on_generic_error, {2, 0}}},
+  {"484", {&IrcClient::on_generic_error, {2, 0}}},
+  {"485", {&IrcClient::on_generic_error, {2, 0}}},
+  {"487", {&IrcClient::on_generic_error, {2, 0}}},
+  {"491", {&IrcClient::on_generic_error, {2, 0}}},
+  {"501", {&IrcClient::on_generic_error, {2, 0}}},
+  {"502", {&IrcClient::on_generic_error, {2, 0}}},
+};
+
+IrcClient::IrcClient(std::shared_ptr<Poller> poller, const std::string& hostname,
+                     const std::string& nickname, const std::string& username,
+                     const std::string& realname, const std::string& user_hostname,
+                     Bridge& bridge):
+  TCPSocketHandler(poller),
+  hostname(hostname),
+  user_hostname(user_hostname),
+  username(username),
+  realname(realname),
+  current_nick(nickname),
+  bridge(bridge),
+  welcomed(false),
+  chanmodes({"", "", "", ""}),
+  chantypes({'#', '&'})
+{
+  this->dummy_channel.topic = "This is a virtual channel provided for "
+                              "convenience by biboumi, it is not connected "
+                              "to any actual IRC channel of the server '" + this->hostname +
+                              "', and sending messages in it has no effect. "
+                              "Its main goal is to keep the connection to the IRC server "
+                              "alive without having to join a real channel of that server. "
+                              "To disconnect from the IRC server, leave this room and all "
+                              "other IRC channels of that server.";
+#ifdef USE_DATABASE
+  auto options = Database::get_irc_server_options(this->bridge.get_bare_jid(),
+                                                  this->get_hostname());
+  std::vector<std::string> ports = utils::split(options.ports, ';', false);
+  for (auto it = ports.rbegin(); it != ports.rend(); ++it)
+    this->ports_to_try.emplace(*it, false);
+# ifdef BOTAN_FOUND
+  ports = utils::split(options.tlsPorts, ';', false);
+  for (auto it = ports.rbegin(); it != ports.rend(); ++it)
+    this->ports_to_try.emplace(*it, true);
+# endif // BOTAN_FOUND
+
+#else  // not USE_DATABASE
+  this->ports_to_try.emplace("6667", false); // standard non-encrypted port
+# ifdef BOTAN_FOUND
+  this->ports_to_try.emplace("6670", true);  // non-standard but I want it for some servers
+  this->ports_to_try.emplace("6697", true);  // standard encrypted port
+# endif // BOTAN_FOUND
+#endif // USE_DATABASE
+}
+
+IrcClient::~IrcClient()
+{
+  // This event may or may not exist (if we never got connected, it
+  // doesn't), but it's ok
+  TimedEventsManager::instance().cancel("PING"s + this->hostname + this->bridge.get_jid());
+}
+
+void IrcClient::start()
+{
+  if (this->is_connecting() || this->is_connected())
+    return;
+  std::string port;
+  bool tls;
+  std::tie(port, tls) = this->ports_to_try.top();
+  this->ports_to_try.pop();
+  this->bridge.send_xmpp_message(this->hostname, "", "Connecting to "s +
+                                  this->hostname + ":" + port + " (" +
+                                  (tls ? "encrypted" : "not encrypted") + ")");
+
+  this->bind_addr = Config::get("outgoing_bind", "");
+
+#ifdef BOTAN_FOUND
+# ifdef USE_DATABASE
+  auto options = Database::get_irc_server_options(this->bridge.get_bare_jid(),
+                                                  this->get_hostname());
+  this->credential_manager.set_trusted_fingerprint(options.trustedFingerprint);
+# endif
+#endif
+  this->connect(this->hostname, port, tls);
+}
+
+void IrcClient::on_connection_failed(const std::string& reason)
+{
+  this->bridge.send_xmpp_message(this->hostname, "",
+                                  "Connection failed: "s + reason);
+
+  if (this->hostname_resolution_failed)
+    while (!this->ports_to_try.empty())
+      this->ports_to_try.pop();
+
+  if (this->ports_to_try.empty())
+    {
+      // Send an error message for all room that the user wanted to join
+      for (const auto& tuple: this->channels_to_join)
+        {
+          Iid iid(std::get<0>(tuple) + "%" + this->hostname);
+          this->bridge.send_presence_error(iid, this->current_nick,
+                                            "cancel", "item-not-found",
+                                            "", reason);
+        }
+    }
+  else                          // try the next port
+    this->start();
+}
+
+void IrcClient::on_connected()
+{
+  const auto webirc_password = Config::get("webirc_password", "");
+  static std::string resolved_ip;
+
+  if (!webirc_password.empty())
+    {
+      if (!resolved_ip.empty())
+        this->send_webirc_command(webirc_password, resolved_ip);
+      else
+        {  // Start resolving the hostname of the user, and call
+           // on_connected again when it’s done
+          this->dns_resolver.resolve(this->user_hostname, "5222",
+                                     [this](const struct addrinfo* addr)
+                                     {
+                                       resolved_ip = addr_to_string(addr);
+                                       // Only continue the process if we
+                                       // didn’t get connected while we were
+                                       // resolving
+                                       if (this->is_connected())
+                                         this->on_connected();
+                                     },
+                                     [this](const char* error_msg)
+                                     {
+                                       if (this->is_connected())
+                                         {
+                                           this->on_connection_close("Could not resolve hostname "s + this->user_hostname +
+                                                                     ": " + error_msg);
+                                           this->send_quit_command("");
+                                         }
+                                     });
+          return;
+        }
+    }
+
+  this->send_message({"CAP", {"REQ", "multi-prefix"}});
+  this->send_message({"CAP", {"END"}});
+
+#ifdef USE_DATABASE
+  auto options = Database::get_irc_server_options(this->bridge.get_bare_jid(),
+                                                  this->get_hostname());
+  if (!options.pass.value().empty())
+    this->send_pass_command(options.pass.value());
+#endif
+
+  this->send_nick_command(this->current_nick);
+
+#ifdef USE_DATABASE
+  if (Config::get("realname_customization", "true") == "true")
+    {
+      if (!options.username.value().empty())
+        this->username = options.username.value();
+      if (!options.realname.value().empty())
+        this->realname = options.realname.value();
+      this->send_user_command(username, realname);
+    }
+  else
+    this->send_user_command(this->username, this->realname);
+#else
+  this->send_user_command(this->username, this->realname);
+#endif
+  this->send_gateway_message("Connected to IRC server"s + (this->use_tls ? " (encrypted)": "") + ".");
+  this->send_pending_data();
+}
+
+void IrcClient::on_connection_close(const std::string& error_msg)
+{
+  std::string message = "Connection closed";
+  if (!error_msg.empty())
+    message += ": " + error_msg;
+  else
+    message += ".";
+  const IrcMessage error{"ERROR", {message}};
+  this->on_error(error);
+  log_warning(message);
+}
+
+IrcChannel* IrcClient::get_channel(const std::string& n)
+{
+  if (n.empty())
+    return &this->dummy_channel;
+  const std::string name = utils::tolower(n);
+  try
+    {
+      return this->channels.at(name).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      this->channels.emplace(name, std::make_unique<IrcChannel>());
+      return this->channels.at(name).get();
+    }
+}
+
+bool IrcClient::is_channel_joined(const std::string& name)
+{
+  IrcChannel* channel = this->get_channel(name);
+  return channel->joined;
+}
+
+std::string IrcClient::get_own_nick() const
+{
+  return this->current_nick;
+}
+
+void IrcClient::parse_in_buffer(const size_t)
+{
+  while (true)
+    {
+      auto pos = this->in_buf.find("\r\n");
+      if (pos == std::string::npos)
+        break ;
+      IrcMessage message(this->in_buf.substr(0, pos));
+      this->in_buf = this->in_buf.substr(pos + 2, std::string::npos);
+      log_debug("IRC RECEIVING: (", this->get_hostname(), ") ", message);
+
+      // Call the standard callback (if any), associated with the command
+      // name that we just received.
+      auto it = irc_callbacks.find(message.command);
+      if (it != irc_callbacks.end())
+        {
+          const auto& limits = it->second.second;
+          // Check that the Message is well formed before actually calling
+          // the callback. limits.first is the min number of arguments,
+          // second is the max
+          if (message.arguments.size() < limits.first ||
+              (limits.second > 0 && message.arguments.size() > limits.second))
+            log_warning("Invalid number of arguments for IRC command “", message.command,
+                        "”: ", message.arguments.size());
+          else
+            {
+              const auto& cb = it->second.first;
+              try {
+                (this->*(cb))(message);
+              } catch (const std::exception& e) {
+                log_error("Unhandled exception: ", e.what());
+              }
+            }
+        }
+      else
+        {
+          log_info("No handler for command ", message.command,
+                   ", forwarding the arguments to the user");
+          this->on_unknown_message(message);
+        }
+      // Try to find a waiting_iq, which response will be triggered by this IrcMessage
+      this->bridge.trigger_on_irc_message(this->hostname, message);
+    }
+}
+
+void IrcClient::send_message(IrcMessage&& message)
+{
+  log_debug("IRC SENDING: (", this->get_hostname(), ") ", message);
+  std::string res;
+  if (!message.prefix.empty())
+    res += ":" + std::move(message.prefix) + " ";
+  res += std::move(message.command);
+  for (const std::string& arg: message.arguments)
+    {
+      if (arg.find(" ") != std::string::npos ||
+          (!arg.empty() && arg[0] == ':'))
+        {
+          res += " :" + arg;
+          break;
+        }
+      res += " " + arg;
+    }
+  res += "\r\n";
+  this->send_data(std::move(res));
+}
+
+void IrcClient::send_raw(const std::string& txt)
+{
+  log_debug("IRC SENDING (raw): (", this->get_hostname(), ") ", txt);
+  this->send_data(txt + "\r\n");
+}
+
+void IrcClient::send_user_command(const std::string& username, const std::string& realname)
+{
+  this->send_message(IrcMessage("USER", {username, this->user_hostname, "ignored", realname}));
+}
+
+void IrcClient::send_nick_command(const std::string& nick)
+{
+  this->send_message(IrcMessage("NICK", {nick}));
+}
+
+void IrcClient::send_pass_command(const std::string& password)
+{
+  this->send_message(IrcMessage("PASS", {password}));
+}
+
+void IrcClient::send_webirc_command(const std::string& password, const std::string& user_ip)
+{
+  this->send_message(IrcMessage("WEBIRC", {password, "biboumi", this->user_hostname, user_ip}));
+}
+
+void IrcClient::send_kick_command(const std::string& chan_name, const std::string& target, const std::string& reason)
+{
+  this->send_message(IrcMessage("KICK", {chan_name, target, reason}));
+}
+
+void IrcClient::send_list_command()
+{
+  this->send_message(IrcMessage("LIST", {}));
+}
+
+void IrcClient::send_topic_command(const std::string& chan_name, const std::string& topic)
+{
+  this->send_message(IrcMessage("TOPIC", {chan_name, topic}));
+}
+
+void IrcClient::send_quit_command(const std::string& reason)
+{
+  this->send_message(IrcMessage("QUIT", {reason}));
+}
+
+void IrcClient::send_join_command(const std::string& chan_name, const std::string& password)
+{
+  if (this->welcomed == false)
+    this->channels_to_join.emplace_back(chan_name, password);
+  else if (password.empty())
+    this->send_message(IrcMessage("JOIN", {chan_name}));
+  else
+    this->send_message(IrcMessage("JOIN", {chan_name, password}));
+  this->start();
+}
+
+bool IrcClient::send_channel_message(const std::string& chan_name, const std::string& body)
+{
+  IrcChannel* channel = this->get_channel(chan_name);
+  if (channel->joined == false)
+    {
+      log_warning("Cannot send message to channel ", chan_name, ", it is not joined");
+      return false;
+    }
+  // The max size is 512, taking into account the whole message, not just
+  // the text we send.
+  // This includes our own nick, username and host (because this will be
+  // added by the server into our message), in addition to the basic
+  // components of the message we send (command name, chan name, \r\n et)
+  //  : + NICK + ! + USER + @ + HOST + <space> + PRIVMSG + <space> + CHAN + <space> + : + \r\n
+  const auto line_size = 512 -
+                         this->current_nick.size() - this->username.size() - this->own_host.size() -
+                         ::strlen(":!@ PRIVMSG ") - chan_name.length() - ::strlen(" :\r\n");
+  const auto lines = cut(body, line_size);
+  for (const auto& line: lines)
+    this->send_message(IrcMessage("PRIVMSG", {chan_name, line}));
+  return true;
+}
+
+void IrcClient::send_private_message(const std::string& username, const std::string& body, const std::string& type)
+{
+  std::string::size_type pos = 0;
+  while (pos < body.size())
+    {
+      this->send_message(IrcMessage(std::string(type), {username, body.substr(pos, 400)}));
+      pos += 400;
+    }
+  // We always try to insert and we don't care if the username was already
+  // in the set.
+  this->nicks_to_treat_as_private.insert(username);
+}
+
+void IrcClient::send_part_command(const std::string& chan_name, const std::string& status_message)
+{
+  IrcChannel* channel = this->get_channel(chan_name);
+  if (channel->joined == true)
+    {
+      if (chan_name.empty())
+        this->leave_dummy_channel(status_message);
+      else
+        this->send_message(IrcMessage("PART", {chan_name, status_message}));
+    }
+}
+
+void IrcClient::send_mode_command(const std::string& chan_name, const std::vector<std::string>& arguments)
+{
+  std::vector<std::string> args(arguments);
+  args.insert(args.begin(), chan_name);
+  IrcMessage m("MODE", std::move(args));
+  this->send_message(std::move(m));
+}
+
+void IrcClient::send_pong_command(const IrcMessage& message)
+{
+  const std::string id = message.arguments[0];
+  this->send_message(IrcMessage("PONG", {id}));
+}
+
+void IrcClient::on_pong(const IrcMessage&)
+{
+}
+
+void IrcClient::send_ping_command()
+{
+  this->send_message(IrcMessage("PING", {"biboumi"}));
+}
+
+void IrcClient::forward_server_message(const IrcMessage& message)
+{
+  const std::string from = message.prefix;
+  const std::string body = message.arguments[1];
+
+  this->bridge.send_xmpp_message(this->hostname, from, body);
+}
+
+void IrcClient::on_notice(const IrcMessage& message)
+{
+  std::string from = message.prefix;
+  const std::string to = message.arguments[0];
+  const std::string body = message.arguments[1];
+
+  if (!body.empty() && body[0] == '\01' && body[body.size() - 1] == '\01')
+    // Do not forward the notice to the user if it's a CTCP command
+    return ;
+
+  if (!to.empty() && this->chantypes.find(to[0]) == this->chantypes.end())
+    {
+      // The notice is for us precisely.
+
+      // Find out if we already sent a private message to this user. If yes
+      // we treat that message as a private message coming from
+      // it. Otherwise we treat it as a notice coming from the server.
+      IrcUser user(from);
+      std::string nick = utils::tolower(user.nick);
+      if (this->nicks_to_treat_as_private.find(nick) !=
+          this->nicks_to_treat_as_private.end())
+        { // We previously sent a message to that nick)
+          this->bridge.send_message({nick + "!" + this->hostname}, nick, body,
+                                     false);
+        }
+      else
+        this->bridge.send_xmpp_message(this->hostname, from, body);
+    }
+  else
+    {
+      // The notice was directed at a channel we are in. Modify the message
+      // to indicate that it is a notice, and make it a MUC message coming
+      // from the MUC JID
+      IrcMessage modified_message(std::move(from), "PRIVMSG", {to, "\u000303[notice]\u0003 "s + body});
+      this->on_channel_message(modified_message);
+    }
+}
+
+void IrcClient::on_isupport_message(const IrcMessage& message)
+{
+  const size_t len = message.arguments.size();
+  for (size_t i = 1; i < len; ++i)
+  {
+    const std::string token = message.arguments[i];
+    if (token.substr(0, 10) == "CHANMODES=")
+    {
+      this->chanmodes = utils::split(token.substr(11), ',');
+      // make sure we have 4 strings
+      this->chanmodes.resize(4);
+    }
+    else if (token.substr(0, 7) == "PREFIX=")
+      {
+        size_t i = 8;           // jump PREFIX=(
+        size_t j = 9;
+        // Find the ) char
+        while (j < token.size() && token[j] != ')')
+          j++;
+        j++;
+        while (j < token.size() && token[i] != ')')
+          {
+            this->sorted_user_modes.push_back(token[i]);
+            this->prefix_to_mode[token[j++]] = token[i++];
+          }
+      }
+    else if (token.substr(0, 10) == "CHANTYPES=")
+      {
+        // Remove the default types, they apply only if no other value is
+        // specified.
+        this->chantypes.clear();
+        size_t i = 10;
+        while (i < token.size())
+          this->chantypes.insert(token[i++]);
+      }
+  }
+}
+
+void IrcClient::on_server_myinfo(const IrcMessage&)
+{
+}
+
+void IrcClient::send_gateway_message(const std::string& message, const std::string& from)
+{
+  this->bridge.send_xmpp_message(this->hostname, from, message);
+}
+
+void IrcClient::set_and_forward_user_list(const IrcMessage& message)
+{
+  const std::string chan_name = utils::tolower(message.arguments[2]);
+  IrcChannel* channel = this->get_channel(chan_name);
+  std::vector<std::string> nicks = utils::split(message.arguments[3], ' ');
+  for (const std::string& nick: nicks)
+    {
+      const IrcUser* user = channel->add_user(nick, this->prefix_to_mode);
+      if (user->nick != channel->get_self()->nick)
+        {
+          this->bridge.send_user_join(this->hostname, chan_name, user, user->get_most_significant_mode(this->sorted_user_modes), false);
+        }
+      else
+        {
+          // we now know the modes of self, so copy the modes into self
+          channel->get_self()->modes = user->modes;
+        }
+    }
+}
+
+void IrcClient::on_channel_join(const IrcMessage& message)
+{
+  const std::string chan_name = utils::tolower(message.arguments[0]);
+  IrcChannel* channel;
+  if (chan_name.empty())
+    channel = &this->dummy_channel;
+  else
+    channel = this->get_channel(chan_name);
+  const std::string nick = message.prefix;
+  if (channel->joined == false)
+    channel->set_self(nick);
+  else
+    {
+      const IrcUser* user = channel->add_user(nick, this->prefix_to_mode);
+      this->bridge.send_user_join(this->hostname, chan_name, user, user->get_most_significant_mode(this->sorted_user_modes), false);
+    }
+}
+
+void IrcClient::on_channel_message(const IrcMessage& message)
+{
+  const IrcUser user(message.prefix);
+  const std::string nick = user.nick;
+  Iid iid;
+  iid.set_local(message.arguments[0]);
+  iid.set_server(this->hostname);
+  const std::string body = message.arguments[1];
+  bool muc = true;
+  if (!this->get_channel(iid.get_local())->joined)
+    {
+      iid.is_user = true;
+      iid.set_local(nick);
+      muc = false;
+    }
+  else
+    iid.is_channel = true;
+  if (!body.empty() && body[0] == '\01')
+    {
+      if (body.substr(1, 6) == "ACTION")
+        this->bridge.send_message(iid, nick,
+                  "/me"s + body.substr(7, body.size() - 8), muc);
+      else if (body.substr(1, 8) == "VERSION\01")
+        this->bridge.send_iq_version_request(nick, this->hostname);
+      else if (body.substr(1, 5) == "PING ")
+        this->bridge.send_xmpp_ping_request(utils::tolower(nick), this->hostname,
+                                             body.substr(6, body.size() - 7));
+    }
+  else
+    this->bridge.send_message(iid, nick, body, muc);
+}
+
+void IrcClient::on_rpl_liststart(const IrcMessage&)
+{
+}
+
+void IrcClient::on_rpl_list(const IrcMessage&)
+{
+}
+
+void IrcClient::on_rpl_listend(const IrcMessage&)
+{
+}
+
+void IrcClient::empty_motd(const IrcMessage&)
+{
+  this->motd.erase();
+}
+
+void IrcClient::on_empty_topic(const IrcMessage& message)
+{
+  const std::string chan_name = utils::tolower(message.arguments[1]);
+  log_debug("empty topic for ", chan_name);
+  IrcChannel* channel = this->get_channel(chan_name);
+  if (channel)
+    channel->topic.clear();
+}
+
+void IrcClient::on_motd_line(const IrcMessage& message)
+{
+  const std::string body = message.arguments[1];
+  // We could send the MOTD without a line break between each IRC-message,
+  // but sometimes it contains some ASCII art, we use line breaks to keep
+  // them intact.
+  this->motd += body+"\n";
+}
+
+void IrcClient::send_motd(const IrcMessage&)
+{
+  this->bridge.send_xmpp_message(this->hostname, "", this->motd);
+}
+
+void IrcClient::on_topic_received(const IrcMessage& message)
+{
+  const std::string chan_name = utils::tolower(message.arguments[message.arguments.size() - 2]);
+  IrcUser author(message.prefix);
+  IrcChannel* channel = this->get_channel(chan_name);
+  channel->topic = message.arguments[message.arguments.size() - 1];
+  channel->topic_author = author.nick;
+  if (channel->joined)
+    this->bridge.send_topic(this->hostname, chan_name, channel->topic, channel->topic_author);
+}
+
+void IrcClient::on_topic_who_time_received(const IrcMessage& message)
+{
+  IrcUser author(message.arguments[2]);
+  const std::string chan_name = utils::tolower(message.arguments[1]);
+  IrcChannel* channel = this->get_channel(chan_name);
+  channel->topic_author = author.nick;
+}
+
+void IrcClient::on_channel_completely_joined(const IrcMessage& message)
+{
+  const std::string chan_name = utils::tolower(message.arguments[1]);
+  IrcChannel* channel = this->get_channel(chan_name);
+  channel->joined = true;
+  this->bridge.send_user_join(this->hostname, chan_name, channel->get_self(), channel->get_self()->get_most_significant_mode(this->sorted_user_modes), true);
+  this->bridge.send_topic(this->hostname, chan_name, channel->topic, channel->topic_author);
+}
+
+void IrcClient::on_own_host_received(const IrcMessage& message)
+{
+  this->own_host = message.arguments[1];
+  const std::string from = message.prefix;
+  if (message.arguments.size() >= 3)
+    this->bridge.send_xmpp_message(this->hostname, from,
+                                   this->own_host + " " + message.arguments[2]);
+  else
+    this->bridge.send_xmpp_message(this->hostname, from, this->own_host +
+                                                         " is now your displayed host");
+}
+
+void IrcClient::on_erroneous_nickname(const IrcMessage& message)
+{
+  const std::string error_msg = message.arguments.size() >= 3 ?
+    message.arguments[2]: "Erroneous nickname";
+  this->send_gateway_message(error_msg + ": " + message.arguments[1], message.prefix);
+}
+
+void IrcClient::on_nickname_conflict(const IrcMessage& message)
+{
+  const std::string nickname = message.arguments[1];
+  this->on_generic_error(message);
+  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  {
+    Iid iid;
+    iid.set_local(it->first);
+    iid.set_server(this->hostname);
+    iid.is_channel = true;
+    this->bridge.send_nickname_conflict_error(iid, nickname);
+  }
+}
+
+void IrcClient::on_nickname_change_too_fast(const IrcMessage& message)
+{
+  const std::string nickname = message.arguments[1];
+  std::string txt;
+  if (message.arguments.size() >= 3)
+    txt = message.arguments[2];
+  this->on_generic_error(message);
+  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  {
+    Iid iid;
+    iid.set_local(it->first);
+    iid.set_server(this->hostname);
+    iid.is_channel = true;
+    this->bridge.send_presence_error(iid, nickname,
+                                      "cancel", "not-acceptable",
+                                      "", txt);
+  }
+}
+
+void IrcClient::on_generic_error(const IrcMessage& message)
+{
+  const std::string error_msg = message.arguments.size() >= 3 ?
+    message.arguments[2]: "Unspecified error";
+  this->send_gateway_message(message.arguments[1] + ": " + error_msg, message.prefix);
+}
+
+void IrcClient::on_welcome_message(const IrcMessage& message)
+{
+  this->current_nick = message.arguments[0];
+  this->welcomed = true;
+#ifdef USE_DATABASE
+  auto options = Database::get_irc_server_options(this->bridge.get_bare_jid(),
+                                                  this->get_hostname());
+  if (!options.afterConnectionCommand.value().empty())
+    this->send_raw(options.afterConnectionCommand.value());
+#endif
+  // Install a repeated events to regularly send a PING
+  TimedEventsManager::instance().add_event(TimedEvent(240s, std::bind(&IrcClient::send_ping_command, this),
+                                                      "PING"s + this->hostname + this->bridge.get_jid()));
+  for (const auto& tuple: this->channels_to_join)
+    this->send_join_command(std::get<0>(tuple), std::get<1>(tuple));
+  this->channels_to_join.clear();
+  // Indicate that the dummy channel is joined as well, if needed
+  if (this->dummy_channel.joining)
+    {
+      // Simulate a message coming from the IRC server saying that we joined
+      // the channel
+      const IrcMessage join_message(this->get_nick(), "JOIN", {""});
+      this->on_channel_join(join_message);
+      const IrcMessage end_join_message(std::string(this->hostname), "366",
+                                        {this->get_nick(),
+                                            "", "End of NAMES list"});
+      this->on_channel_completely_joined(end_join_message);
+    }
+}
+
+void IrcClient::on_part(const IrcMessage& message)
+{
+  const std::string chan_name = message.arguments[0];
+  IrcChannel* channel = this->get_channel(chan_name);
+  if (!channel->joined)
+    return ;
+  std::string txt;
+  if (message.arguments.size() >= 2)
+    txt = message.arguments[1];
+  const IrcUser* user = channel->find_user(message.prefix);
+  if (user)
+    {
+      std::string nick = user->nick;
+      channel->remove_user(user);
+      Iid iid;
+      iid.set_local(chan_name);
+      iid.set_server(this->hostname);
+      iid.is_channel = true;
+      bool self = channel->get_self()->nick == nick;
+      if (self)
+      {
+        channel->joined = false;
+        this->channels.erase(utils::tolower(chan_name));
+        // channel pointer is now invalid
+        channel = nullptr;
+      }
+      this->bridge.send_muc_leave(std::move(iid), std::move(nick), std::move(txt), self);
+    }
+}
+
+void IrcClient::on_error(const IrcMessage& message)
+{
+  const std::string leave_message = message.arguments[0];
+  // The user is out of all the channels
+  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  {
+    Iid iid;
+    iid.set_local(it->first);
+    iid.set_server(this->hostname);
+    iid.is_channel = true;
+    IrcChannel* channel = it->second.get();
+    if (!channel->joined)
+      continue;
+    std::string own_nick = channel->get_self()->nick;
+    this->bridge.send_muc_leave(std::move(iid), std::move(own_nick), leave_message, true);
+  }
+  this->channels.clear();
+  this->send_gateway_message("ERROR: "s + leave_message);
+}
+
+void IrcClient::on_quit(const IrcMessage& message)
+{
+  std::string txt;
+  if (message.arguments.size() >= 1)
+    txt = message.arguments[0];
+  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+    {
+      const std::string chan_name = it->first;
+      IrcChannel* channel = it->second.get();
+      const IrcUser* user = channel->find_user(message.prefix);
+      if (user)
+        {
+          std::string nick = user->nick;
+          channel->remove_user(user);
+          Iid iid;
+          iid.set_local(chan_name);
+          iid.set_server(this->hostname);
+          iid.is_channel = true;
+          this->bridge.send_muc_leave(std::move(iid), std::move(nick), txt, false);
+        }
+    }
+}
+
+void IrcClient::on_nick(const IrcMessage& message)
+{
+  const std::string new_nick = message.arguments[0];
+  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+    {
+      const std::string chan_name = it->first;
+      IrcChannel* channel = it->second.get();
+      IrcUser* user = channel->find_user(message.prefix);
+      if (user)
+        {
+          std::string old_nick = user->nick;
+          Iid iid;
+          iid.set_local(chan_name);
+          iid.set_server(this->hostname);
+          iid.is_channel = true;
+          const bool self = channel->get_self()->nick == old_nick;
+          const char user_mode = user->get_most_significant_mode(this->sorted_user_modes);
+          this->bridge.send_nick_change(std::move(iid), old_nick, new_nick, user_mode, self);
+          user->nick = new_nick;
+          if (self)
+            {
+              channel->get_self()->nick = new_nick;
+              this->current_nick = new_nick;
+            }
+        }
+    }
+}
+
+void IrcClient::on_kick(const IrcMessage& message)
+{
+  const std::string chan_name = utils::tolower(message.arguments[0]);
+  const std::string target = message.arguments[1];
+  const std::string reason = message.arguments[2];
+  IrcChannel* channel = this->get_channel(chan_name);
+  if (!channel->joined)
+    return ;
+  if (channel->get_self()->nick == target)
+    channel->joined = false;
+  IrcUser author(message.prefix);
+  Iid iid;
+  iid.set_local(chan_name);
+  iid.set_server(this->hostname);
+  iid.is_channel = true;
+  this->bridge.kick_muc_user(std::move(iid), target, reason, author.nick);
+}
+
+void IrcClient::on_mode(const IrcMessage& message)
+{
+  const std::string target = message.arguments[0];
+  if (this->chantypes.find(target[0]) != this->chantypes.end())
+    this->on_channel_mode(message);
+  else
+    this->on_user_mode(message);
+}
+
+void IrcClient::on_channel_mode(const IrcMessage& message)
+{
+  // For now, just transmit the modes so the user can know what happens
+  // TODO, actually interprete the mode.
+  Iid iid;
+  iid.set_local(message.arguments[0]);
+  iid.set_server(this->hostname);
+  iid.is_channel = true;
+  IrcUser user(message.prefix);
+  std::string mode_arguments;
+  for (size_t i = 1; i < message.arguments.size(); ++i)
+    {
+      if (!message.arguments[i].empty())
+        {
+          if (i != 1)
+            mode_arguments += " ";
+          mode_arguments += message.arguments[i];
+        }
+    }
+  this->bridge.send_message(iid, "", "Mode "s + iid.get_local() +
+                                      " [" + mode_arguments + "] by " + user.nick,
+                             true);
+  const IrcChannel* channel = this->get_channel(iid.get_local());
+  if (!channel)
+    return;
+
+  // parse the received modes, we need to handle things like "+m-oo coucou toutou"
+  const std::string modes = message.arguments[1];
+  // a list of modified IrcUsers. When we applied all modes, we check the
+  // modes that now applies to each of them, and send a notification for
+  // each one. This is to disallow sending two notifications or more when a
+  // single MODE command changes two or more modes on the same participant
+  std::set<const IrcUser*> modified_users;
+  // If it is true, the modes are added, if it’s false they are
+  // removed. When we encounter the '+' char, the value is changed to true,
+  // and with '-' it is changed to false.
+  bool add = true;
+  bool use_arg;
+  size_t arg_pos = 2;
+  for (const char c: modes)
+    {
+      if (c == '+')
+        add = true;
+      else if (c == '-')
+        add = false;
+      else
+        { // lookup the mode symbol in the 4 chanmodes lists, depending on
+          // the list where it is found, it takes an argument or not
+          size_t type;
+          for (type = 0; type < 4; ++type)
+            if (this->chanmodes[type].find(c) != std::string::npos)
+              break;
+          if (type == 4)        // if mode was not found
+            {
+              // That mode can also be of type B if it is present in the
+              // prefix_to_mode map
+              for (const std::pair<char, char>& pair: this->prefix_to_mode)
+                if (pair.second == c)
+                  {
+                    type = 1;
+                    break;
+                  }
+            }
+          // modes of type A, B or C (but only with add == true)
+          if (type == 0 || type == 1 ||
+              (type == 2 && add == true))
+            use_arg = true;
+          else // modes of type C (but only with add == false), D, or unknown
+            use_arg = false;
+          if (use_arg == true && message.arguments.size() > arg_pos)
+            {
+              const std::string target = message.arguments[arg_pos++];
+              IrcUser* user = channel->find_user(target);
+              if (!user)
+                {
+                  log_warning("Trying to set mode for non-existing user '", target
+                             , "' in channel", iid.get_local());
+                  return;
+                }
+              if (add)
+                user->add_mode(c);
+              else
+                user->remove_mode(c);
+              modified_users.insert(user);
+            }
+        }
+    }
+  for (const IrcUser* u: modified_users)
+    {
+      char most_significant_mode = u->get_most_significant_mode(this->sorted_user_modes);
+      this->bridge.send_affiliation_role_change(iid, u->nick, most_significant_mode);
+    }
+}
+
+void IrcClient::on_user_mode(const IrcMessage& message)
+{
+  this->bridge.send_xmpp_message(this->hostname, "",
+                                  "User mode for "s + message.arguments[0] +
+                                  " is [" + message.arguments[1] + "]");
+}
+
+void IrcClient::on_unknown_message(const IrcMessage& message)
+{
+  if (message.arguments.size() < 2)
+    return ;
+  std::string from = message.prefix;
+  std::stringstream ss;
+  for (auto it = message.arguments.begin() + 1; it != message.arguments.end(); ++it)
+    {
+      ss << *it;
+      if (it + 1 != message.arguments.end())
+        ss << " ";
+    }
+  this->bridge.send_xmpp_message(this->hostname, from, ss.str());
+}
+
+size_t IrcClient::number_of_joined_channels() const
+{
+  if (this->dummy_channel.joined)
+    return this->channels.size() + 1;
+  else
+    return this->channels.size();
+}
+
+DummyIrcChannel& IrcClient::get_dummy_channel()
+{
+  return this->dummy_channel;
+}
+
+void IrcClient::leave_dummy_channel(const std::string& exit_message)
+{
+  if (!this->dummy_channel.joined)
+    return;
+  this->dummy_channel.joined = false;
+  this->dummy_channel.joining = false;
+  this->dummy_channel.remove_all_users();
+  this->bridge.send_muc_leave(Iid("%"s + this->hostname), std::string(this->current_nick), exit_message, true);
+}
+
+#ifdef BOTAN_FOUND
+bool IrcClient::abort_on_invalid_cert() const
+{
+#ifdef USE_DATABASE
+  auto options = Database::get_irc_server_options(this->bridge.get_bare_jid(), this->hostname);
+  return options.verifyCert.value();
+#endif
+  return true;
+}
+#endif
diff --git a/src/irc/irc_client.hpp b/src/irc/irc_client.hpp
new file mode 100644
index 0000000..fc3918e
--- /dev/null
+++ b/src/irc/irc_client.hpp
@@ -0,0 +1,383 @@
+#pragma once
+
+
+#include <irc/irc_message.hpp>
+#include <irc/irc_channel.hpp>
+#include <irc/iid.hpp>
+
+#include <network/tcp_socket_handler.hpp>
+#include <network/resolver.hpp>
+
+#include <unordered_map>
+#include <utility>
+#include <memory>
+#include <vector>
+#include <string>
+#include <stack>
+#include <map>
+#include <set>
+
+class Bridge;
+
+/**
+ * Represent one IRC client, i.e. an endpoint connected to a single IRC
+ * server, through a TCP socket, receiving and sending commands to it.
+ */
+class IrcClient: public TCPSocketHandler
+{
+public:
+  explicit IrcClient(std::shared_ptr<Poller> poller, const std::string& hostname,
+                     const std::string& nickname, const std::string& username,
+                     const std::string& realname, const std::string& user_hostname,
+                     Bridge& bridge);
+  ~IrcClient();
+
+  IrcClient(const IrcClient&) = delete;
+  IrcClient(IrcClient&&) = delete;
+  IrcClient& operator=(const IrcClient&) = delete;
+  IrcClient& operator=(IrcClient&&) = delete;
+
+  /**
+   * Connect to the IRC server
+   */
+  void start();
+  /**
+   * Called when the connection to the server cannot be established
+   */
+  void on_connection_failed(const std::string& reason) override final;
+  /**
+   * Called when successfully connected to the server
+   */
+  void on_connected() override final;
+  /**
+   * Close the connection, remove us from the poller
+   */
+  void on_connection_close(const std::string& error) override final;
+  /**
+   * Parse the data we have received so far and try to get one or more
+   * complete messages from it.
+   */
+  void parse_in_buffer(const size_t) override final;
+#ifdef BOTAN_FOUND
+  virtual bool abort_on_invalid_cert() const override final;
+#endif
+  /**
+   * Return the channel with this name, create it if it does not yet exist
+   */
+  IrcChannel* get_channel(const std::string& name);
+  /**
+   * Returns true if the channel is joined
+   */
+  bool is_channel_joined(const std::string& name);
+  /**
+   * Return our own nick
+   */
+  std::string get_own_nick() const;
+  /**
+   * Serialize the given message into a line, and send that into the socket
+   * (actually, into our out_buf and signal the poller that we want to wach
+   * for send events to be ready)
+   */
+  void send_message(IrcMessage&& message);
+  void send_raw(const std::string& txt);
+  /**
+   * Send the PONG irc command
+   */
+  void send_pong_command(const IrcMessage& message);
+  /**
+   * Do nothing when we receive a PONG command (but also do not log that no
+   * handler exist)
+   */
+  void on_pong(const IrcMessage& message);
+  void send_ping_command();
+  /**
+   * Send the USER irc command
+   */
+  void send_user_command(const std::string& username, const std::string& realname);
+  /**
+   * Send the NICK irc command
+   */
+  void send_nick_command(const std::string& username);
+  void send_pass_command(const std::string& password);
+  void send_webirc_command(const std::string& password, const std::string& user_ip);
+  /**
+   * Send the JOIN irc command.
+   */
+  void send_join_command(const std::string& chan_name, const std::string& password);
+  /**
+   * Send a PRIVMSG command for a channel
+   * Return true if the message was actually sent
+   */
+  bool send_channel_message(const std::string& chan_name, const std::string& body);
+  /**
+   * Send a PRIVMSG command for an user
+   */
+  void send_private_message(const std::string& username, const std::string& body, const std::string& type);
+  /**
+   * Send the PART irc command
+   */
+  void send_part_command(const std::string& chan_name, const std::string& status_message);
+  /**
+   * Send the MODE irc command
+   */
+  void send_mode_command(const std::string& chan_name, const std::vector<std::string>& arguments);
+  /**
+   * Send the KICK irc command
+   */
+  void send_kick_command(const std::string& chan_name, const std::string& target, const std::string& reason);
+  /**
+   * Send the LIST irc command
+   */
+  void send_list_command();
+  void send_topic_command(const std::string& chan_name, const std::string& topic);
+  /**
+   * Send the QUIT irc command
+   */
+  void send_quit_command(const std::string& reason);
+  /**
+   * Send a message to the gateway user, not generated by the IRC server,
+   * but that might be useful because we want to be verbose (for example we
+   * might want to notify the user about the connexion state)
+   */
+  void send_gateway_message(const std::string& message, const std::string& from="");
+  /**
+   * Forward the server message received from IRC to the XMPP component
+   */
+  void forward_server_message(const IrcMessage& message);
+  /**
+   * When receiving the isupport informations.  See
+   * http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt
+   */
+  void on_isupport_message(const IrcMessage& message);
+  /**
+   * Does nothing yet. Isn’t that duplicating features from 005?
+   */
+  void on_server_myinfo(const IrcMessage& message);
+  /**
+   * Just empty the motd we kept as a string
+   */
+  void empty_motd(const IrcMessage& message);
+  /**
+   * Send the MOTD string as one single "big" message
+   */
+  void send_motd(const IrcMessage& message);
+  /**
+   * Append this line to the MOTD
+   */
+  void on_motd_line(const IrcMessage& message);
+  /**
+   * Forward the join of an other user into an IRC channel, and save the
+   * IrcUsers in the IrcChannel
+   */
+  void set_and_forward_user_list(const IrcMessage& message);
+  /**
+   * Signal the start of the LIST response. The RFC says its obsolete and
+   * “not used”, but I we receive it on some servers, so just ignore it.
+   */
+  void on_rpl_liststart(const IrcMessage& message);
+  /**
+   * A single LIST response line (one channel)
+   *
+   * The command is handled in a wait_irc callback. This general handler is
+   * empty and just used to avoid sending a message stanza for each received
+   * channel.
+   */
+  void on_rpl_list(const IrcMessage& message);
+  /**
+   * Signal the end of the LIST response, ignore.
+   */
+  void on_rpl_listend(const IrcMessage& message);
+  /**
+   * Remember our nick and host, when we are joined to the channel. The list
+   * of user comes after so we do not send the self-presence over XMPP yet.
+   */
+  void on_channel_join(const IrcMessage& message);
+  /**
+   * When a channel message is received
+   */
+  void on_channel_message(const IrcMessage& message);
+  /**
+   * A notice is received
+   */
+  void on_notice(const IrcMessage& message);
+  /**
+   * Save the topic in the IrcChannel
+   */
+  void on_topic_received(const IrcMessage& message);
+  /**
+   * Save the topic author in the IrcChannel
+   */
+  void on_topic_who_time_received(const IrcMessage& message);
+  /**
+   * Empty the topic
+   */
+  void on_empty_topic(const IrcMessage& message);
+  /**
+   * The channel has been completely joined (self presence, topic, all names
+   * received etc), send the self presence and topic to the XMPP user.
+   */
+  void on_channel_completely_joined(const IrcMessage& message);
+  /**
+   * Save our own host, as reported by the server
+   */
+  void on_own_host_received(const IrcMessage& message);
+  /**
+   * We tried to set an invalid nickname
+   */
+  void on_erroneous_nickname(const IrcMessage& message);
+  /**
+   * When the IRC servers denies our nickname because of a conflict.  Send a
+   * presence conflict from all channels, because the name is server-wide.
+   */
+  void on_nickname_conflict(const IrcMessage& message);
+  /**
+   * Idem, but for when the user changes their nickname too quickly
+   */
+  void on_nickname_change_too_fast(const IrcMessage& message);
+  /**
+   * Handles most errors from the server by just forwarding the message to the user.
+   */
+  void on_generic_error(const IrcMessage& message);
+  /**
+   * When a message 001 is received, join the rooms we wanted to join, and set our actual nickname
+   */
+  void on_welcome_message(const IrcMessage& message);
+  void on_part(const IrcMessage& message);
+  void on_error(const IrcMessage& message);
+  void on_nick(const IrcMessage& message);
+  void on_kick(const IrcMessage& message);
+  void on_mode(const IrcMessage& message);
+  /**
+   * A mode towards our own user is received (note, that is different from a
+   * channel mode towards or own nick, see
+   * http://tools.ietf.org/html/rfc2812#section-3.1.5 VS #section-3.2.3)
+   */
+  void on_user_mode(const IrcMessage& message);
+  /**
+   * A mode towards a channel. Note that this can change the mode of the
+   * channel itself or an IrcUser in it.
+   */
+  void on_channel_mode(const IrcMessage& message);
+  void on_quit(const IrcMessage& message);
+  void on_unknown_message(const IrcMessage& message);
+  /**
+   * Return the number of joined channels
+   */
+  size_t number_of_joined_channels() const;
+  /**
+   * Get a reference to the unique dummy channel
+   */
+  DummyIrcChannel& get_dummy_channel();
+  /**
+   * Leave the dummy channel: forward a message to the user to indicate that
+   * he left it, and mark it as not joined.
+   */
+  void leave_dummy_channel(const std::string& exit_message);
+
+  const std::string& get_hostname() const { return this->hostname; }
+  std::string get_nick() const { return this->current_nick; }
+  bool is_welcomed() const { return this->welcomed; }
+
+  const Resolver& get_resolver() const { return this->dns_resolver; }
+
+  const std::vector<char>& get_sorted_user_modes() const { return sorted_user_modes; }
+
+private:
+  /**
+   * The hostname of the server we are connected to.
+   */
+  const std::string hostname;
+  /**
+   * Our own host, as reported by the IRC server.
+   * By default (and if it is not overridden by the server), it is a
+   * meaningless string, with the maximum allowed size
+   */
+  std::string own_host{63, '*'};
+  /**
+   * The hostname of the user.  This is used in the USER and the WEBIRC
+   * commands, but only the one in WEBIRC will be used by the IRC server.
+   */
+  const std::string user_hostname;
+  /**
+   * The username used in the USER irc command
+   */
+  std::string username;
+  /**
+   * The realname used in the USER irc command
+   */
+  std::string realname;
+  /**
+   * Our current nickname on the server
+   */
+  std::string current_nick;
+  /**
+   * To communicate back with the bridge
+   */
+  Bridge& bridge;
+  /**
+   * The list of joined channels, indexed by name
+   */
+  std::unordered_map<std::string, std::unique_ptr<IrcChannel>> channels;
+  /**
+   * A single channel with a iid of the form "hostname" (normal channel have
+   * an iid of the form "chan%hostname".
+   */
+  DummyIrcChannel dummy_channel;
+  /**
+   * A list of chan we want to join (tuples with the channel name and the
+   * password, if any), but we need a response 001 from the server before
+   * sending the actual JOIN commands. So we just keep the channel names in
+   * a list, and send the JOIN commands for each of them whenever the
+   * WELCOME message is received.
+   */
+  std::vector<std::tuple<std::string, std::string>> channels_to_join;
+  /**
+   * This flag indicates that the server is completely joined (connection
+   * has been established, we are authentified and we have a nick)
+   */
+  bool welcomed;
+  /**
+   * See http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt section 3.3
+   * We store the possible chanmodes in this object.
+   * chanmodes[0] contains modes of type A, [1] of type B etc
+   */
+  std::vector<std::string> chanmodes;
+  /**
+   * See http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt
+   * section 3.5
+   */
+  std::set<char> chantypes;
+  /**
+   * Each motd line received is appended to this string, which we send when
+   * the motd is completely received
+   */
+  std::string motd;
+  /**
+   * See http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt section 3.14
+   * The example given would be transformed into
+   * modes_to_prefix = {{'&', 'a'}, {'*', 'b'}}
+   */
+  std::map<char, char> prefix_to_mode;
+  /**
+   * Available user modes, sorted from most significant to least significant
+   * (for example 'ahov' is a common order).
+   */
+  std::vector<char> sorted_user_modes;
+  /**
+   * A list of ports to which we will try to connect, in reverse. Each port
+   * is associated with a boolean telling if we should use TLS or not if the
+   * connection succeeds on that port.
+   */
+  std::stack<std::pair<std::string, bool>> ports_to_try;
+  /**
+   * A set of (lowercase) nicknames to which we sent a private message.
+   */
+  std::set<std::string> nicks_to_treat_as_private;
+  /**
+   * DNS resolver, used to resolve the hostname of the user if we are using
+   * the WebIRC protocole.
+   */
+  Resolver dns_resolver;
+};
+
+
diff --git a/src/irc/irc_message.cpp b/src/irc/irc_message.cpp
new file mode 100644
index 0000000..966a47c
--- /dev/null
+++ b/src/irc/irc_message.cpp
@@ -0,0 +1,61 @@
+#include <irc/irc_message.hpp>
+#include <iostream>
+
+IrcMessage::IrcMessage(std::string&& line)
+{
+  std::string::size_type pos;
+
+  // optional prefix
+  if (line[0] == ':')
+    {
+      pos = line.find(" ");
+      this->prefix = line.substr(1, pos - 1);
+      line = line.substr(pos + 1, std::string::npos);
+    }
+  // command
+  pos = line.find(" ");
+  this->command = line.substr(0, pos);
+  line = line.substr(pos + 1, std::string::npos);
+  // arguments
+  do
+    {
+      if (line[0] == ':')
+        {
+          this->arguments.emplace_back(line.substr(1, std::string::npos));
+          break ;
+        }
+      pos = line.find(" ");
+      this->arguments.emplace_back(line.substr(0, pos));
+      line = line.substr(pos + 1, std::string::npos);
+    } while (pos != std::string::npos);
+}
+
+IrcMessage::IrcMessage(std::string&& prefix,
+                       std::string&& command,
+                       std::vector<std::string>&& args):
+  prefix(std::move(prefix)),
+  command(std::move(command)),
+  arguments(std::move(args))
+{
+}
+
+IrcMessage::IrcMessage(std::string&& command,
+                       std::vector<std::string>&& args):
+  prefix(),
+  command(std::move(command)),
+  arguments(std::move(args))
+{
+}
+
+std::ostream& operator<<(std::ostream& os, const IrcMessage& message)
+{
+  os << "IrcMessage";
+  os << "[" << message.command << "]";
+  for (const std::string& arg: message.arguments)
+    {
+      os << "{" << arg << "}";
+    }
+  if (!message.prefix.empty())
+    os << "(from: " << message.prefix << ")";
+  return os;
+}
diff --git a/src/irc/irc_message.hpp b/src/irc/irc_message.hpp
new file mode 100644
index 0000000..fe954e4
--- /dev/null
+++ b/src/irc/irc_message.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+
+#include <vector>
+#include <string>
+#include <ostream>
+
+class IrcMessage
+{
+public:
+  IrcMessage(std::string&& line);
+  IrcMessage(std::string&& prefix, std::string&& command, std::vector<std::string>&& args);
+  IrcMessage(std::string&& command, std::vector<std::string>&& args);
+  ~IrcMessage() = default;
+
+  IrcMessage(const IrcMessage&) = delete;
+  IrcMessage(IrcMessage&&) = delete;
+  IrcMessage& operator=(const IrcMessage&) = delete;
+  IrcMessage& operator=(IrcMessage&&) = delete;
+
+  std::string prefix;
+  std::string command;
+  std::vector<std::string> arguments;
+};
+
+std::ostream& operator<<(std::ostream& os, const IrcMessage& message);
+
+
diff --git a/src/irc/irc_user.cpp b/src/irc/irc_user.cpp
new file mode 100644
index 0000000..9fa3612
--- /dev/null
+++ b/src/irc/irc_user.cpp
@@ -0,0 +1,57 @@
+#include <irc/irc_user.hpp>
+
+#include <iostream>
+
+IrcUser::IrcUser(const std::string& name,
+                 const std::map<char, char>& prefix_to_mode)
+{
+  if (name.empty())
+    return ;
+
+  // One or more prefix (with multi-prefix support) may come before the
+  // actual nick
+  std::string::size_type name_begin = 0;
+  while (name_begin != name.size())
+    {
+      const auto prefix = prefix_to_mode.find(name[name_begin]);
+      // This is not a prefix
+      if (prefix == prefix_to_mode.end())
+        break;
+      this->modes.insert(prefix->second);
+      name_begin++;
+    }
+
+  const std::string::size_type sep = name.find("!", name_begin);
+  if (sep == std::string::npos)
+    this->nick = name.substr(name_begin);
+  else
+    {
+      this->nick = name.substr(name_begin, sep-name_begin);
+      this->host = name.substr(sep+1);
+    }
+}
+
+IrcUser::IrcUser(const std::string& name):
+  IrcUser(name, {})
+{
+}
+
+void IrcUser::add_mode(const char mode)
+{
+  this->modes.insert(mode);
+}
+
+void IrcUser::remove_mode(const char mode)
+{
+  this->modes.erase(mode);
+}
+
+char IrcUser::get_most_significant_mode(const std::vector<char>& modes) const
+{
+  for (const char mode: modes)
+    {
+      if (this->modes.find(mode) != this->modes.end())
+        return mode;
+    }
+  return 0;
+}
diff --git a/src/irc/irc_user.hpp b/src/irc/irc_user.hpp
new file mode 100644
index 0000000..c84030e
--- /dev/null
+++ b/src/irc/irc_user.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+
+/**
+ * Keeps various information about one IRC channel user
+ */
+class IrcUser
+{
+public:
+  explicit IrcUser(const std::string& name,
+                   const std::map<char, char>& prefix_to_mode);
+  explicit IrcUser(const std::string& name);
+
+  IrcUser(const IrcUser&) = delete;
+  IrcUser(IrcUser&&) = delete;
+  IrcUser& operator=(const IrcUser&) = delete;
+  IrcUser& operator=(IrcUser&&) = delete;
+
+  void add_mode(const char mode);
+  void remove_mode(const char mode);
+  char get_most_significant_mode(const std::vector<char>& sorted_user_modes) const;
+
+  std::string nick;
+  std::string host;
+  std::set<char> modes;
+};
+
+
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..53f3193
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,202 @@
+#include <xmpp/biboumi_component.hpp>
+#include <utils/timed_events.hpp>
+#include <network/poller.hpp>
+#include <config/config.hpp>
+#include <logger/logger.hpp>
+#include <utils/xdg.hpp>
+#include <utils/reload.hpp>
+
+#ifdef CARES_FOUND
+# include <network/dns_handler.hpp>
+#endif
+
+#include <atomic>
+#include <signal.h>
+
+// A flag set by the SIGINT signal handler.
+static volatile std::atomic<bool> stop(false);
+// Flag set by the SIGUSR1/2 signal handler.
+static volatile std::atomic<bool> reload(false);
+// A flag indicating that we are wanting to exit the process. i.e: if this
+// flag is set and all connections are closed, we can exit properly.
+static bool exiting = false;
+
+/**
+ * Provide an helpful message to help the user write a minimal working
+ * configuration file.
+ */
+int config_help(const std::string& missing_option)
+{
+  if (!missing_option.empty())
+    log_error("Configuration error: empty value for option ", missing_option, ".");
+  log_error("Please provide a configuration file filled like this:\n\n"
+            "hostname=irc.example.com\npassword=S3CR3T");
+  return 1;
+}
+
+int display_help()
+{
+  std::cout << "Usage: biboumi [configuration_file]" << std::endl;
+  return 0;
+}
+
+static void sigint_handler(int sig, siginfo_t*, void*)
+{
+  // In 2 seconds, repeat the same signal, to force the exit
+  TimedEventsManager::instance().add_event(TimedEvent(std::chrono::steady_clock::now() + 2s,
+                                    [sig]() { raise(sig); }));
+  stop.store(true);
+}
+
+static void sigusr_handler(int, siginfo_t*, void*)
+{
+  reload.store(true);
+}
+
+int main(int ac, char** av)
+{
+  if (ac > 1)
+    {
+      const std::string arg = av[1];
+      if (arg.size() >= 2 && arg[0] == '-' && arg[1] == '-')
+        {
+          if (arg == "--help")
+            return display_help();
+          else
+            {
+              std::cerr << "Unknow command line option: " << arg << std::endl;
+              return 1;
+            }
+        }
+    }
+  const std::string conf_filename = ac > 1 ? av[1] : xdg_config_path("biboumi.cfg");
+  std::cout << "Using configuration file: " << conf_filename << std::endl;
+
+  if (!Config::read_conf(conf_filename))
+    return config_help("");
+
+  const std::string password = Config::get("password", "");
+  if (password.empty())
+    return config_help("password");
+  const std::string hostname = Config::get("hostname", "");
+  if (hostname.empty())
+    return config_help("hostname");
+
+  try {
+      open_database();
+    } catch (...) {
+      return 1;
+    }
+
+  // Block the signals we want to manage. They will be unblocked only during
+  // the epoll_pwait or ppoll calls. This avoids some race conditions,
+  // explained in man 2 pselect on linux
+  sigset_t mask;
+  sigemptyset(&mask);
+  sigaddset(&mask, SIGINT);
+  sigaddset(&mask, SIGTERM);
+  sigaddset(&mask, SIGUSR1);
+  sigaddset(&mask, SIGUSR2);
+  sigprocmask(SIG_BLOCK, &mask, nullptr);
+
+  // Install the signals used to exit the process cleanly, or reload the
+  // config
+  struct sigaction on_sigint;
+  on_sigint.sa_sigaction = &sigint_handler;
+  // All signals must be blocked while a signal handler is running
+  sigfillset(&on_sigint.sa_mask);
+  // we want to catch that signal only once.
+  // Sending SIGINT again will "force" an exit
+  on_sigint.sa_flags = SA_RESETHAND;
+  sigaction(SIGINT, &on_sigint, nullptr);
+  sigaction(SIGTERM, &on_sigint, nullptr);
+
+  // Install a signal to reload the config on SIGUSR1/2
+  struct sigaction on_sigusr;
+  on_sigusr.sa_sigaction = &sigusr_handler;
+  sigfillset(&on_sigusr.sa_mask);
+  on_sigusr.sa_flags = 0;
+  sigaction(SIGUSR1, &on_sigusr, nullptr);
+  sigaction(SIGUSR2, &on_sigusr, nullptr);
+
+  auto p = std::make_shared<Poller>();
+  auto xmpp_component =
+    std::make_shared<BiboumiComponent>(p, hostname, password);
+  xmpp_component->start();
+
+#ifdef CARES_FOUND
+  DNSHandler::instance.watch_dns_sockets(p);
+#endif
+  auto timeout = TimedEventsManager::instance().get_timeout();
+  while (p->poll(timeout) != -1)
+  {
+    TimedEventsManager::instance().execute_expired_events();
+    // Check for empty irc_clients (not connected, or with no joined
+    // channel) and remove them
+    xmpp_component->clean();
+    if (stop)
+    {
+      log_info("Signal received, exiting...");
+#ifdef SYSTEMD_FOUND
+      sd_notify(0, "STOPPING=1");
+#endif
+      exiting = true;
+      stop.store(false);
+      xmpp_component->shutdown();
+      // Cancel the timer for a potential reconnection
+      TimedEventsManager::instance().cancel("XMPP reconnection");
+    }
+    if (reload)
+    {
+      log_info("Signal received, reloading the config...");
+      ::reload_process();
+      reload.store(false);
+    }
+    // Reconnect to the XMPP server if this was not intended.  This may have
+    // happened because we sent something invalid to it and it decided to
+    // close the connection.  This is a bug that should be fixed, but we
+    // still reconnect automatically instead of dropping everything
+    if (!exiting && xmpp_component->ever_auth &&
+        !xmpp_component->is_connected() &&
+        !xmpp_component->is_connecting())
+    {
+      if (xmpp_component->first_connection_try == true)
+      { // immediately re-try to connect
+        xmpp_component->reset();
+        xmpp_component->start();
+      }
+      else
+      { // Re-connecting failed, we now try only each few seconds
+        auto reconnect_later = [xmpp_component]()
+        {
+          xmpp_component->reset();
+          xmpp_component->start();
+        };
+        TimedEvent event(std::chrono::steady_clock::now() + 2s,
+                         reconnect_later, "XMPP reconnection");
+        TimedEventsManager::instance().add_event(std::move(event));
+      }
+    }
+    // If the only existing connection is the one to the XMPP component:
+    // close the XMPP stream.
+    if (exiting && xmpp_component->is_connecting())
+      xmpp_component->close();
+    if (exiting && p->size() == 1 && xmpp_component->is_document_open())
+      xmpp_component->close_document();
+#ifdef CARES_FOUND
+    if (!exiting)
+      DNSHandler::instance.watch_dns_sockets(p);
+#endif
+    if (exiting) // If we are exiting, do not wait for any timed event
+      timeout = utils::no_timeout;
+    else
+      timeout = TimedEventsManager::instance().get_timeout();
+  }
+#ifdef CARES_FOUND
+  DNSHandler::instance.destroy();
+#endif
+  if (!xmpp_component->ever_auth)
+    return 1; // To signal that the process did not properly start
+  log_info("All connections cleanly closed, have a nice day.");
+  return 0;
+}
diff --git a/src/utils/empty_if_fixed_server.hpp b/src/utils/empty_if_fixed_server.hpp
new file mode 100644
index 0000000..9ccf5fd
--- /dev/null
+++ b/src/utils/empty_if_fixed_server.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+
+#include <string>
+
+#include <config/config.hpp>
+
+namespace utils
+{
+  inline std::string empty_if_fixed_server(std::string&& str)
+  {
+    if (!Config::get("fixed_irc_server", "").empty())
+      return {};
+    return str;
+  }
+
+  inline std::string empty_if_fixed_server(const std::string& str)
+  {
+    if (!Config::get("fixed_irc_server", "").empty())
+      return {};
+    return str;
+  }
+
+}
+
+
diff --git a/src/utils/reload.cpp b/src/utils/reload.cpp
new file mode 100644
index 0000000..348c5b5
--- /dev/null
+++ b/src/utils/reload.cpp
@@ -0,0 +1,34 @@
+#include <utils/reload.hpp>
+#include <database/database.hpp>
+#include <config/config.hpp>
+#include <utils/xdg.hpp>
+#include <logger/logger.hpp>
+
+#include "biboumi.h"
+
+void open_database()
+{
+#ifdef USE_DATABASE
+  const auto db_filename = Config::get("db_name", xdg_data_path("biboumi.sqlite"));
+  log_info("Opening database: ", db_filename);
+  Database::open(db_filename);
+  log_info("database successfully opened.");
+#endif
+}
+
+void reload_process()
+{
+  Config::read_conf();
+  // Destroy the logger instance, to be recreated the next time a log
+  // line needs to be written
+  Logger::instance().reset();
+  log_info("Configuration and logger reloaded.");
+#ifdef USE_DATABASE
+  try {
+      open_database();
+    } catch (const litesql::DatabaseError&) {
+      log_warning("Re-using the previous database.");
+    }
+#endif
+}
+
diff --git a/src/utils/reload.hpp b/src/utils/reload.hpp
new file mode 100644
index 0000000..408426a
--- /dev/null
+++ b/src/utils/reload.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+void open_database();
+void reload_process();
diff --git a/src/xmpp/biboumi_adhoc_commands.cpp b/src/xmpp/biboumi_adhoc_commands.cpp
new file mode 100644
index 0000000..eec930d
--- /dev/null
+++ b/src/xmpp/biboumi_adhoc_commands.cpp
@@ -0,0 +1,635 @@
+#include <xmpp/biboumi_adhoc_commands.hpp>
+#include <xmpp/biboumi_component.hpp>
+#include <config/config.hpp>
+#include <utils/string.hpp>
+#include <utils/split.hpp>
+#include <xmpp/jid.hpp>
+
+#include <biboumi.h>
+
+#ifdef USE_DATABASE
+#include <database/database.hpp>
+#endif
+
+#include <louloulibs.h>
+
+#include <algorithm>
+
+using namespace std::string_literals;
+
+void DisconnectUserStep1(XmppComponent& xmpp_component, AdhocSession&, XmlNode& command_node)
+{
+  auto& biboumi_component = static_cast<BiboumiComponent&>(xmpp_component);
+
+  XmlNode x("jabber:x:data:x");
+  x["type"] = "form";
+  XmlNode title("title");
+  title.set_inner("Disconnect a user from the gateway");
+  x.add_child(std::move(title));
+  XmlNode instructions("instructions");
+  instructions.set_inner("Choose a user JID and a quit message");
+  x.add_child(std::move(instructions));
+  XmlNode jids_field("field");
+  jids_field["var"] = "jids";
+  jids_field["type"] = "list-multi";
+  jids_field["label"] = "The JIDs to disconnect";
+  XmlNode required("required");
+  jids_field.add_child(std::move(required));
+  for (Bridge* bridge: biboumi_component.get_bridges())
+    {
+      XmlNode option("option");
+      option["label"] = bridge->get_jid();
+      XmlNode value("value");
+      value.set_inner(bridge->get_jid());
+      option.add_child(std::move(value));
+      jids_field.add_child(std::move(option));
+    }
+  x.add_child(std::move(jids_field));
+
+  XmlNode message_field("field");
+  message_field["var"] = "quit-message";
+  message_field["type"] = "text-single";
+  message_field["label"] = "Quit message";
+  XmlNode message_value("value");
+  message_value.set_inner("Disconnected by admin");
+  message_field.add_child(std::move(message_value));
+  x.add_child(std::move(message_field));
+  command_node.add_child(std::move(x));
+}
+
+void DisconnectUserStep2(XmppComponent& xmpp_component, AdhocSession& session, XmlNode& command_node)
+{
+  auto& biboumi_component = static_cast<BiboumiComponent&>(xmpp_component);
+
+  // Find out if the jids, and the quit message are provided in the form.
+  std::string quit_message;
+  const XmlNode* x = command_node.get_child("x", "jabber:x:data");
+  if (x)
+    {
+      const XmlNode* message_field = nullptr;
+      const XmlNode* jids_field = nullptr;
+      for (const XmlNode* field: x->get_children("field", "jabber:x:data"))
+        if (field->get_tag("var") == "jids")
+          jids_field = field;
+        else if (field->get_tag("var") == "quit-message")
+          message_field = field;
+      if (message_field)
+        {
+          const XmlNode* value = message_field->get_child("value", "jabber:x:data");
+          if (value)
+            quit_message = value->get_inner();
+        }
+      if (jids_field)
+        {
+          std::size_t num = 0;
+          for (const XmlNode* value: jids_field->get_children("value", "jabber:x:data"))
+            {
+              Bridge* bridge = biboumi_component.find_user_bridge(value->get_inner());
+              if (bridge)
+                {
+                  bridge->shutdown(quit_message);
+                  num++;
+                }
+            }
+          command_node.delete_all_children();
+
+          XmlNode note("note");
+          note["type"] = "info";
+          if (num == 0)
+            note.set_inner("No user were disconnected.");
+          else if (num == 1)
+            note.set_inner("1 user has been disconnected.");
+          else
+            note.set_inner(std::to_string(num) + " users have been disconnected.");
+          command_node.add_child(std::move(note));
+          return;
+        }
+    }
+  XmlNode error(ADHOC_NS":error");
+  error["type"] = "modify";
+  XmlNode condition(STANZA_NS":bad-request");
+  error.add_child(std::move(condition));
+  command_node.add_child(std::move(error));
+  session.terminate();
+}
+
+#ifdef USE_DATABASE
+void ConfigureIrcServerStep1(XmppComponent&, AdhocSession& session, XmlNode& command_node)
+{
+  const Jid owner(session.get_owner_jid());
+  const Jid target(session.get_target_jid());
+  std::string server_domain;
+  if ((server_domain = Config::get("fixed_irc_server", "")).empty())
+    server_domain = target.local;
+  auto options = Database::get_irc_server_options(owner.local + "@" + owner.domain,
+                                                  server_domain);
+
+  XmlNode x("jabber:x:data:x");
+  x["type"] = "form";
+  XmlNode title("title");
+  title.set_inner("Configure the IRC server "s + server_domain);
+  x.add_child(std::move(title));
+  XmlNode instructions("instructions");
+  instructions.set_inner("Edit the form, to configure the settings of the IRC server "s + server_domain);
+  x.add_child(std::move(instructions));
+
+  XmlNode required("required");
+
+  XmlNode ports("field");
+  ports["var"] = "ports";
+  ports["type"] = "text-multi";
+  ports["label"] = "Ports";
+  ports["desc"] = "List of ports to try, without TLS. Defaults: 6667.";
+  auto vals = utils::split(options.ports.value(), ';', false);
+  for (const auto& val: vals)
+    {
+      XmlNode ports_value("value");
+      ports_value.set_inner(val);
+      ports.add_child(std::move(ports_value));
+    }
+  ports.add_child(required);
+  x.add_child(std::move(ports));
+
+#ifdef BOTAN_FOUND
+  XmlNode tls_ports("field");
+  tls_ports["var"] = "tls_ports";
+  tls_ports["type"] = "text-multi";
+  tls_ports["label"] = "TLS ports";
+  tls_ports["desc"] = "List of ports to try, with TLS. Defaults: 6697, 6670.";
+  vals = utils::split(options.tlsPorts.value(), ';', false);
+  for (const auto& val: vals)
+    {
+      XmlNode tls_ports_value("value");
+      tls_ports_value.set_inner(val);
+      tls_ports.add_child(std::move(tls_ports_value));
+    }
+  tls_ports.add_child(required);
+  x.add_child(std::move(tls_ports));
+
+  XmlNode verify_cert("field");
+  verify_cert["var"] = "verify_cert";
+  verify_cert["type"] = "boolean";
+  verify_cert["label"] = "Verify certificate";
+  verify_cert["desc"] = "Whether or not to abort the connection if the server’s TLS certificate is invalid";
+  XmlNode verify_cert_value("value");
+  if (options.verifyCert.value())
+    verify_cert_value.set_inner("true");
+  else
+    verify_cert_value.set_inner("false");
+  verify_cert.add_child(std::move(verify_cert_value));
+  x.add_child(std::move(verify_cert));
+
+  XmlNode fingerprint("field");
+  fingerprint["var"] = "fingerprint";
+  fingerprint["type"] = "text-single";
+  fingerprint["label"] = "SHA-1 fingerprint of the TLS certificate to trust.";
+  if (!options.trustedFingerprint.value().empty())
+    {
+      XmlNode fingerprint_value("value");
+      fingerprint_value.set_inner(options.trustedFingerprint.value());
+      fingerprint.add_child(std::move(fingerprint_value));
+    }
+  fingerprint.add_child(required);
+  x.add_child(std::move(fingerprint));
+#endif
+
+  XmlNode pass("field");
+  pass["var"] = "pass";
+  pass["type"] = "text-private";
+  pass["label"] = "Server password (to be used in a PASS command when connecting)";
+  if (!options.pass.value().empty())
+    {
+      XmlNode pass_value("value");
+      pass_value.set_inner(options.pass.value());
+      pass.add_child(std::move(pass_value));
+    }
+  pass.add_child(required);
+  x.add_child(std::move(pass));
+
+  XmlNode after_cnt_cmd("field");
+  after_cnt_cmd["var"] = "after_connect_command";
+  after_cnt_cmd["type"] = "text-single";
+  after_cnt_cmd["desc"] = "Custom IRC command sent after the connection is established with the server.";
+  after_cnt_cmd["label"] = "After-connection IRC command";
+  if (!options.afterConnectionCommand.value().empty())
+    {
+      XmlNode after_cnt_cmd_value("value");
+      after_cnt_cmd_value.set_inner(options.afterConnectionCommand.value());
+      after_cnt_cmd.add_child(std::move(after_cnt_cmd_value));
+    }
+  after_cnt_cmd.add_child(required);
+  x.add_child(std::move(after_cnt_cmd));
+
+  if (Config::get("realname_customization", "true") == "true")
+    {
+      XmlNode username("field");
+      username["var"] = "username";
+      username["type"] = "text-single";
+      username["label"] = "Username";
+      if (!options.username.value().empty())
+        {
+          XmlNode username_value("value");
+          username_value.set_inner(options.username.value());
+          username.add_child(std::move(username_value));
+        }
+      username.add_child(required);
+      x.add_child(std::move(username));
+
+      XmlNode realname("field");
+      realname["var"] = "realname";
+      realname["type"] = "text-single";
+      realname["label"] = "Realname";
+      if (!options.realname.value().empty())
+        {
+          XmlNode realname_value("value");
+          realname_value.set_inner(options.realname.value());
+          realname.add_child(std::move(realname_value));
+        }
+      realname.add_child(required);
+      x.add_child(std::move(realname));
+    }
+
+  XmlNode encoding_out("field");
+  encoding_out["var"] = "encoding_out";
+  encoding_out["type"] = "text-single";
+  encoding_out["desc"] = "The encoding used when sending messages to the IRC server.";
+  encoding_out["label"] = "Out encoding";
+  if (!options.encodingOut.value().empty())
+    {
+      XmlNode encoding_out_value("value");
+      encoding_out_value.set_inner(options.encodingOut.value());
+      encoding_out.add_child(std::move(encoding_out_value));
+    }
+  encoding_out.add_child(required);
+  x.add_child(std::move(encoding_out));
+
+  XmlNode encoding_in("field");
+  encoding_in["var"] = "encoding_in";
+  encoding_in["type"] = "text-single";
+  encoding_in["desc"] = "The encoding used to decode message received from the IRC server.";
+  encoding_in["label"] = "In encoding";
+  if (!options.encodingIn.value().empty())
+    {
+      XmlNode encoding_in_value("value");
+      encoding_in_value.set_inner(options.encodingIn.value());
+      encoding_in.add_child(std::move(encoding_in_value));
+    }
+  encoding_in.add_child(required);
+  x.add_child(std::move(encoding_in));
+
+
+  command_node.add_child(std::move(x));
+}
+
+void ConfigureIrcServerStep2(XmppComponent&, AdhocSession& session, XmlNode& command_node)
+{
+  const XmlNode* x = command_node.get_child("x", "jabber:x:data");
+  if (x)
+    {
+      const Jid owner(session.get_owner_jid());
+      const Jid target(session.get_target_jid());
+      std::string server_domain;
+      if ((server_domain = Config::get("fixed_irc_server", "")).empty())
+        server_domain = target.local;
+      auto options = Database::get_irc_server_options(owner.local + "@" + owner.domain,
+                                                      server_domain);
+      for (const XmlNode* field: x->get_children("field", "jabber:x:data"))
+        {
+          const XmlNode* value = field->get_child("value", "jabber:x:data");
+          const std::vector<const XmlNode*> values = field->get_children("value", "jabber:x:data");
+          if (field->get_tag("var") == "ports")
+            {
+              std::string ports;
+              for (const auto& val: values)
+                ports += val->get_inner() + ";";
+              options.ports = ports;
+            }
+
+#ifdef BOTAN_FOUND
+          else if (field->get_tag("var") == "tls_ports")
+            {
+              std::string ports;
+              for (const auto& val: values)
+                ports += val->get_inner() + ";";
+              options.tlsPorts = ports;
+            }
+
+          else if (field->get_tag("var") == "verify_cert" && value
+              && !value->get_inner().empty())
+            {
+              auto val = to_bool(value->get_inner());
+              options.verifyCert = val;
+            }
+
+          else if (field->get_tag("var") == "fingerprint" && value &&
+                   !value->get_inner().empty())
+            {
+              options.trustedFingerprint = value->get_inner();
+            }
+
+#endif // BOTAN_FOUND
+
+          else if (field->get_tag("var") == "pass" &&
+                   value && !value->get_inner().empty())
+            options.pass = value->get_inner();
+
+          else if (field->get_tag("var") == "after_connect_command" &&
+                   value && !value->get_inner().empty())
+            options.afterConnectionCommand = value->get_inner();
+
+          else if (field->get_tag("var") == "username" &&
+                   value && !value->get_inner().empty())
+            {
+              auto username = value->get_inner();
+              // The username must not contain spaces
+              std::replace(username.begin(), username.end(), ' ', '_');
+              options.username = username;
+            }
+
+          else if (field->get_tag("var") == "realname" &&
+                   value && !value->get_inner().empty())
+            options.realname = value->get_inner();
+
+          else if (field->get_tag("var") == "encoding_out" &&
+                   value && !value->get_inner().empty())
+            options.encodingOut = value->get_inner();
+
+          else if (field->get_tag("var") == "encoding_in" &&
+                   value && !value->get_inner().empty())
+            options.encodingIn = value->get_inner();
+
+        }
+
+      options.update();
+
+      command_node.delete_all_children();
+      XmlNode note("note");
+      note["type"] = "info";
+      note.set_inner("Configuration successfully applied.");
+      command_node.add_child(std::move(note));
+      return;
+    }
+  XmlNode error(ADHOC_NS":error");
+  error["type"] = "modify";
+  XmlNode condition(STANZA_NS":bad-request");
+  error.add_child(std::move(condition));
+  command_node.add_child(std::move(error));
+  session.terminate();
+}
+
+void ConfigureIrcChannelStep1(XmppComponent&, AdhocSession& session, XmlNode& command_node)
+{
+  const Jid owner(session.get_owner_jid());
+  const Jid target(session.get_target_jid());
+  const Iid iid(target.local);
+  auto options = Database::get_irc_channel_options_with_server_default(owner.local + "@" + owner.domain,
+                                                                       iid.get_server(), iid.get_local());
+
+  XmlNode x("jabber:x:data:x");
+  x["type"] = "form";
+  XmlNode title("title");
+  title.set_inner("Configure the IRC channel "s + iid.get_local() + " on server "s + iid.get_server());
+  x.add_child(std::move(title));
+  XmlNode instructions("instructions");
+  instructions.set_inner("Edit the form, to configure the settings of the IRC channel "s + iid.get_local());
+  x.add_child(std::move(instructions));
+
+  XmlNode required("required");
+
+  XmlNode encoding_out("field");
+  encoding_out["var"] = "encoding_out";
+  encoding_out["type"] = "text-single";
+  encoding_out["desc"] = "The encoding used when sending messages to the IRC server. Defaults to the server's “out encoding” if unset for the channel";
+  encoding_out["label"] = "Out encoding";
+  if (!options.encodingOut.value().empty())
+    {
+      XmlNode encoding_out_value("value");
+      encoding_out_value.set_inner(options.encodingOut.value());
+      encoding_out.add_child(std::move(encoding_out_value));
+    }
+  encoding_out.add_child(required);
+  x.add_child(std::move(encoding_out));
+
+  XmlNode encoding_in("field");
+  encoding_in["var"] = "encoding_in";
+  encoding_in["type"] = "text-single";
+  encoding_in["desc"] = "The encoding used to decode message received from the IRC server. Defaults to the server's “in encoding” if unset for the channel";
+  encoding_in["label"] = "In encoding";
+  if (!options.encodingIn.value().empty())
+    {
+      XmlNode encoding_in_value("value");
+      encoding_in_value.set_inner(options.encodingIn.value());
+      encoding_in.add_child(std::move(encoding_in_value));
+    }
+  encoding_in.add_child(required);
+  x.add_child(std::move(encoding_in));
+
+  command_node.add_child(std::move(x));
+}
+
+void ConfigureIrcChannelStep2(XmppComponent&, AdhocSession& session, XmlNode& command_node)
+{
+  const XmlNode* x = command_node.get_child("x", "jabber:x:data");
+  if (x)
+    {
+      const Jid owner(session.get_owner_jid());
+      const Jid target(session.get_target_jid());
+      const Iid iid(target.local);
+      auto options = Database::get_irc_channel_options(owner.local + "@" + owner.domain,
+                                                       iid.get_server(), iid.get_local());
+      for (const XmlNode* field: x->get_children("field", "jabber:x:data"))
+        {
+          const XmlNode* value = field->get_child("value", "jabber:x:data");
+
+          if (field->get_tag("var") == "encoding_out" &&
+                   value && !value->get_inner().empty())
+            options.encodingOut = value->get_inner();
+
+          else if (field->get_tag("var") == "encoding_in" &&
+                   value && !value->get_inner().empty())
+            options.encodingIn = value->get_inner();
+        }
+
+      options.update();
+
+      command_node.delete_all_children();
+      XmlNode note("note");
+      note["type"] = "info";
+      note.set_inner("Configuration successfully applied.");
+      command_node.add_child(std::move(note));
+      return;
+    }
+  XmlNode error(ADHOC_NS":error");
+  error["type"] = "modify";
+  XmlNode condition(STANZA_NS":bad-request");
+  error.add_child(std::move(condition));
+  command_node.add_child(std::move(error));
+  session.terminate();
+}
+#endif  // USE_DATABASE
+
+void DisconnectUserFromServerStep1(XmppComponent& xmpp_component, AdhocSession& session, XmlNode& command_node)
+{
+  const Jid owner(session.get_owner_jid());
+  if (owner.bare() != Config::get("admin", ""))
+    { // A non-admin is not allowed to disconnect other users, only
+      // him/herself, so we just skip this step
+      auto next_step = session.get_next_step();
+      next_step(xmpp_component, session, command_node);
+    }
+  else
+    { // Send a form to select the user to disconnect
+      auto& biboumi_component = static_cast<BiboumiComponent&>(xmpp_component);
+
+      XmlNode x("jabber:x:data:x");
+      x["type"] = "form";
+      XmlNode title("title");
+      title.set_inner("Disconnect a user from selected IRC servers");
+      x.add_child(std::move(title));
+      XmlNode instructions("instructions");
+      instructions.set_inner("Choose a user JID");
+      x.add_child(std::move(instructions));
+      XmlNode jids_field("field");
+      jids_field["var"] = "jid";
+      jids_field["type"] = "list-single";
+      jids_field["label"] = "The JID to disconnect";
+      XmlNode required("required");
+      jids_field.add_child(std::move(required));
+      for (Bridge* bridge: biboumi_component.get_bridges())
+        {
+          XmlNode option("option");
+          option["label"] = bridge->get_jid();
+          XmlNode value("value");
+          value.set_inner(bridge->get_jid());
+          option.add_child(std::move(value));
+          jids_field.add_child(std::move(option));
+        }
+      x.add_child(std::move(jids_field));
+      command_node.add_child(std::move(x));
+    }
+}
+
+void DisconnectUserFromServerStep2(XmppComponent& xmpp_component, AdhocSession& session, XmlNode& command_node)
+{
+  // If no JID is contained in the command node, it means we skipped the
+  // previous stage, and the jid to disconnect is the executor's jid
+  std::string jid_to_disconnect = session.get_owner_jid();
+
+  if (const XmlNode* x = command_node.get_child("x", "jabber:x:data"))
+    {
+      for (const XmlNode* field: x->get_children("field", "jabber:x:data"))
+        if (field->get_tag("var") == "jid")
+          {
+            if (const XmlNode* value = field->get_child("value", "jabber:x:data"))
+              jid_to_disconnect = value->get_inner();
+          }
+    }
+
+  // Save that JID for the last step
+  session.vars["jid"] = jid_to_disconnect;
+
+  // Send a data form to let the user choose which server to disconnect the
+  // user from
+  command_node.delete_all_children();
+  auto& biboumi_component = static_cast<BiboumiComponent&>(xmpp_component);
+
+  XmlNode x("jabber:x:data:x");
+  x["type"] = "form";
+  XmlNode title("title");
+  title.set_inner("Disconnect a user from selected IRC servers");
+  x.add_child(std::move(title));
+  XmlNode instructions("instructions");
+  instructions.set_inner("Choose one or more servers to disconnect this JID from");
+  x.add_child(std::move(instructions));
+  XmlNode jids_field("field");
+  jids_field["var"] = "irc-servers";
+  jids_field["type"] = "list-multi";
+  jids_field["label"] = "The servers to disconnect from";
+  XmlNode required("required");
+  jids_field.add_child(std::move(required));
+  Bridge* bridge = biboumi_component.find_user_bridge(jid_to_disconnect);
+
+  if (!bridge || bridge->get_irc_clients().empty())
+    {
+      XmlNode note("note");
+      note["type"] = "info";
+      note.set_inner("User "s + jid_to_disconnect + " is not connected to any IRC server.");
+      command_node.add_child(std::move(note));
+      session.terminate();
+      return ;
+    }
+
+  for (const auto& pair: bridge->get_irc_clients())
+    {
+      XmlNode option("option");
+      option["label"] = pair.first;
+      XmlNode value("value");
+      value.set_inner(pair.first);
+      option.add_child(std::move(value));
+      jids_field.add_child(std::move(option));
+    }
+  x.add_child(std::move(jids_field));
+
+  XmlNode message_field("field");
+  message_field["var"] = "quit-message";
+  message_field["type"] = "text-single";
+  message_field["label"] = "Quit message";
+  XmlNode message_value("value");
+  message_value.set_inner("Killed by admin");
+  message_field.add_child(std::move(message_value));
+  x.add_child(std::move(message_field));
+
+  command_node.add_child(std::move(x));
+}
+
+void DisconnectUserFromServerStep3(XmppComponent& xmpp_component, AdhocSession& session, XmlNode& command_node)
+{
+  const auto it = session.vars.find("jid");
+  if (it == session.vars.end())
+    return ;
+  const auto jid_to_disconnect = it->second;
+
+  std::vector<std::string> servers;
+  std::string quit_message;
+
+  if (const XmlNode* x = command_node.get_child("x", "jabber:x:data"))
+    {
+      for (const XmlNode* field: x->get_children("field", "jabber:x:data"))
+        {
+          if (field->get_tag("var") == "irc-servers")
+            {
+              for (const XmlNode* value: field->get_children("value", "jabber:x:data"))
+                servers.push_back(value->get_inner());
+            }
+          else if (field->get_tag("var") == "quit-message")
+            if (const XmlNode* value = field->get_child("value", "jabber:x:data"))
+              quit_message = value->get_inner();
+        }
+    }
+
+  auto& biboumi_component = static_cast<BiboumiComponent&>(xmpp_component);
+  Bridge* bridge = biboumi_component.find_user_bridge(jid_to_disconnect);
+  auto& clients = bridge->get_irc_clients();
+
+  std::size_t number = 0;
+
+  for (const auto& hostname: servers)
+    {
+      auto it = clients.find(hostname);
+      if (it != clients.end())
+        {
+          it->second->on_error({"ERROR", {quit_message}});
+          clients.erase(it);
+          number++;
+        }
+    }
+  command_node.delete_all_children();
+  XmlNode note("note");
+  note["type"] = "info";
+  std::string msg = jid_to_disconnect + " was disconnected from " + std::to_string(number) + " IRC server";
+  if (number > 1)
+    msg += "s";
+  msg += ".";
+  note.set_inner(msg);
+  command_node.add_child(std::move(note));
+}
diff --git a/src/xmpp/biboumi_adhoc_commands.hpp b/src/xmpp/biboumi_adhoc_commands.hpp
new file mode 100644
index 0000000..2763a9f
--- /dev/null
+++ b/src/xmpp/biboumi_adhoc_commands.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+
+#include <xmpp/adhoc_command.hpp>
+#include <xmpp/adhoc_session.hpp>
+#include <xmpp/xmpp_stanza.hpp>
+
+class XmppComponent;
+
+void DisconnectUserStep1(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+void DisconnectUserStep2(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+
+void ConfigureIrcServerStep1(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+void ConfigureIrcServerStep2(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+
+void ConfigureIrcChannelStep1(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+void ConfigureIrcChannelStep2(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+
+void DisconnectUserFromServerStep1(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+void DisconnectUserFromServerStep2(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+void DisconnectUserFromServerStep3(XmppComponent&, AdhocSession& session, XmlNode& command_node);
+
+
diff --git a/src/xmpp/biboumi_component.cpp b/src/xmpp/biboumi_component.cpp
new file mode 100644
index 0000000..a6aac21
--- /dev/null
+++ b/src/xmpp/biboumi_component.cpp
@@ -0,0 +1,632 @@
+#include <xmpp/biboumi_component.hpp>
+
+#include <utils/timed_events.hpp>
+#include <utils/scopeguard.hpp>
+#include <utils/tolower.hpp>
+#include <logger/logger.hpp>
+#include <xmpp/adhoc_command.hpp>
+#include <xmpp/biboumi_adhoc_commands.hpp>
+#include <bridge/list_element.hpp>
+#include <config/config.hpp>
+#include <xmpp/jid.hpp>
+#include <utils/sha1.hpp>
+
+#include <stdexcept>
+#include <iostream>
+
+#include <stdio.h>
+
+#include <louloulibs.h>
+#include <biboumi.h>
+
+#include <uuid.h>
+
+#ifdef SYSTEMD_FOUND
+# include <systemd/sd-daemon.h>
+#endif
+
+using namespace std::string_literals;
+
+static std::set<std::string> kickable_errors{
+    "gone",
+    "internal-server-error",
+    "item-not-found",
+    "jid-malformed",
+    "recipient-unavailable",
+    "redirect",
+    "remote-server-not-found",
+    "remote-server-timeout",
+    "service-unavailable",
+    "malformed-error"
+    };
+
+
+BiboumiComponent::BiboumiComponent(std::shared_ptr<Poller> poller, const std::string& hostname, const std::string& secret):
+  XmppComponent(poller, hostname, secret),
+  irc_server_adhoc_commands_handler(*this),
+  irc_channel_adhoc_commands_handler(*this)
+{
+  this->stanza_handlers.emplace("presence",
+                                std::bind(&BiboumiComponent::handle_presence, this,std::placeholders::_1));
+  this->stanza_handlers.emplace("message",
+                                std::bind(&BiboumiComponent::handle_message, this,std::placeholders::_1));
+  this->stanza_handlers.emplace("iq",
+                                std::bind(&BiboumiComponent::handle_iq, this,std::placeholders::_1));
+
+  this->adhoc_commands_handler.get_commands() = {
+    {"ping", AdhocCommand({&PingStep1}, "Do a ping", false)},
+    {"hello", AdhocCommand({&HelloStep1, &HelloStep2}, "Receive a custom greeting", false)},
+    {"disconnect-user", AdhocCommand({&DisconnectUserStep1, &DisconnectUserStep2}, "Disconnect selected users from the gateway", true)},
+    {"disconnect-from-irc-servers", AdhocCommand({&DisconnectUserFromServerStep1, &DisconnectUserFromServerStep2, &DisconnectUserFromServerStep3}, "Disconnect from the selected IRC servers", false)},
+    {"reload", AdhocCommand({&Reload}, "Reload biboumi’s configuration", true)}
+  };
+
+#ifdef USE_DATABASE
+  AdhocCommand configure_server_command({&ConfigureIrcServerStep1, &ConfigureIrcServerStep2}, "Configure a few settings for that IRC server", false);
+  if (!Config::get("fixed_irc_server", "").empty())
+  {
+    this->adhoc_commands_handler.get_commands().emplace(std::make_pair("configure",
+            configure_server_command));
+  }
+#endif
+
+  this->irc_server_adhoc_commands_handler.get_commands() = {
+#ifdef USE_DATABASE
+    {"configure", configure_server_command},
+#endif
+  };
+  this->irc_channel_adhoc_commands_handler.get_commands() = {
+#ifdef USE_DATABASE
+    {"configure", AdhocCommand({&ConfigureIrcChannelStep1, &ConfigureIrcChannelStep2}, "Configure a few settings for that IRC channel", false)},
+#endif
+  };
+}
+
+void BiboumiComponent::shutdown()
+{
+  for (auto it = this->bridges.begin(); it != this->bridges.end(); ++it)
+  {
+    it->second->shutdown("Gateway shutdown");
+  }
+}
+
+void BiboumiComponent::clean()
+{
+  auto it = this->bridges.begin();
+  while (it != this->bridges.end())
+  {
+    it->second->clean();
+    if (it->second->active_clients() == 0)
+      it = this->bridges.erase(it);
+    else
+      ++it;
+  }
+}
+
+void BiboumiComponent::handle_presence(const Stanza& stanza)
+{
+  std::string from_str = stanza.get_tag("from");
+  std::string id = stanza.get_tag("id");
+  std::string to_str = stanza.get_tag("to");
+  std::string type = stanza.get_tag("type");
+
+  // Check for mandatory tags
+  if (from_str.empty())
+    {
+      log_warning("Received an invalid presence stanza: tag 'from' is missing.");
+      return;
+    }
+  if (to_str.empty())
+    {
+      this->send_stanza_error("presence", from_str, this->served_hostname, id,
+                              "modify", "bad-request", "Missing 'to' tag");
+      return;
+    }
+
+  Bridge* bridge = this->get_user_bridge(from_str);
+  Jid to(to_str);
+  Jid from(from_str);
+  Iid iid(to.local);
+
+  // An error stanza is sent whenever we exit this function without
+  // disabling this scopeguard.  If error_type and error_name are not
+  // changed, the error signaled is internal-server-error. Change their
+  // value to signal an other kind of error. For example
+  // feature-not-implemented, etc.  Any non-error process should reach the
+  // stanza_error.disable() call at the end of the function.
+  std::string error_type("cancel");
+  std::string error_name("internal-server-error");
+  utils::ScopeGuard stanza_error([&](){
+      this->send_stanza_error("presence", from_str, to_str, id,
+                              error_type, error_name, "");
+        });
+
+  try {
+  if (iid.is_channel && !iid.get_server().empty())
+    { // presence toward a MUC that corresponds to an irc channel, or a
+      // dummy channel if iid.chan is empty
+      if (type.empty())
+        {
+          const std::string own_nick = bridge->get_own_nick(iid);
+          if (!own_nick.empty() && own_nick != to.resource)
+            bridge->send_irc_nick_change(iid, to.resource);
+          const XmlNode* x = stanza.get_child("x", MUC_NS);
+          const XmlNode* password = x ? x->get_child("password", MUC_NS): nullptr;
+          bridge->join_irc_channel(iid, to.resource, password ? password->get_inner(): "",
+                                   from.resource);
+        }
+      else if (type == "unavailable")
+        {
+          const XmlNode* status = stanza.get_child("status", COMPONENT_NS);
+          bridge->leave_irc_channel(std::move(iid), status ? status->get_inner() : "", from.resource);
+        }
+    }
+  else
+    {
+      // An user wants to join an invalid IRC channel, return a presence error to him
+      if (type.empty())
+        this->send_invalid_room_error(to.local, to.resource, from_str);
+    }
+  }
+  catch (const IRCNotConnected& ex)
+    {
+      this->send_stanza_error("presence", from_str, to_str, id,
+                              "cancel", "remote-server-not-found",
+                              "Not connected to IRC server "s + ex.hostname,
+                              true);
+    }
+  stanza_error.disable();
+}
+
+void BiboumiComponent::handle_message(const Stanza& stanza)
+{
+  std::string from = stanza.get_tag("from");
+  std::string id = stanza.get_tag("id");
+  std::string to_str = stanza.get_tag("to");
+  std::string type = stanza.get_tag("type");
+
+  if (from.empty())
+    return;
+  if (type.empty())
+    type = "normal";
+  Bridge* bridge = this->get_user_bridge(from);
+  Jid to(to_str);
+  Iid iid(to.local);
+
+  std::string error_type("cancel");
+  std::string error_name("internal-server-error");
+  utils::ScopeGuard stanza_error([&](){
+      this->send_stanza_error("message", from, to_str, id,
+                              error_type, error_name, "");
+    });
+  const XmlNode* body = stanza.get_child("body", COMPONENT_NS);
+
+  try {                         // catch IRCNotConnected exceptions
+  if (type == "groupchat" && iid.is_channel)
+    {
+      if (body && !body->get_inner().empty())
+        {
+          bridge->send_channel_message(iid, body->get_inner());
+        }
+      const XmlNode* subject = stanza.get_child("subject", COMPONENT_NS);
+      if (subject)
+        bridge->set_channel_topic(iid, subject->get_inner());
+    }
+  else if (type == "error")
+    {
+      const XmlNode* error = stanza.get_child("error", COMPONENT_NS);
+      // Only a set of errors are considered “fatal”. If we encounter one of
+      // them, we purge (we disconnect the user from all the IRC servers).
+      // We consider this to be true, unless the error condition is
+      // specified and is not in the kickable_errors set
+      bool kickable_error = true;
+      if (error && error->has_children())
+        {
+          const XmlNode* condition = error->get_last_child();
+          if (kickable_errors.find(condition->get_name()) == kickable_errors.end())
+            kickable_error = false;
+        }
+      if (kickable_error)
+        bridge->shutdown("Error from remote client");
+    }
+  else if (type == "chat")
+    {
+      if (body && !body->get_inner().empty())
+        {
+          // a message for nick!server
+          if (iid.is_user && !iid.get_local().empty())
+            {
+              bridge->send_private_message(iid, body->get_inner());
+              bridge->remove_preferred_from_jid(iid.get_local());
+            }
+          else if (!iid.is_user && !to.resource.empty())
+            { // a message for chan%server@biboumi/Nick or
+              // server@biboumi/Nick
+              // Convert that into a message to nick!server
+              Iid user_iid(utils::tolower(to.resource) + "!" + iid.get_server());
+              bridge->send_private_message(user_iid, body->get_inner());
+              bridge->set_preferred_from_jid(user_iid.get_local(), to_str);
+            }
+          else if (!iid.is_user && !iid.is_channel)
+            { // Message sent to the server JID
+              // Convert the message body into a raw IRC message
+              bridge->send_raw_message(iid.get_server(), body->get_inner());
+            }
+        }
+    }
+  else if (iid.is_user)
+    this->send_invalid_user_error(to.local, from);
+  } catch (const IRCNotConnected& ex)
+    {
+      this->send_stanza_error("message", from, to_str, id,
+                              "cancel", "remote-server-not-found",
+                              "Not connected to IRC server "s + ex.hostname,
+                              true);
+    }
+  stanza_error.disable();
+}
+
+// We MUST return an iq, whatever happens, except if the type is
+// "result".
+// To do this, we use a scopeguard. If an exception is raised somewhere, an
+// iq of type error "internal-server-error" is sent. If we handle the
+// request properly (by calling a function that registers an iq to be sent
+// later, or that directly sends an iq), we disable the ScopeGuard. If we
+// reach the end of the function without having disabled the scopeguard, we
+// send a "feature-not-implemented" iq as a result.  If an other kind of
+// error is found (for example the feature is implemented in biboumi, but
+// the request is missing some attribute) we can just change the values of
+// error_type and error_name and return from the function (without disabling
+// the scopeguard); an iq error will be sent
+void BiboumiComponent::handle_iq(const Stanza& stanza)
+{
+  std::string id = stanza.get_tag("id");
+  std::string from = stanza.get_tag("from");
+  std::string to_str = stanza.get_tag("to");
+  std::string type = stanza.get_tag("type");
+
+  if (from.empty()) {
+    log_warning("Received an iq without a 'from'. Ignoring.");
+    return;
+  }
+  if (id.empty() || to_str.empty() || type.empty())
+    {
+      this->send_stanza_error("iq", from, this->served_hostname, id,
+                              "modify", "bad-request", "");
+      return;
+    }
+
+  Bridge* bridge = this->get_user_bridge(from);
+  Jid to(to_str);
+
+  // These two values will be used in the error iq sent if we don't disable
+  // the scopeguard.
+  std::string error_type("cancel");
+  std::string error_name("internal-server-error");
+  utils::ScopeGuard stanza_error([&](){
+      this->send_stanza_error("iq", from, to_str, id,
+                              error_type, error_name, "");
+    });
+  try {
+  if (type == "set")
+    {
+      const XmlNode* query;
+      if ((query = stanza.get_child("query", MUC_ADMIN_NS)))
+        {
+          const XmlNode* child = query->get_child("item", MUC_ADMIN_NS);
+          if (child)
+            {
+              std::string nick = child->get_tag("nick");
+              std::string role = child->get_tag("role");
+              std::string affiliation = child->get_tag("affiliation");
+              if (!nick.empty())
+                {
+                  Iid iid(to.local);
+                  if (role == "none")
+                    {               // This is a kick
+                      std::string reason;
+                      const XmlNode* reason_el = child->get_child("reason", MUC_ADMIN_NS);
+                      if (reason_el)
+                        reason = reason_el->get_inner();
+                      bridge->send_irc_kick(iid, nick, reason, id, from);
+                    }
+                  else
+                    bridge->forward_affiliation_role_change(iid, nick, affiliation, role);
+                  stanza_error.disable();
+                }
+            }
+        }
+      else if ((query = stanza.get_child("command", ADHOC_NS)))
+        {
+          Stanza response("iq");
+          response["to"] = from;
+          response["from"] = to_str;
+          response["id"] = id;
+
+          // Depending on the 'to' jid in the request, we use one adhoc
+          // command handler or an other
+          Iid iid(to.local);
+          AdhocCommandsHandler* adhoc_handler;
+          if (!to.local.empty() && !iid.is_user && !iid.is_channel)
+            adhoc_handler = &this->irc_server_adhoc_commands_handler;
+          else if (!to.local.empty() && iid.is_channel)
+            adhoc_handler = &this->irc_channel_adhoc_commands_handler;
+          else
+            adhoc_handler = &this->adhoc_commands_handler;
+
+          // Execute the command, if any, and get a result XmlNode that we
+          // insert in our response
+          XmlNode inner_node = adhoc_handler->handle_request(from, to_str, *query);
+          if (inner_node.get_child("error", ADHOC_NS))
+            response["type"] = "error";
+          else
+            response["type"] = "result";
+          response.add_child(std::move(inner_node));
+          this->send_stanza(response);
+          stanza_error.disable();
+        }
+    }
+  else if (type == "get")
+    {
+      const XmlNode* query;
+      if ((query = stanza.get_child("query", DISCO_INFO_NS)))
+        { // Disco info
+          if (to_str == this->served_hostname)
+            {
+              const std::string node = query->get_tag("node");
+              if (node.empty())
+                {
+                  // On the gateway itself
+                  this->send_self_disco_info(id, from);
+                  stanza_error.disable();
+                }
+            }
+        }
+      else if ((query = stanza.get_child("query", VERSION_NS)))
+        {
+          Iid iid(to.local);
+          if (iid.is_user ||
+              (iid.is_channel && !to.resource.empty()))
+            {
+              // Get the IRC user version
+              std::string target;
+              if (iid.is_user)
+                target = iid.get_local();
+              else
+                target = to.resource;
+              bridge->send_irc_version_request(iid.get_server(), target, id,
+                                               from, to_str);
+            }
+          else
+            {
+              // On the gateway itself or on a channel
+              this->send_version(id, from, to_str);
+            }
+          stanza_error.disable();
+        }
+      else if ((query = stanza.get_child("query", DISCO_ITEMS_NS)))
+        {
+          Iid iid(to.local);
+          const std::string node = query->get_tag("node");
+          if (node == ADHOC_NS)
+            {
+              Jid from_jid(from);
+              if (to.local.empty())
+                {               // Get biboumi's adhoc commands
+                  this->send_adhoc_commands_list(id, from, this->served_hostname,
+                                                 (Config::get("admin", "") ==
+                                                  from_jid.bare()),
+                                                 this->adhoc_commands_handler);
+                  stanza_error.disable();
+                }
+              else if (!iid.is_user && !iid.is_channel)
+                {               // Get the server's adhoc commands
+                  this->send_adhoc_commands_list(id, from, to_str,
+                                                 (Config::get("admin", "") ==
+                                                  from_jid.bare()),
+                                                 this->irc_server_adhoc_commands_handler);
+                  stanza_error.disable();
+                }
+              else if (!iid.is_user && iid.is_channel)
+                {               // Get the channel's adhoc commands
+                  this->send_adhoc_commands_list(id, from, to_str,
+                                                 (Config::get("admin", "") ==
+                                                  from_jid.bare()),
+                                                 this->irc_channel_adhoc_commands_handler);
+                  stanza_error.disable();
+                }
+            }
+          else if (node.empty() && !iid.is_user && !iid.is_channel)
+            { // Disco on an IRC server: get the list of channels
+              bridge->send_irc_channel_list_request(iid, id, from);
+              stanza_error.disable();
+            }
+        }
+      else if ((query = stanza.get_child("ping", PING_NS)))
+        {
+          Iid iid(to.local);
+          if (iid.is_user)
+            { // Ping any user (no check on the nick done ourself)
+              bridge->send_irc_user_ping_request(iid.get_server(),
+                                                 iid.get_local(), id, from, to_str);
+            }
+          else if (iid.is_channel && !to.resource.empty())
+            { // Ping a room participant (we check if the nick is in the room)
+              bridge->send_irc_participant_ping_request(iid,
+                                                        to.resource, id, from, to_str);
+            }
+          else
+            { // Ping a channel, a server or the gateway itself
+              bridge->on_gateway_ping(iid.get_server(),
+                                     id, from, to_str);
+            }
+          stanza_error.disable();
+        }
+    }
+  else if (type == "result")
+    {
+      stanza_error.disable();
+      const XmlNode* query;
+      if ((query = stanza.get_child("query", VERSION_NS)))
+        {
+          const XmlNode* name_node = query->get_child("name", VERSION_NS);
+          const XmlNode* version_node = query->get_child("version", VERSION_NS);
+          const XmlNode* os_node = query->get_child("os", VERSION_NS);
+          std::string name;
+          std::string version;
+          std::string os;
+          if (name_node)
+            name = name_node->get_inner() + " (through the biboumi gateway)";
+          if (version_node)
+            version = version_node->get_inner();
+          if (os_node)
+            os = os_node->get_inner();
+          const Iid iid(to.local);
+          bridge->send_xmpp_version_to_irc(iid, name, version, os);
+        }
+      else
+        {
+          const auto it = this->waiting_iq.find(id);
+          if (it != this->waiting_iq.end())
+            {
+              it->second(bridge, stanza);
+              this->waiting_iq.erase(it);
+            }
+        }
+    }
+  }
+  catch (const IRCNotConnected& ex)
+    {
+      this->send_stanza_error("iq", from, to_str, id,
+                              "cancel", "remote-server-not-found",
+                              "Not connected to IRC server "s + ex.hostname,
+                              true);
+      stanza_error.disable();
+      return;
+    }
+  error_type = "cancel";
+  error_name = "feature-not-implemented";
+}
+
+Bridge* BiboumiComponent::get_user_bridge(const std::string& user_jid)
+{
+  auto bare_jid = Jid{user_jid}.bare();
+  try
+    {
+      return this->bridges.at(bare_jid).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      this->bridges.emplace(bare_jid, std::make_unique<Bridge>(bare_jid, *this, this->poller));
+      return this->bridges.at(bare_jid).get();
+    }
+}
+
+Bridge* BiboumiComponent::find_user_bridge(const std::string& full_jid)
+{
+  auto bare_jid = Jid{full_jid}.bare();
+  try
+    {
+      return this->bridges.at(bare_jid).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      return nullptr;
+    }
+}
+
+std::vector<Bridge*> BiboumiComponent::get_bridges() const
+{
+  std::vector<Bridge*> res;
+  for (auto it = this->bridges.begin(); it != this->bridges.end(); ++it)
+    res.push_back(it->second.get());
+  return res;
+}
+
+void BiboumiComponent::send_self_disco_info(const std::string& id, const std::string& jid_to)
+{
+  Stanza iq("iq");
+  iq["type"] = "result";
+  iq["id"] = id;
+  iq["to"] = jid_to;
+  iq["from"] = this->served_hostname;
+  XmlNode query("query");
+  query["xmlns"] = DISCO_INFO_NS;
+  XmlNode identity("identity");
+  identity["category"] = "conference";
+  identity["type"] = "irc";
+  identity["name"] = "Biboumi XMPP-IRC gateway";
+  query.add_child(std::move(identity));
+  for (const char* ns: {DISCO_INFO_NS, MUC_NS, ADHOC_NS})
+    {
+      XmlNode feature("feature");
+      feature["var"] = ns;
+      query.add_child(std::move(feature));
+    }
+  iq.add_child(std::move(query));
+  this->send_stanza(iq);
+}
+
+void BiboumiComponent::send_iq_version_request(const std::string& from,
+                                            const std::string& jid_to)
+{
+  Stanza iq("iq");
+  iq["type"] = "get";
+  iq["id"] = "version_"s + this->next_id();
+  iq["from"] = from + "@" + this->served_hostname;
+  iq["to"] = jid_to;
+  XmlNode query("query");
+  query["xmlns"] = VERSION_NS;
+  iq.add_child(std::move(query));
+  this->send_stanza(iq);
+}
+
+void BiboumiComponent::send_ping_request(const std::string& from,
+                                         const std::string& jid_to,
+                                         const std::string& id)
+{
+  Stanza iq("iq");
+  iq["type"] = "get";
+  iq["id"] = id;
+  iq["from"] = from + "@" + this->served_hostname;
+  iq["to"] = jid_to;
+  XmlNode ping("ping");
+  ping["xmlns"] = PING_NS;
+  iq.add_child(std::move(ping));
+  this->send_stanza(iq);
+
+  auto result_cb = [from, id](Bridge* bridge, const Stanza& stanza)
+    {
+      Jid to(stanza.get_tag("to"));
+      if (to.local != from)
+        {
+          log_error("Received a corresponding ping result, but the 'to' from "
+                    "the response mismatches the 'from' of the request");
+        }
+      else
+        bridge->send_irc_ping_result(from, id);
+    };
+  this->waiting_iq[id] = result_cb;
+}
+
+void BiboumiComponent::send_iq_room_list_result(const std::string& id,
+                                             const std::string& to_jid,
+                                             const std::string& from,
+                                             const std::vector<ListElement>& rooms_list)
+{
+  Stanza iq("iq");
+  iq["from"] = from + "@" + this->served_hostname;
+  iq["to"] = to_jid;
+  iq["id"] = id;
+  iq["type"] = "result";
+  XmlNode query("query");
+  query["xmlns"] = DISCO_ITEMS_NS;
+  for (const auto& room: rooms_list)
+    {
+      XmlNode item("item");
+      item["jid"] = room.channel + "%" + from + "@" + this->served_hostname;
+      query.add_child(std::move(item));
+    }
+  iq.add_child(std::move(query));
+  this->send_stanza(iq);
+}
diff --git a/src/xmpp/biboumi_component.hpp b/src/xmpp/biboumi_component.hpp
new file mode 100644
index 0000000..24d768a
--- /dev/null
+++ b/src/xmpp/biboumi_component.hpp
@@ -0,0 +1,109 @@
+#pragma once
+
+
+#include <xmpp/xmpp_component.hpp>
+
+#include <bridge/bridge.hpp>
+
+#include <memory>
+#include <string>
+#include <map>
+
+struct ListElement;
+
+/**
+ * A callback called when the waited iq result is received (it is matched
+ * against the iq id)
+ */
+using iq_responder_callback_t = std::function<void(Bridge* bridge, const Stanza& stanza)>;
+
+/**
+ * Interact with the Biboumi Bridge
+ */
+class BiboumiComponent: public XmppComponent
+{
+public:
+  explicit BiboumiComponent(std::shared_ptr<Poller> poller, const std::string& hostname, const std::string& secret);
+  ~BiboumiComponent() = default;
+
+  BiboumiComponent(const BiboumiComponent&) = delete;
+  BiboumiComponent(BiboumiComponent&&) = delete;
+  BiboumiComponent& operator=(const BiboumiComponent&) = delete;
+  BiboumiComponent& operator=(BiboumiComponent&&) = delete;
+
+  /**
+   * Returns the bridge for the given user. If it does not exist, return
+   * nullptr.
+   */
+  Bridge* find_user_bridge(const std::string& full_jid);
+  /**
+   * Return a list of all the managed bridges.
+   */
+  std::vector<Bridge*> get_bridges() const;
+
+  /**
+   * Send a "close" message to all our connected peers.  That message
+   * depends on the protocol used (this may be a QUIT irc message, or a
+   * <stream/>, etc).  We may also directly close the connection, or we may
+   * wait for the remote peer to acknowledge it before closing.
+   */
+  void shutdown();
+  /**
+   * Run a check on all bridges, to remove all disconnected (socket is
+   * closed, or no channel is joined) IrcClients. Some kind of garbage collector.
+   */
+  void clean();
+  /**
+   * Send a result IQ with the gateway disco informations.
+   */
+  void send_self_disco_info(const std::string& id, const std::string& jid_to);
+  /**
+   * Send an iq version request
+   */
+  void send_iq_version_request(const std::string& from,
+                               const std::string& jid_to);
+  /**
+   * Send a ping request
+   */
+  void send_ping_request(const std::string& from,
+                         const std::string& jid_to,
+                         const std::string& id);
+  /**
+   * Send the channels list in one big stanza
+   */
+  void send_iq_room_list_result(const std::string& id, const std::string& to_jid,
+                                const std::string& from,
+                                const std::vector<ListElement>& rooms_list);
+  /**
+   * Handle the various stanza types
+   */
+  void handle_presence(const Stanza& stanza);
+  void handle_message(const Stanza& stanza);
+  void handle_iq(const Stanza& stanza);
+
+private:
+  /**
+   * Return the bridge associated with the bare JID. Create a new one
+   * if none already exist.
+   */
+  Bridge* get_user_bridge(const std::string& user_jid);
+
+  /**
+   * A map of id -> callback.  When we want to wait for an iq result, we add
+   * the callback to this map, with the iq id as the key. When an iq result
+   * is received, we look for a corresponding callback in this map. If
+   * found, we call it and remove it.
+   */
+  std::map<std::string, iq_responder_callback_t> waiting_iq;
+
+  /**
+   * One bridge for each user of the component. Indexed by the user's bare
+   * jid
+   */
+  std::unordered_map<std::string, std::unique_ptr<Bridge>> bridges;
+
+  AdhocCommandsHandler irc_server_adhoc_commands_handler;
+  AdhocCommandsHandler irc_channel_adhoc_commands_handler;
+};
+
+