/*
* ngIRCd -- The Next Generation IRC Daemon
- * Copyright (c)2001-2011 Alexander Barton (alex@barton.de) and Contributors.
+ * Copyright (c)2001-2014 Alexander Barton (alex@barton.de) and Contributors.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* Channel management
*/
-#include "imp.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <strings.h>
+#include <time.h>
-#include "defines.h"
#include "conn-func.h"
-#include "exp.h"
#include "channel.h"
-#include "imp.h"
#include "irc-write.h"
#include "conf.h"
#include "hash.h"
-#include "lists.h"
#include "log.h"
#include "messages.h"
#include "match.h"
-
-#include "exp.h"
-
+#include "parse.h"
+#include "irc-mode.h"
#define REMOVE_PART 0
#define REMOVE_QUIT 1
#define REMOVE_KICK 2
-
static CHANNEL *My_Channels;
static CL2CHAN *My_Cl2Chan;
-
static CL2CHAN *Get_Cl2Chan PARAMS(( CHANNEL *Chan, CLIENT *Client ));
static CL2CHAN *Add_Client PARAMS(( CHANNEL *Chan, CLIENT *Client ));
static bool Remove_Client PARAMS(( int Type, CHANNEL *Chan, CLIENT *Client, CLIENT *Origin, const char *Reason, bool InformServer ));
GLOBAL void
Channel_Init( void )
{
- CHANNEL *sc;
-
My_Channels = NULL;
My_Cl2Chan = NULL;
-
- sc = Channel_Create("&SERVER");
- if (sc) {
- Channel_SetModes(sc, "mnPt");
- Channel_SetTopic(sc, Client_ThisServer(), "Server Messages");
- }
} /* Channel_Init */
}
+GLOBAL struct list_head *
+Channel_GetListExcepts(CHANNEL *c)
+{
+ assert(c != NULL);
+ return &c->list_excepts;
+}
+
+
GLOBAL struct list_head *
Channel_GetListInvites(CHANNEL *c)
{
}
+/**
+ * Generate predefined persistent channels and &SERVER
+ */
GLOBAL void
Channel_InitPredefined( void )
{
- /* Generate predefined persistent channels */
-
CHANNEL *new_chan;
+ REQUEST Req;
const struct Conf_Channel *conf_chan;
- const char *c;
- size_t i, channel_count = array_length(&Conf_Channels, sizeof(*conf_chan));
+ char *c;
+ char modes[COMMAND_LEN], name[CHANNEL_NAME_LEN];
+ size_t i, n, channel_count = array_length(&Conf_Channels, sizeof(*conf_chan));
conf_chan = array_start(&Conf_Channels);
new_chan = Channel_Create(conf_chan->name);
if (!new_chan) {
- Log(LOG_ERR, "Can't create pre-defined channel \"%s\"",
+ Log(LOG_ERR, "Can't create pre-defined channel \"%s\"!",
conf_chan->name);
continue;
}
- Log(LOG_INFO, "Created pre-defined channel \"%s\"",
- conf_chan->name);
-
Channel_ModeAdd(new_chan, 'P');
if (conf_chan->topic[0])
Channel_SetTopic(new_chan, NULL, conf_chan->topic);
- c = conf_chan->modes;
- while (*c)
- Channel_ModeAdd(new_chan, *c++);
+ /* Evaluate modes strings with fake requests */
+ if (conf_chan->modes_num) {
+ /* Prepare fake request structure */
+ strlcpy(name, conf_chan->name, sizeof(name));
+ LogDebug("Evaluating predefined channel modes for \"%s\" ...", name);
+ Req.argv[0] = name;
+ Req.prefix = Client_ID(Client_ThisServer());
+ Req.command = "MODE";
+
+ /* Iterate over channel modes strings */
+ for (n = 0; n < conf_chan->modes_num; n++) {
+ Req.argc = 1;
+ strlcpy(modes, conf_chan->modes[n], sizeof(modes));
+ LogDebug("Evaluate \"MODE %s %s\".", name, modes);
+ c = strtok(modes, " ");
+ while (c && Req.argc < 15) {
+ Req.argv[Req.argc++] = c;
+ c = strtok(0, " ");
+ }
+
+ if (Req.argc > 1) {
+ /* Handling of legacy "Key" and "MaxUsers" settings:
+ * Enforce setting the respective mode(s), to support
+ * the legacy "Mode = kl" notation, which was valid but
+ * is an invalid MODE string: key and limit are missing!
+ * So set them manually when "k" or "l" are detected in
+ * the first MODE parameter ... */
+ if (Req.argc > 1 && strchr(Req.argv[1], 'k')) {
+ Channel_SetKey(new_chan, conf_chan->key);
+ Channel_ModeAdd(new_chan, 'k');
+ }
+ if (strchr(Req.argv[1], 'l')) {
+ Channel_SetMaxUsers(new_chan, conf_chan->maxusers);
+ Channel_ModeAdd(new_chan, 'l');
+ }
+
+ IRC_MODE(Client_ThisServer(), &Req);
+ }
+
+ /* Original channel modes strings are no longer needed */
+ free(conf_chan->modes[n]);
+ }
+ }
- Channel_SetKey(new_chan, conf_chan->key);
- Channel_SetMaxUsers(new_chan, conf_chan->maxusers);
Set_KeyFile(new_chan, conf_chan->keyfile);
+
+ Log(LOG_INFO,
+ "Created pre-defined channel \"%s\", mode \"%s\" (%s, user limit %d).",
+ new_chan->name, new_chan->modes,
+ new_chan->key[0] ? "channel key set" : "no channel key",
+ new_chan->maxusers);
}
- if (channel_count)
- array_free(&Conf_Channels);
+
+ /* Make sure the local &SERVER channel exists */
+ if (!Channel_Search("&SERVER")) {
+ new_chan = Channel_Create("&SERVER");
+ if (new_chan) {
+ Channel_SetModes(new_chan, "mnPt");
+ Channel_SetTopic(new_chan, Client_ThisServer(),
+ "Server Messages");
+ } else
+ Log(LOG_ERR, "Failed to create \"&SERVER\" channel!");
+ } else
+ LogDebug("Required channel \"&SERVER\" already exists, ok.");
} /* Channel_InitPredefined */
array_free(&chan->topic);
array_free(&chan->keyfile);
Lists_Free(&chan->list_bans);
+ Lists_Free(&chan->list_excepts);
Lists_Free(&chan->list_invites);
free(chan);
/* Check that the channel name is valid */
if (! Channel_IsValidName(Name)) {
- IRC_WriteStrClient(Client, ERR_NOSUCHCHANNEL_MSG,
+ IRC_WriteErrClient(Client, ERR_NOSUCHCHANNEL_MSG,
Client_ID(Client), Name);
return false;
}
/* Check that specified channel exists */
chan = Channel_Search(Name);
if (!chan) {
- IRC_WriteStrClient(Client, ERR_NOSUCHCHANNEL_MSG,
+ IRC_WriteErrClient(Client, ERR_NOSUCHCHANNEL_MSG,
Client_ID(Client), Name);
return false;
}
/* Check that the client is in the channel */
if (!Get_Cl2Chan(chan, Client)) {
- IRC_WriteStrClient(Client, ERR_NOTONCHANNEL_MSG,
+ IRC_WriteErrClient(Client, ERR_NOTONCHANNEL_MSG,
Client_ID(Client), Name);
return false;
}
const char *Reason )
{
CHANNEL *chan;
+ bool can_kick = false;
assert(Peer != NULL);
assert(Target != NULL);
/* Check that channel exists */
chan = Channel_Search( Name );
- if( ! chan )
- {
- IRC_WriteStrClient( Origin, ERR_NOSUCHCHANNEL_MSG, Client_ID( Origin ), Name );
+ if (!chan) {
+ IRC_WriteErrClient(Origin, ERR_NOSUCHCHANNEL_MSG,
+ Client_ID(Origin), Name);
return;
}
Client_Type(Origin) != CLIENT_SERVICE) {
/* Check that user is on the specified channel */
if (!Channel_IsMemberOf(chan, Origin)) {
- IRC_WriteStrClient( Origin, ERR_NOTONCHANNEL_MSG,
- Client_ID(Origin), Name);
- return;
- }
-
- /* Check if user has operator status */
- if (!strchr(Channel_UserModes(chan, Origin), 'o')) {
- IRC_WriteStrClient(Origin, ERR_CHANOPRIVSNEEDED_MSG,
+ IRC_WriteErrClient(Origin, ERR_NOTONCHANNEL_MSG,
Client_ID(Origin), Name);
return;
}
/* Check that the client to be kicked is on the specified channel */
if (!Channel_IsMemberOf(chan, Target)) {
- IRC_WriteStrClient(Origin, ERR_USERNOTINCHANNEL_MSG,
+ IRC_WriteErrClient(Origin, ERR_USERNOTINCHANNEL_MSG,
Client_ID(Origin), Client_ID(Target), Name );
return;
}
+ if(Client_Type(Peer) == CLIENT_USER) {
+ /* Channel mode 'Q' and user mode 'q' on target: nobody but
+ * IRC Operators and servers can kick the target user */
+ if ((Channel_HasMode(chan, 'Q')
+ || Client_HasMode(Target, 'q')
+ || Client_Type(Target) == CLIENT_SERVICE)
+ && !Client_HasMode(Origin, 'o')) {
+ IRC_WriteErrClient(Origin, ERR_KICKDENY_MSG,
+ Client_ID(Origin), Name,
+ Client_ID(Target));
+ return;
+ }
+
+ /* Check if client has the rights to kick target */
+
+ /* Owner can kick everyone */
+ if (Channel_UserHasMode(chan, Peer, 'q'))
+ can_kick = true;
+
+ /* Admin can't kick owner */
+ else if (Channel_UserHasMode(chan, Peer, 'a') &&
+ !Channel_UserHasMode(chan, Target, 'q'))
+ can_kick = true;
+
+ /* Op can't kick owner | admin */
+ else if (Channel_UserHasMode(chan, Peer, 'o') &&
+ !Channel_UserHasMode(chan, Target, 'q') &&
+ !Channel_UserHasMode(chan, Target, 'a'))
+ can_kick = true;
+
+ /* Half Op can't kick owner | admin | op */
+ else if (Channel_UserHasMode(chan, Peer, 'h') &&
+ !Channel_UserHasMode(chan, Target, 'q') &&
+ !Channel_UserHasMode(chan, Target, 'a') &&
+ !Channel_UserHasMode(chan, Target, 'o'))
+ can_kick = true;
+
+ /* IRC operators & IRCd with OperCanMode enabled
+ * can kick anyways regardless of privilege */
+ else if(Client_HasMode(Origin, 'o') && Conf_OperCanMode)
+ can_kick = true;
+
+ if(!can_kick) {
+ IRC_WriteErrClient(Origin, ERR_CHANOPPRIVTOOLOW_MSG,
+ Client_ID(Origin), Name);
+ return;
+ }
+ }
+
/* Kick Client from channel */
Remove_Client( REMOVE_KICK, chan, Target, Origin, Reason, true);
} /* Channel_Kick */
} /* Channel_Quit */
+/**
+ * Get number of channels this server knows and that are "visible" to
+ * the given client. If no client is given, all channels will be counted.
+ *
+ * @param Client The client to check or NULL.
+ * @return Number of channels visible to the client.
+ */
GLOBAL unsigned long
-Channel_Count( void )
+Channel_CountVisible (CLIENT *Client)
{
CHANNEL *c;
unsigned long count = 0;
c = My_Channels;
- while( c )
- {
- count++;
+ while(c) {
+ if (Client) {
+ if (!Channel_HasMode(c, 's')
+ || Channel_IsMemberOf(c, Client))
+ count++;
+ } else
+ count++;
c = c->next;
}
return count;
-} /* Channel_Count */
+}
GLOBAL unsigned long
} /* Channel_Modes */
+GLOBAL bool
+Channel_HasMode( CHANNEL *Chan, char Mode )
+{
+ assert( Chan != NULL );
+ return strchr( Chan->modes, Mode ) != NULL;
+} /* Channel_HasMode */
+
+
GLOBAL char *
Channel_Key( CHANNEL *Chan )
{
assert( Chan != NULL );
x[0] = Mode; x[1] = '\0';
- if( ! strchr( Chan->modes, x[0] ))
+ if( ! Channel_HasMode( Chan, x[0] ))
{
/* Channel does not have this mode yet, set it */
strlcat( Chan->modes, x, sizeof( Chan->modes ));
} /* Channel_UserModes */
+/**
+ * Test if a user has a given channel user mode.
+ *
+ * @param Chan The channel to check.
+ * @param Client The client to check.
+ * @param Mode The channel user mode to test for.
+ * @return true if the user has the given channel user mode set.
+ */
+GLOBAL bool
+Channel_UserHasMode( CHANNEL *Chan, CLIENT *Client, char Mode )
+{
+ char *channel_user_modes;
+
+ assert(Chan != NULL);
+ assert(Client != NULL);
+ assert(Mode > 0);
+
+ channel_user_modes = Channel_UserModes(Chan, Client);
+ if (!channel_user_modes || !*channel_user_modes)
+ return false;
+
+ return strchr(channel_user_modes, Mode) != NULL;
+} /* Channel_UserHasMode */
+
+
GLOBAL bool
Channel_IsMemberOf( CHANNEL *Chan, CLIENT *Client )
{
} /* Channel_SetMaxUsers */
+/**
+ * Check if a client is allowed to send to a specific channel.
+ *
+ * @param Chan The channel to check.
+ * @param From The client that wants to send.
+ * @return true if the client is allowed to send, false otherwise.
+ */
static bool
Can_Send_To_Channel(CHANNEL *Chan, CLIENT *From)
{
- bool is_member, has_voice, is_op;
+ bool is_member, has_voice, is_halfop, is_op, is_chanadmin, is_owner;
- is_member = has_voice = is_op = false;
+ is_member = has_voice = is_halfop = is_op = is_chanadmin = is_owner = false;
/* The server itself always can send messages :-) */
if (Client_ThisServer() == From)
if (Channel_IsMemberOf(Chan, From)) {
is_member = true;
- if (strchr(Channel_UserModes(Chan, From), 'v'))
+ if (Channel_UserHasMode(Chan, From, 'v'))
has_voice = true;
- if (strchr(Channel_UserModes(Chan, From), 'o'))
+ if (Channel_UserHasMode(Chan, From, 'h'))
+ is_halfop = true;
+ if (Channel_UserHasMode(Chan, From, 'o'))
is_op = true;
+ if (Channel_UserHasMode(Chan, From, 'a'))
+ is_chanadmin = true;
+ if (Channel_UserHasMode(Chan, From, 'q'))
+ is_owner = true;
}
/*
* If channel mode n set: non-members cannot send to channel.
* If channel mode m set: need voice.
*/
- if (strchr(Channel_Modes(Chan), 'n') && !is_member)
+ if (Channel_HasMode(Chan, 'n') && !is_member)
+ return false;
+
+ if (Channel_HasMode(Chan, 'M') && !Client_HasMode(From, 'R')
+ && !Client_HasMode(From, 'o'))
return false;
- if (is_op || has_voice)
+ if (has_voice || is_halfop || is_op || is_chanadmin || is_owner)
return true;
- if (strchr(Channel_Modes(Chan), 'm'))
+ if (Channel_HasMode(Chan, 'm'))
return false;
+ if (Lists_Check(&Chan->list_excepts, From))
+ return true;
+
return !Lists_Check(&Chan->list_bans, From);
}
if (!Can_Send_To_Channel(Chan, From)) {
if (! SendErrors)
return CONNECTED; /* no error, see RFC 2812 */
- return IRC_WriteStrClient(From, ERR_CANNOTSENDTOCHAN_MSG,
+ if (Channel_HasMode(Chan, 'M'))
+ return IRC_WriteErrClient(From, ERR_NEEDREGGEDNICK_MSG,
+ Client_ID(From), Channel_Name(Chan));
+ else
+ return IRC_WriteErrClient(From, ERR_CANNOTSENDTOCHAN_MSG,
Client_ID(From), Channel_Name(Chan));
}
if (Client_Conn(From) > NONE)
Conn_UpdateIdle(Client_Conn(From));
- return IRC_WriteStrChannelPrefix(Client, Chan, From, true,
- "%s %s :%s", Command, Channel_Name(Chan), Text);
+ IRC_WriteStrChannelPrefix(Client, Chan, From, true, "%s %s :%s",
+ Command, Channel_Name(Chan), Text);
+ return CONNECTED;
}
switch( Type )
{
case REMOVE_QUIT:
- /* QUIT: other servers have already been notified,
+ /* QUIT: other servers have already been notified,
* see Client_Destroy(); so only inform other clients
* in same channel. */
assert( InformServer == false );
}
/* When channel is empty and is not pre-defined, delete */
- if( ! strchr( Channel_Modes( Chan ), 'P' ))
+ if( ! Channel_HasMode( Chan, 'P' ))
{
if( ! Get_First_Cl2Chan( NULL, Chan )) Delete_Channel( Chan );
}
GLOBAL bool
-Channel_AddBan(CHANNEL *c, const char *mask )
+Channel_AddBan(CHANNEL *c, const char *mask, const char *who )
{
struct list_head *h = Channel_GetListBans(c);
- LogDebug("Adding \"%s\" to \"%s\" %s list", mask, Channel_Name(c), "ban");
- return Lists_Add(h, mask, false);
+ LogDebug("Adding \"%s\" to \"%s\" ban list", mask, Channel_Name(c));
+ return Lists_Add(h, mask, time(NULL), who, false);
}
GLOBAL bool
-Channel_AddInvite(CHANNEL *c, const char *mask, bool onlyonce)
+Channel_AddExcept(CHANNEL *c, const char *mask, const char *who )
+{
+ struct list_head *h = Channel_GetListExcepts(c);
+ LogDebug("Adding \"%s\" to \"%s\" exception list", mask, Channel_Name(c));
+ return Lists_Add(h, mask, time(NULL), who, false);
+}
+
+
+GLOBAL bool
+Channel_AddInvite(CHANNEL *c, const char *mask, bool onlyonce, const char *who )
{
struct list_head *h = Channel_GetListInvites(c);
- LogDebug("Adding \"%s\" to \"%s\" %s list", mask, Channel_Name(c), "invite");
- return Lists_Add(h, mask, onlyonce);
+ LogDebug("Adding \"%s\" to \"%s\" invite list", mask, Channel_Name(c));
+ return Lists_Add(h, mask, time(NULL), who, onlyonce);
}
static bool
-ShowInvitesBans(struct list_head *head, CLIENT *Client, CHANNEL *Channel, bool invite)
+ShowChannelList(struct list_head *head, CLIENT *Client, CHANNEL *Channel,
+ char *msg, char *msg_end)
{
struct list_elem *e;
- char *msg = invite ? RPL_INVITELIST_MSG : RPL_BANLIST_MSG;
- char *msg_end;
- assert( Client != NULL );
- assert( Channel != NULL );
+ assert (Client != NULL);
+ assert (Channel != NULL);
e = Lists_GetFirst(head);
while (e) {
- if( ! IRC_WriteStrClient( Client, msg, Client_ID( Client ),
- Channel_Name( Channel ), Lists_GetMask(e) )) return DISCONNECTED;
+ if (!IRC_WriteStrClient(Client, msg, Client_ID(Client),
+ Channel_Name(Channel),
+ Lists_GetMask(e),
+ Lists_GetReason(e),
+ Lists_GetValidity(e)))
+ return DISCONNECTED;
e = Lists_GetNext(e);
}
- msg_end = invite ? RPL_ENDOFINVITELIST_MSG : RPL_ENDOFBANLIST_MSG;
- return IRC_WriteStrClient( Client, msg_end, Client_ID( Client ), Channel_Name( Channel ));
+ return IRC_WriteStrClient(Client, msg_end, Client_ID(Client),
+ Channel_Name(Channel));
}
assert( Channel != NULL );
h = Channel_GetListBans(Channel);
- return ShowInvitesBans(h, Client, Channel, false);
+ return ShowChannelList(h, Client, Channel, RPL_BANLIST_MSG,
+ RPL_ENDOFBANLIST_MSG);
+}
+
+
+GLOBAL bool
+Channel_ShowExcepts( CLIENT *Client, CHANNEL *Channel )
+{
+ struct list_head *h;
+
+ assert( Channel != NULL );
+
+ h = Channel_GetListExcepts(Channel);
+ return ShowChannelList(h, Client, Channel, RPL_EXCEPTLIST_MSG,
+ RPL_ENDOFEXCEPTLIST_MSG);
}
assert( Channel != NULL );
h = Channel_GetListInvites(Channel);
- return ShowInvitesBans(h, Client, Channel, true);
+ return ShowChannelList(h, Client, Channel, RPL_INVITELIST_MSG,
+ RPL_ENDOFINVITELIST_MSG);
}
assert(Client != NULL);
assert(Key != NULL);
- if (!strchr(Chan->modes, 'k'))
+ if (!Channel_HasMode(Chan, 'k'))
return true;
if (*Key == '\0')
return false;
} /* Channel_CheckKey */
-/**
- * Check wether a client is allowed to administer a channel or not.
- *
- * @param Chan The channel to test.
- * @param Client The client from which the command has been received.
- * @param Origin The originator of the command (or NULL).
- * @param OnChannel Set to true if the originator is member of the channel.
- * @param AdminOk Set to true if the client is allowed to do
- * administrative tasks on this channel.
- * @param UseServerMode Set to true if ngIRCd should emulate "server mode",
- * that is send commands as if originating from a server
- * and not the originator of the command.
- */
-GLOBAL void
-Channel_CheckAdminRights(CHANNEL *Chan, CLIENT *Client, CLIENT *Origin,
- bool *OnChannel, bool *AdminOk, bool *UseServerMode)
-{
- assert (Chan != NULL);
- assert (Client != NULL);
- assert (OnChannel != NULL);
- assert (AdminOk != NULL);
- assert (UseServerMode != NULL);
-
- /* Use the client as origin, if no origin has been given (no prefix?) */
- if (!Origin)
- Origin = Client;
-
- *OnChannel = false;
- *AdminOk = false;
- *UseServerMode = false;
-
- if (Client_Type(Client) != CLIENT_USER
- && Client_Type(Client) != CLIENT_SERVER
- && Client_Type(Client) != CLIENT_SERVICE)
- return;
-
- /* Allow channel administration if the client is a server or service */
- if (Client_Type(Client) != CLIENT_USER) {
- *AdminOk = true;
- return;
- }
-
- *OnChannel = Channel_IsMemberOf(Chan, Origin);
-
- if (*OnChannel && strchr(Channel_UserModes(Chan, Origin), 'o')) {
- /* User is a channel operator */
- *AdminOk = true;
- } else if (Conf_OperCanMode) {
- /* IRC operators are allowed to administer channels as well */
- if (Client_OperByMe(Origin)) {
- *AdminOk = true;
- if (Conf_OperServerMode)
- *UseServerMode = true;
- }
- }
-} /* Channel_CheckAdminRights */
-
-
static CL2CHAN *
Get_First_Cl2Chan( CLIENT *Client, CHANNEL *Chan )
{