Commit 158d743b authored by louiz’'s avatar louiz’

Remove the virtual channel feature altogether

parent 8503d1f6
......@@ -2,6 +2,8 @@ Version 8.0
===========
- Add a complete='true' in MAM’s iq result when appropriate
- The “virtual” channel with an empty name (for example
%irc.freenode.net@biboumi) has been entirely removed.
Version 7.2 - 2018-01-24
========================
......
......@@ -103,16 +103,15 @@ fixed_irc_server
If this option contains the hostname of an IRC server (for example
irc.example.org), then biboumi will enforce the connexion to that IRC
server only. This means that a JID like ``#chan@biboumi.example.com`` must
be used instead of ``#chan%irc.example.org@biboumi.example.com``. In that
mode, the virtual channel (see `Connect to an IRC server`_) is not
available. The `%` character loses any meaning in the JIDs. It can appear
in the JID but will not be interpreted as a separator (thus the JID
server only. This means that a JID like ``#chan@biboumi.example.com``
must be used instead of ``#chan%irc.example.org@biboumi.example.com``. The
`%` character loses any meaning in the JIDs. It can appear in the JID but
will not be interpreted as a separator (thus the JID
``#channel%hello@biboumi.example.com`` points to the channel named
``#channel%hello`` on the configured IRC server) This option can for example
be used by an administrator that just wants to let their users join their own
IRC server using an XMPP client, while forbidding access to any other IRC
server.
``#channel%hello`` on the configured IRC server) This option can for
example be used by an administrator that just wants to let their users
join their own IRC server using an XMPP client, while forbidding access to
any other IRC server.
persistent_by_default
---------------------
......@@ -295,10 +294,6 @@ the two is based on the first character: by default, if the name starts with
``'#'`` or ``'&'`` (but this can be overridden by the server, using the
ISUPPORT extension) then it’s a channel name, otherwise this is a nickname.
As a special case, the channel name can also be empty (for example
``%irc.example.com``), in that case this represents the virtual channel
provided by biboumi. See `Connect to an IRC server`_ for more details.
There is two ways to address an IRC user, using a local part like this:
``nickname`` % ``irc_server`` or by using the in-room address of the
participant, like this:
......@@ -336,9 +331,6 @@ Examples:
* ``irc.example.com@biboumi.example.com`` is the IRC server irc.example.com.
* ``%irc.example.com@biboumi.example.com`` is the virtual channel provided by
biboumi, for the IRC server irc.example.com.
Note: Some JIDs are valid but make no sense in the context of
biboumi:
......@@ -362,16 +354,7 @@ Connect to an IRC server
The connection to the IRC server is automatically made when the user tries
to join any channel on that IRC server. The connection is closed whenever
the last channel on that server is left by the user. To be able to stay
connected to an IRC server without having to be in a real IRC channel,
biboumi provides a virtual channel on the jid
``%irc.example.com@biboumi.example.com``. For example if you want to join the
channel ``#foo`` on the server ``irc.example.com``, but you need to authenticate
to a bot of the server before you’re allowed to join it, you can first join
the room ``%irc.example.com@biboumi.example.com`` (this will effectively
connect you to the IRC server without joining any channel), then send your
authentication message to the user ``bot%irc.example.com@biboumi.example.com``
and finally join the room ``#foo%irc.example.com@biboumi.example.com``.
the last channel on that server is left by the user.
Roster
------
......
......@@ -63,7 +63,6 @@ void Bridge::shutdown(const std::string& exit_message)
for (auto& pair: this->irc_clients)
{
pair.second->send_quit_command(exit_message);
pair.second->leave_dummy_channel(exit_message, {});
}
}
......@@ -176,35 +175,6 @@ bool Bridge::join_irc_channel(const Iid& iid, const std::string& nickname, const
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 (res_in_chan)
return false;
// Immediately simulate a message coming from the IRC server saying that we
// joined the channel
if (irc->get_dummy_channel().joined)
{
this->generate_channel_join_for_resource(iid, resource);
}
else
{
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);
......@@ -445,11 +415,7 @@ void Bridge::leave_irc_channel(Iid&& iid, const std::string& status_message, con
#endif
if (channel->joined && !channel->parting && !persistent)
{
const auto& chan_name = iid.get_local();
if (chan_name.empty())
irc->leave_dummy_channel(status_message, resource);
else
irc->send_part_command(iid.get_local(), status_message);
irc->send_part_command(iid.get_local(), status_message);
}
else if (channel->joined)
{
......@@ -1254,9 +1220,6 @@ std::size_t Bridge::number_of_channels_the_resource_is_in(const std::string& irc
res++;
}
IrcClient* irc = this->find_irc_client(irc_hostname);
if (irc && (irc->get_dummy_channel().joined || irc->get_dummy_channel().joining))
res++;
return res;
}
......
......@@ -58,9 +58,3 @@ void IrcChannel::remove_all_users()
this->users.clear();
this->self = nullptr;
}
DummyIrcChannel::DummyIrcChannel():
IrcChannel(),
joining(false)
{
}
......@@ -42,33 +42,3 @@ protected:
IrcUser* self{nullptr};
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;
};
......@@ -145,14 +145,6 @@ IrcClient::IrcClient(std::shared_ptr<Poller>& poller, std::string hostname,
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());
......@@ -315,8 +307,6 @@ void IrcClient::on_connection_close(const std::string& error_msg)
IrcChannel* IrcClient::get_channel(const std::string& n)
{
if (n.empty())
return &this->dummy_channel;
const std::string name = utils::tolower(n);
try
{
......@@ -670,10 +660,7 @@ 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);
channel = this->get_channel(chan_name);
const std::string nick = message.prefix;
IrcUser* user = channel->add_user(nick, this->prefix_to_mode);
if (channel->joined == false)
......@@ -948,18 +935,6 @@ void IrcClient::on_welcome_message(const IrcMessage& message)
if (!channels_with_key.empty())
this->send_join_command(channels_with_key, keys);
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)
......@@ -1062,10 +1037,6 @@ void IrcClient::on_nick(const IrcMessage& message)
}
};
if (this->get_dummy_channel().joined)
{
change_nick_func("", &this->get_dummy_channel());
}
for (const auto& pair: this->channels)
{
change_nick_func(pair.first, pair.second.get());
......@@ -1248,25 +1219,7 @@ void IrcClient::on_unknown_message(const IrcMessage& message)
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, const std::string& resource)
{
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("%" + this->hostname, this->chantypes), std::string(this->current_nick), exit_message, true, true, resource);
return this->channels.size();
}
#ifdef BOTAN_FOUND
......
......@@ -279,15 +279,6 @@ public:
* 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& resource);
const std::string& get_hostname() const { return this->hostname; }
std::string get_nick() const { return this->current_nick; }
......@@ -339,11 +330,6 @@ private:
* 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
......
......@@ -148,8 +148,7 @@ void BiboumiComponent::handle_presence(const Stanza& stanza)
try {
if (iid.type == Iid::Type::Channel && !iid.get_server().empty())
{ // presence toward a MUC that corresponds to an irc channel, or a
// dummy channel if iid.chan is empty
{ // presence toward a MUC that corresponds to an irc channel
if (type.empty())
{
const std::string own_nick = bridge->get_own_nick(iid);
......
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment