Implement the Bridge class to translate between the two protocols

Add all useful classes as well: Jid, Iid, IrcChannel, IrcUser etc to
properly keep the informations about what we receive from the IRC server.

Only handle the MUC join stanza, and send the list of users in the IRC
channel to the XMPP user, and the IRC channel’s topic, for now.

17 files changed, 694 insertions, 14 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 363eb79..bff724c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,7 +32,7 @@ add_library(network STATIC ${source_network})
 file(GLOB source_irc
   src/irc/*.[hc]pp)
 add_library(irc STATIC ${source_irc})
-target_link_libraries(irc network ${CRYPTO++_LIBRARIES} expatpp)
+target_link_libraries(irc network)
 
 #
 ## xmpplib
@@ -40,9 +40,18 @@ target_link_libraries(irc network ${CRYPTO++_LIBRARIES} expatpp)
 file(GLOB source_xmpp
   src/xmpp/*.[hc]pp)
 add_library(xmpp STATIC ${source_xmpp})
-target_link_libraries(xmpp network )
+target_link_libraries(xmpp bridge network ${CRYPTO++_LIBRARIES} expatpp)
+
+#
+## bridge
+#
+file(GLOB source_bridge
+  src/bridge/*.[hc]pp)
+add_library(bridge STATIC ${source_bridge})
+target_link_libraries(bridge xmpp irc)
 
 add_executable(${PROJECT_NAME} src/main.cpp)
 target_link_libraries(${PROJECT_NAME}
   xmpp
-  irc)
\ No newline at end of file
+  irc
+  bridge)
\ No newline at end of file
diff --git a/src/bridge/bridge.cpp b/src/bridge/bridge.cpp
new file mode 100644
index 0000000..638777d
--- /dev/null
+++ b/src/bridge/bridge.cpp
@@ -0,0 +1,57 @@
+#include <bridge/bridge.hpp>
+#include <xmpp/xmpp_component.hpp>
+#include <network/poller.hpp>
+
+Bridge::Bridge(const std::string& user_jid, XmppComponent* xmpp, Poller* poller):
+  user_jid(user_jid),
+  xmpp(xmpp),
+  poller(poller)
+{
+}
+
+Bridge::~Bridge()
+{
+}
+
+IrcClient* Bridge::get_irc_client(const std::string& hostname, const std::string& username)
+{
+  try
+    {
+      return this->irc_clients.at(hostname).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      this->irc_clients.emplace(hostname, std::make_shared<IrcClient>(hostname, username, this));
+      std::shared_ptr<IrcClient> irc = this->irc_clients.at(hostname);
+      this->poller->add_socket_handler(irc);
+      irc->start();
+      return irc.get();
+    }
+}
+
+void Bridge::join_irc_channel(const Iid& iid, const std::string& username)
+{
+  IrcClient* irc = this->get_irc_client(iid.server, username);
+  irc->send_join_command(iid.chan);
+}
+
+void Bridge::send_xmpp_message(const std::string& from, const std::string& author, const std::string& msg)
+{
+  const std::string body = std::string("[") + author + std::string("] ") + msg;
+  this->xmpp->send_message(from, body, this->user_jid);
+}
+
+void Bridge::send_user_join(const std::string& hostname, const std::string& chan_name, const std::string nick)
+{
+  this->xmpp->send_user_join(chan_name + "%" + hostname, nick, this->user_jid);
+}
+
+void Bridge::send_self_join(const std::string& hostname, const std::string& chan_name, const std::string nick)
+{
+  this->xmpp->send_self_join(chan_name + "%" + hostname, nick, this->user_jid);
+}
+
+void Bridge::send_topic(const std::string& hostname, const std::string& chan_name, const std::string topic)
+{
+  this->xmpp->send_topic(chan_name + "%" + hostname, topic, this->user_jid);
+}
diff --git a/src/bridge/bridge.hpp b/src/bridge/bridge.hpp
new file mode 100644
index 0000000..f9ddcca
--- /dev/null
+++ b/src/bridge/bridge.hpp
@@ -0,0 +1,94 @@
+#ifndef BRIDGE_INCLUDED
+# define BRIDGE_INCLUDED
+
+#include <irc/irc_client.hpp>
+#include <irc/iid.hpp>
+
+#include <unordered_map>
+#include <string>
+#include <memory>
+
+class XmppComponent;
+class Poller;
+
+/**
+ * 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, XmppComponent* xmpp, Poller* poller);
+  ~Bridge();
+
+  /***
+   **
+   ** From XMPP to IRC.
+   **
+   **/
+
+  void join_irc_channel(const Iid& iid, const std::string& username);
+
+  /***
+   **
+   ** From IRC to XMPP.
+   **
+   **/
+
+  /**
+   * Send a message corresponding to a server NOTICE, the from attribute
+   * should be juste the server hostname@irc.component.
+   */
+  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 std::string nick);
+  /**
+   * Send the self presence of an user when the MUC is fully joined.
+   */
+  void send_self_join(const std::string& hostname, const std::string& chan_name, const std::string nick);
+  /**
+   * 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);
+
+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* get_irc_client(const std::string& hostname, const std::string& username);
+  /**
+   * The JID of the user associated with this bridge. Messages from/to this
+   * JID are only managed by this bridge.
+   */
+  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;
+  /**
+   * A raw pointer, because we do not own it, the XMPP component owns us,
+   * but we still need to communicate with it, when sending messages from
+   * IRC to XMPP.
+   */
+  XmppComponent* xmpp;
+  /**
+   * Poller, to give it the IrcClients that we spawn, to make it manage
+   * their sockets.
+   * We don't own it.
+   */
+  Poller* poller;
+
+  Bridge(const Bridge&) = delete;
+  Bridge(Bridge&& other) = delete;
+  Bridge& operator=(const Bridge&) = delete;
+  Bridge& operator=(Bridge&&) = delete;
+};
+
+#endif // BRIDGE_INCLUDED
diff --git a/src/irc/iid.cpp b/src/irc/iid.cpp
new file mode 100644
index 0000000..ffc8d88
--- /dev/null
+++ b/src/irc/iid.cpp
@@ -0,0 +1,17 @@
+#include <irc/iid.hpp>
+
+Iid::Iid(const std::string& iid)
+{
+  std::string::size_type sep = iid.find("%");
+  if (sep != std::string::npos)
+    {
+      this->chan = iid.substr(0, sep);
+      sep++;
+    }
+  else
+    {
+      this->chan = iid;
+      return;
+    }
+  this->server = iid.substr(sep);
+}
diff --git a/src/irc/iid.hpp b/src/irc/iid.hpp
new file mode 100644
index 0000000..aacc9e6
--- /dev/null
+++ b/src/irc/iid.hpp
@@ -0,0 +1,34 @@
+#ifndef IID_INCLUDED
+# define IID_INCLUDED
+
+#include <string>
+
+/**
+ * A name representing an IRC channel, on the same model than the XMPP JIDs (but much simpler).
+ * The separator between the server and the channel name is '%'
+ * #test%irc.freenode.org has :
+ * - chan: "#test" (the # is part of the name, it could very well be absent, or & instead
+ * - server: "irc.freenode.org"
+ * #test has:
+ * - chan: "#test"
+ * - server: ""
+ * %irc.freenode.org:
+ * - chan: ""
+ * - server: "irc.freenode.org"
+ */
+class Iid
+{
+public:
+  explicit Iid(const std::string& iid);
+
+  std::string chan;
+  std::string server;
+
+private:
+  Iid(const Iid&) = delete;
+  Iid(Iid&&) = delete;
+  Iid& operator=(const Iid&) = delete;
+  Iid& operator=(Iid&&) = delete;
+};
+
+#endif // IID_INCLUDED
diff --git a/src/irc/irc_channel.cpp b/src/irc/irc_channel.cpp
new file mode 100644
index 0000000..223305b
--- /dev/null
+++ b/src/irc/irc_channel.cpp
@@ -0,0 +1,24 @@
+#include <irc/irc_channel.hpp>
+#include <utils/make_unique.hpp>
+
+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)
+{
+  this->users.emplace_back(std::make_unique<IrcUser>(name));
+  return this->users.back().get();
+}
+
+IrcUser* IrcChannel::get_self() const
+{
+  return this->self.get();
+}
diff --git a/src/irc/irc_channel.hpp b/src/irc/irc_channel.hpp
new file mode 100644
index 0000000..da0f298
--- /dev/null
+++ b/src/irc/irc_channel.hpp
@@ -0,0 +1,34 @@
+#ifndef IRC_CHANNEL_INCLUDED
+# define IRC_CHANNEL_INCLUDED
+
+#include <irc/irc_user.hpp>
+#include <memory>
+#include <string>
+#include <vector>
+
+/**
+ * Keep the state of a joined channel (the list of occupants with their
+ * informations (mode, etc), the modes, etc)
+ */
+class IrcChannel
+{
+public:
+  explicit IrcChannel();
+
+  bool joined;
+  std::string topic;
+  void set_self(const std::string& name);
+  IrcUser* get_self() const;
+  IrcUser* add_user(const std::string& name);
+
+private:
+  std::unique_ptr<IrcUser> self;
+  std::vector<std::unique_ptr<IrcUser>> users;
+
+  IrcChannel(const IrcChannel&) = delete;
+  IrcChannel(IrcChannel&&) = delete;
+  IrcChannel& operator=(const IrcChannel&) = delete;
+  IrcChannel& operator=(IrcChannel&&) = delete;
+};
+
+#endif // IRC_CHANNEL_INCLUDED
diff --git a/src/irc/irc_client.cpp b/src/irc/irc_client.cpp
index 80f36ee..7875b1c 100644
--- a/src/irc/irc_client.cpp
+++ b/src/irc/irc_client.cpp
@@ -1,10 +1,18 @@
-#include <irc/irc_client.hpp>
 #include <irc/irc_message.hpp>
+#include <irc/irc_client.hpp>
+#include <bridge/bridge.hpp>
+#include <irc/irc_user.hpp>
+
+#include <utils/make_unique.hpp>
+#include <utils/split.hpp>
 
 #include <iostream>
 #include <stdexcept>
 
-IrcClient::IrcClient()
+IrcClient::IrcClient(const std::string& hostname, const std::string& username, Bridge* bridge):
+  hostname(hostname),
+  username(username),
+  bridge(bridge)
 {
   std::cout << "IrcClient()" << std::endl;
 }
@@ -14,8 +22,15 @@ IrcClient::~IrcClient()
   std::cout << "~IrcClient()" << std::endl;
 }
 
+void IrcClient::start()
+{
+  this->connect(this->hostname, "6667");
+}
+
 void IrcClient::on_connected()
 {
+  this->send_nick_command(this->username);
+  this->send_user_command(this->username, this->username);
 }
 
 void IrcClient::on_connection_close()
@@ -23,6 +38,19 @@ void IrcClient::on_connection_close()
   std::cout << "Connection closed by remote server." << std::endl;
 }
 
+IrcChannel* IrcClient::get_channel(const std::string& name)
+{
+  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();
+    }
+}
+
 void IrcClient::parse_in_buffer()
 {
   while (true)
@@ -33,6 +61,21 @@ void IrcClient::parse_in_buffer()
       IrcMessage message(this->in_buf.substr(0, pos));
       this->in_buf = this->in_buf.substr(pos + 2, std::string::npos);
       std::cout << message << std::endl;
+      // TODO map function and command name properly
+      if (message.command == "PING")
+        this->send_pong_command();
+      else if (message.command == "NOTICE" ||
+               message.command == "375" ||
+               message.command == "372")
+        this->forward_server_message(message);
+      else if (message.command == "JOIN")
+        this->on_self_channel_join(message);
+      else if (message.command == "353")
+        this->set_and_forward_user_list(message);
+      else if (message.command == "332")
+        this->on_topic_received(message);
+      else if (message.command == "366")
+        this->on_channel_completely_joined(message);
     }
 }
 
@@ -52,6 +95,8 @@ void IrcClient::send_message(IrcMessage&& message)
       res += " " + arg;
     }
   res += "\r\n";
+  std::cout << "=== IRC SENDING ===" << std::endl;
+  std::cout << res << std::endl;
   this->send_data(std::move(res));
 }
 
@@ -67,5 +112,59 @@ void IrcClient::send_nick_command(const std::string& nick)
 
 void IrcClient::send_join_command(const std::string& chan_name)
 {
-  this->send_message(IrcMessage("JOIN", {chan_name}));
+  IrcChannel* channel = this->get_channel(chan_name);
+  if (channel->joined == false)
+    this->send_message(IrcMessage("JOIN", {chan_name}));
+}
+
+void IrcClient::send_pong_command()
+{
+  this->send_message(IrcMessage("PONG", {}));
+}
+
+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::set_and_forward_user_list(const IrcMessage& message)
+{
+  const std::string chan_name = 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)
+    {
+      IrcUser* user = channel->add_user(nick);
+      if (user->nick != channel->get_self()->nick)
+        {
+          std::cout << "Adding user [" << nick << "] to chan " << chan_name << std::endl;
+          this->bridge->send_user_join(this->hostname, chan_name, user->nick);
+        }
+    }
+}
+
+void IrcClient::on_self_channel_join(const IrcMessage& message)
+{
+  const std::string chan_name = message.arguments[0];
+  IrcChannel* channel = this->get_channel(chan_name);
+  channel->joined = true;
+  channel->set_self(message.prefix);
+}
+
+void IrcClient::on_topic_received(const IrcMessage& message)
+{
+  const std::string chan_name = message.arguments[1];
+  IrcChannel* channel = this->get_channel(chan_name);
+  channel->topic = message.arguments[2];
+}
+
+void IrcClient::on_channel_completely_joined(const IrcMessage& message)
+{
+  const std::string chan_name = message.arguments[1];
+  IrcChannel* channel = this->get_channel(chan_name);
+  this->bridge->send_self_join(this->hostname, chan_name, channel->get_self()->nick);
+  this->bridge->send_topic(this->hostname, chan_name, channel->topic);
 }
diff --git a/src/irc/irc_client.hpp b/src/irc/irc_client.hpp
index e380f5b..db1b83b 100644
--- a/src/irc/irc_client.hpp
+++ b/src/irc/irc_client.hpp
@@ -2,11 +2,16 @@
 # define IRC_CLIENT_INCLUDED
 
 #include <irc/irc_message.hpp>
+#include <irc/irc_channel.hpp>
+#include <irc/iid.hpp>
 
 #include <network/socket_handler.hpp>
 
+#include <unordered_map>
 #include <string>
 
+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.
@@ -16,9 +21,13 @@
 class IrcClient: public SocketHandler
 {
 public:
-  explicit IrcClient();
+  explicit IrcClient(const std::string& hostname, const std::string& username, Bridge* bridge);
   ~IrcClient();
   /**
+   * Connect to the IRC server
+   */
+  void start();
+  /**
    * Called when successfully connected to the server
    */
   void on_connected();
@@ -32,12 +41,20 @@ public:
    */
   void parse_in_buffer();
   /**
+   * Return the channel with this name, create it if it does not yet exist
+   */
+  IrcChannel* get_channel(const std::string& name);
+  /**
    * 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);
   /**
+   * Send the PONG irc command
+   */
+  void send_pong_command();
+  /**
    * Send the USER irc command
    */
   void send_user_command(const std::string& username, const std::string& realname);
@@ -49,8 +66,49 @@ public:
    * Send the JOIN irc command
    */
   void send_join_command(const std::string& chan_name);
+  /**
+   * Forward the server message received from IRC to the XMPP component
+   */
+  void forward_server_message(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);
+  /**
+   * 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_self_channel_join(const IrcMessage& message);
+  /**
+   * Save the topic in the IrcChannel
+   */
+  void on_topic_received(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);
 
 private:
+  /**
+   * The hostname of the server we are connected to.
+   */
+  const std::string hostname;
+  /**
+   * The user name used in the USER irc command
+   */
+  const std::string username;
+  /**
+   * Raw pointer because the bridge owns us.
+   */
+  Bridge* bridge;
+
+  /**
+   * The list of joined channels, indexed by name
+   */
+  std::unordered_map<std::string, std::unique_ptr<IrcChannel>> channels;
+
   IrcClient(const IrcClient&) = delete;
   IrcClient(IrcClient&&) = delete;
   IrcClient& operator=(const IrcClient&) = delete;
diff --git a/src/irc/irc_user.cpp b/src/irc/irc_user.cpp
new file mode 100644
index 0000000..fc853bc
--- /dev/null
+++ b/src/irc/irc_user.cpp
@@ -0,0 +1,24 @@
+#include <irc/irc_user.hpp>
+
+#include <iostream>
+
+IrcUser::IrcUser(const std::string& name)
+{
+  const std::string::size_type sep = name.find("!");
+  if (sep == std::string::npos)
+    {
+      if (name[0] == '@' || name[0] == '+')
+        this->nick = name.substr(1);
+      else
+        this->nick = name;
+    }
+  else
+    {
+      if (name[0] == '@' || name[0] == '+')
+        this->nick = name.substr(1, sep);
+      else
+        this->nick = name.substr(0, sep);
+      this->host = name.substr(sep+1);
+    }
+  std::cout << "Created user: [" << this->nick << "!" << this->host << std::endl;
+}
diff --git a/src/irc/irc_user.hpp b/src/irc/irc_user.hpp
new file mode 100644
index 0000000..b76b2ef
--- /dev/null
+++ b/src/irc/irc_user.hpp
@@ -0,0 +1,24 @@
+#ifndef IRC_USER_INCLUDED
+# define IRC_USER_INCLUDED
+
+#include <string>
+
+/**
+ * Keeps various information about one IRC channel user
+ */
+class IrcUser
+{
+public:
+  explicit IrcUser(const std::string& name);
+
+  std::string nick;
+  std::string host;
+
+private:
+  IrcUser(const IrcUser&) = delete;
+  IrcUser(IrcUser&&) = delete;
+  IrcUser& operator=(const IrcUser&) = delete;
+  IrcUser& operator=(IrcUser&&) = delete;
+};
+
+#endif // IRC_USER_INCLUDED
diff --git a/src/main.cpp b/src/main.cpp
index fe3b2e5..b0fb140 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,6 +1,17 @@
 #include <irc/irc_client.hpp>
+#include <xmpp/xmpp_component.hpp>
 #include <network/poller.hpp>
 
+#include <xmpp/xmpp_parser.hpp>
+#include <xmpp/xmpp_stanza.hpp>
+
+#include <memory>
+
+#include <xmpp/jid.hpp>
+#include <irc/iid.hpp>
+
+#include <iostream>
+
 int main()
 {
   Poller p;
diff --git a/src/xmpp/jid.cpp b/src/xmpp/jid.cpp
new file mode 100644
index 0000000..78b28a0
--- /dev/null
+++ b/src/xmpp/jid.cpp
@@ -0,0 +1,19 @@
+#include <xmpp/jid.hpp>
+
+Jid::Jid(const std::string& jid)
+{
+  std::string::size_type at = jid.find("@");
+  if (at != std::string::npos)
+    {
+      this->local = jid.substr(0, at);
+      at++;
+    }
+  else
+    at = 0;
+  std::string::size_type slash = jid.find("/", at);
+  if (slash != std::string::npos)
+    {
+      this->resource = jid.substr(slash + 1);
+    }
+  this->domain = jid.substr(at, slash - at);
+}
diff --git a/src/xmpp/jid.hpp b/src/xmpp/jid.hpp
new file mode 100644
index 0000000..3027497
--- /dev/null
+++ b/src/xmpp/jid.hpp
@@ -0,0 +1,26 @@
+#ifndef JID_INCLUDED
+# define JID_INCLUDED
+
+#include <string>
+
+/**
+ * Parse a JID into its different subart
+ */
+class Jid
+{
+public:
+  explicit Jid(const std::string& jid);
+
+  std::string domain;
+  std::string local;
+  std::string resource;
+
+private:
+  Jid(const Jid&) = delete;
+  Jid(Jid&&) = delete;
+  Jid& operator=(const Jid&) = delete;
+  Jid& operator=(Jid&&) = delete;
+};
+
+
+#endif // JID_INCLUDED
diff --git a/src/xmpp/stanza.hpp b/src/xmpp/stanza.hpp
new file mode 100644
index 0000000..697bda4
--- /dev/null
+++ b/src/xmpp/stanza.hpp
@@ -0,0 +1,18 @@
+#ifndef Stanza
+# define Stanza
+
+class Stanza
+{
+public:
+  explicit Stanza();
+  ~Stanza();
+private:
+  Stanza(const Stanza&) = delete;
+  Stanza(Stanza&&) = delete;
+  Stanza& operator=(const Stanza&) = delete;
+  Stanza& operator=(Stanza&&) = delete;
+};
+
+#endif // Stanza
+
+
diff --git a/src/xmpp/xmpp_component.cpp b/src/xmpp/xmpp_component.cpp
index 0563aa7..3a288c7 100644
--- a/src/xmpp/xmpp_component.cpp
+++ b/src/xmpp/xmpp_component.cpp
@@ -1,4 +1,7 @@
+#include <utils/make_unique.hpp>
+
 #include <xmpp/xmpp_component.hpp>
+#include <xmpp/jid.hpp>
 
 #include <iostream>
 
@@ -20,6 +23,8 @@ XmppComponent::XmppComponent(const std::string& hostname, const std::string& sec
                                                   std::placeholders::_1));
   this->stanza_handlers.emplace("handshake",
                                 std::bind(&XmppComponent::handle_handshake, this,std::placeholders::_1));
+  this->stanza_handlers.emplace("presence",
+                                std::bind(&XmppComponent::handle_presence, this,std::placeholders::_1));
 }
 
 XmppComponent::~XmppComponent()
@@ -46,7 +51,6 @@ void XmppComponent::on_connected()
   node["xmlns:stream"] = "http://etherx.jabber.org/streams";
   node["to"] = "irc.abricot";
   this->send_stanza(node);
-
 }
 
 void XmppComponent::on_connection_close()
@@ -99,16 +103,17 @@ void XmppComponent::on_stanza(const Stanza& stanza)
 {
   std::cout << "=========== STANZA ============" << std::endl;
   std::cout << stanza.to_string() << std::endl;
+  std::function<void(const Stanza&)> handler;
   try
     {
-      const auto& handler = this->stanza_handlers.at(stanza.get_name());
-      handler(stanza);
+      handler = this->stanza_handlers.at(stanza.get_name());
     }
   catch (const std::out_of_range& exception)
     {
       std::cout << "No handler for stanza of type " << stanza.get_name() << std::endl;
       return;
     }
+  handler(stanza);
 }
 
 void XmppComponent::send_stream_error(const std::string& name, const std::string& explanation)
@@ -133,5 +138,104 @@ void XmppComponent::close_document()
 
 void XmppComponent::handle_handshake(const Stanza& stanza)
 {
+  (void)stanza;
   this->authenticated = true;
 }
+
+void XmppComponent::handle_presence(const Stanza& stanza)
+{
+  Bridge* bridge = this->get_user_bridge(stanza["from"]);
+  Jid to(stanza["to"]);
+  Iid iid(to.local);
+  if (!iid.chan.empty() && !iid.server.empty())
+    bridge->join_irc_channel(iid, to.resource);
+}
+
+Bridge* XmppComponent::get_user_bridge(const std::string& user_jid)
+{
+  try
+    {
+      return this->bridges.at(user_jid).get();
+    }
+  catch (const std::out_of_range& exception)
+    {
+      this->bridges.emplace(user_jid, std::make_unique<Bridge>(user_jid, this, this->poller));
+      return this->bridges.at(user_jid).get();
+    }
+}
+
+void XmppComponent::send_message(const std::string& from, const std::string& body, const std::string& to)
+{
+  XmlNode node("message");
+  node["to"] = to;
+  node["from"] = from + "@" + this->served_hostname;
+  XmlNode body_node("body");
+  body_node.set_inner(body);
+  body_node.close();
+  node.add_child(std::move(body_node));
+  node.close();
+  this->send_stanza(node);
+}
+
+void XmppComponent::send_user_join(const std::string& from, const std::string& nick, const std::string& to)
+{
+  XmlNode node("presence");
+  node["to"] = to;
+  node["from"] = from + "@" + this->served_hostname + "/" + nick;
+
+  XmlNode x("x");
+  x["xmlns"] = "http://jabber.org/protocol/muc#user";
+
+  // TODO: put real values here
+  XmlNode item("item");
+  item["affiliation"] = "member";
+  item["role"] = "participant";
+  item.close();
+  x.add_child(std::move(item));
+  x.close();
+  node.add_child(std::move(x));
+  node.close();
+  this->send_stanza(node);
+}
+
+void XmppComponent::send_self_join(const std::string& from, const std::string& nick, const std::string& to)
+{
+  XmlNode node("presence");
+  node["to"] = to;
+  node["from"] = from + "@" + this->served_hostname + "/" + nick;
+
+  XmlNode x("x");
+  x["xmlns"] = "http://jabber.org/protocol/muc#user";
+
+  // TODO: put real values here
+  XmlNode item("item");
+  item["affiliation"] = "member";
+  item["role"] = "participant";
+  item.close();
+  x.add_child(std::move(item));
+
+  XmlNode status("status");
+  status["code"] = "110";
+  status.close();
+  x.add_child(std::move(status));
+
+  x.close();
+
+  node.add_child(std::move(x));
+  node.close();
+  this->send_stanza(node);
+}
+
+void XmppComponent::send_topic(const std::string& from, const std::string& topic, const std::string& to)
+{
+  XmlNode message("message");
+  message["to"] = to;
+  message["from"] = from + "@" + this->served_hostname;
+  message["type"] = "groupchat";
+  XmlNode subject("subject");
+  subject.set_inner(topic);
+  subject.close();
+  message.add_child(std::move(subject));
+  message.close();
+  this->send_stanza(message);
+}
diff --git a/src/xmpp/xmpp_component.hpp b/src/xmpp/xmpp_component.hpp
index 464ecaa..725b495 100644
--- a/src/xmpp/xmpp_component.hpp
+++ b/src/xmpp/xmpp_component.hpp
@@ -1,13 +1,13 @@
 #ifndef XMPP_COMPONENT_INCLUDED
 # define XMPP_COMPONENT_INCLUDED
 
-#include <string>
-
 #include <network/socket_handler.hpp>
-
 #include <xmpp/xmpp_parser.hpp>
+#include <bridge/bridge.hpp>
 
 #include <unordered_map>
+#include <memory>
+#include <string>
 
 /**
  * An XMPP component, communicating with an XMPP server using the protocole
@@ -55,13 +55,35 @@ public:
    * Send the closing signal for our document (not closing the connection though).
    */
   void close_document();
-
+  /**
+   * Send a message from from@served_hostname, with the given body
+   */
+  void send_message(const std::string& from, const std::string& body, const std::string& to);
+  /**
+   * Send a join from a new participant
+   */
+  void send_user_join(const std::string& from, const std::string& nick, const std::string& to);
+  /**
+   * Send the self join to the user
+   */
+  void send_self_join(const std::string& from, const std::string& nick, const std::string& to);
+  /**
+   * Send the MUC topic to the user
+   */
+  void send_topic(const std::string& from, const std::string& topic, const std::string& to);
   /**
    * Handle the various stanza types
    */
   void handle_handshake(const Stanza& stanza);
+  void handle_presence(const Stanza& stanza);
 
 private:
+  /**
+   * Return the bridge associated with the given full JID. Create a new one
+   * if none already exist.
+   */
+  Bridge* get_user_bridge(const std::string& user_jid);
+
   XmppParser parser;
   std::string stream_id;
   std::string served_hostname;
@@ -70,6 +92,12 @@ private:
 
   std::unordered_map<std::string, std::function<void(const Stanza&)>> stanza_handlers;
 
+  /**
+   * One bridge for each user of the component. Indexed by the user's full
+   * jid
+   */
+  std::unordered_map<std::string, std::unique_ptr<Bridge>> bridges;
+
   XmppComponent(const XmppComponent&) = delete;
   XmppComponent(XmppComponent&&) = delete;
   XmppComponent& operator=(const XmppComponent&) = delete;