MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-03 12:28:52 +01:00
Code Issues Releases Wiki Activity
construct/ircd/channel.cc

1328 lines
34 KiB
C++
Raw Blame History

/*
* ircd-ratbox: A slightly useful ircd.
* channel.c: Controls channels.
*
* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
* Copyright (C) 1996-2002 Hybrid Development Team
* Copyright (C) 2002-2005 ircd-ratbox development team
*
* 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
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
using namespace ircd;
int h_can_join;
int h_can_send;
int h_get_channel_access;
struct config_channel_entry ircd::ConfigChannel;
rb_dlink_list chan::global_channel_list;
//std::map<std::string, std::unique_ptr<chan::chan>> chan::chans;
void
chan::init()
{
h_can_join = register_hook("can_join");
h_can_send = register_hook("can_send");
h_get_channel_access = register_hook("get_channel_access");
}
chan::chan::chan(const std::string &name)
:name{name}
,mode{}
,mode_lock{}
,topic{}
,members{0}
,locmembers{0}
,invites{0}
,banlist{0}
,exceptlist{0}
,invexlist{0}
,quietlist{0}
,join_count{0}
,join_delta{0}
,flood_noticed{0}
,received_number_of_privmsgs{0}
,first_received_message_time{0}
,last_knock{0}
,bants{0}
,channelts{0}
,last_checked_ts{0}
,last_checked_client{nullptr}
,last_checked_type{0}
,last_checked_result{0}
{
}
chan::chan::~chan()
noexcept
{
rb_dlink_node *ptr, *next_ptr;
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, invites.head)
del_invite(this, reinterpret_cast<client *>(ptr->data));
/* free all bans/exceptions/denies */
free_channel_list(&banlist);
free_channel_list(&exceptlist);
free_channel_list(&invexlist);
free_channel_list(&quietlist);
rb_dlinkDelete(&node, &global_channel_list);
del_from_channel_hash(name.c_str(), this);
}
chan::membership::membership()
:channode{0}
,locchannode{0}
,usernode{0}
,chan{nullptr}
,client{nullptr}
,flags{0}
,bants{0}
{
}
chan::membership::~membership()
noexcept
{
}
chan::modes::modes()
:mode{0}
,limit{0}
,key{0}
,join_num{0}
,join_time{0}
,forward{0}
{
}
chan::ban::ban(const std::string &banstr,
const std::string &who,
const std::string &forward)
:banstr{banstr}
,who{who}
,forward{forward}
,when{0}
{
}
void
chan::send_join(chan &chan,
Client &client)
{
if (!IsClient(&client))
return;
sendto_channel_local_with_capability(ALL_MEMBERS, NOCAPS, CLICAP_EXTENDED_JOIN, &chan,
":%s!%s@%s JOIN %s",
client.name,
client.username,
client.host,
chan.name.c_str());
sendto_channel_local_with_capability(ALL_MEMBERS, CLICAP_EXTENDED_JOIN, NOCAPS, &chan,
":%s!%s@%s JOIN %s %s :%s",
client.name,
client.username,
client.host,
chan.name.c_str(),
EmptyString(client.user->suser)? "*" : client.user->suser,
client.info);
// Send away message to away-notify enabled clients.
if (client.user->away)
sendto_channel_local_with_capability_butone(&client, ALL_MEMBERS, CLICAP_AWAY_NOTIFY, NOCAPS, &chan,
":%s!%s@%s AWAY :%s",
client.name,
client.username,
client.host,
client.user->away);
}
/* find_channel_membership()
*
* input - channel to find them in, client to find
* output - membership of client in channel, else NULL
* side effects -
*/
chan::membership *
chan::find_channel_membership(chan *chptr, client *client_p)
{
struct membership *msptr;
rb_dlink_node *ptr;
if(!IsClient(client_p))
return NULL;
/* Pick the most efficient list to use to be nice to things like
* CHANSERV which could be in a large number of channels
*/
if(rb_dlink_list_length(&chptr->members) < rb_dlink_list_length(&client_p->user->channel))
{
RB_DLINK_FOREACH(ptr, chptr->members.head)
{
msptr = (membership *)ptr->data;
if(msptr->client == client_p)
return msptr;
}
}
else
{
RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
{
msptr = (membership *)ptr->data;
if(msptr->chan == chptr)
return msptr;
}
}
return NULL;
}
/* find_channel_status()
*
* input - membership to get status for, whether we can combine flags
* output - flags of user on channel
* side effects -
*/
const char *
chan::find_status(const membership *const &msptr,
const int &combine)
{
static char buffer[3];
char *p;
p = buffer;
if(is_chanop(msptr))
{
if(!combine)
return "@";
*p++ = '@';
}
if(is_voiced(msptr))
*p++ = '+';
*p = '\0';
return buffer;
}
/* add_user_to_channel()
*
* input - channel to add client to, client to add, channel flags
* output -
* side effects - user is added to channel
*/
void
chan::add_user_to_channel(chan *chptr, client *client_p, int flags)
{
membership *msptr;
s_assert(client_p->user != NULL);
if(client_p->user == NULL)
return;
msptr = new membership;
msptr->chan = chptr;
msptr->client = client_p;
msptr->flags = flags;
rb_dlinkAdd(msptr, &msptr->usernode, &client_p->user->channel);
rb_dlinkAdd(msptr, &msptr->channode, &chptr->members);
if(MyClient(client_p))
rb_dlinkAdd(msptr, &msptr->locchannode, &chptr->locmembers);
}
/* remove_user_from_channel()
*
* input - membership pointer to remove from channel
* output -
* side effects - membership (thus user) is removed from channel
*/
void
chan::remove_user_from_channel(membership *msptr)
{
client *client_p;
chan *chptr;
s_assert(msptr != NULL);
if(msptr == NULL)
return;
client_p = msptr->client;
chptr = msptr->chan;
rb_dlinkDelete(&msptr->usernode, &client_p->user->channel);
rb_dlinkDelete(&msptr->channode, &chptr->members);
if(client_p->servptr == &me)
rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
if(!(chptr->mode.mode & mode::PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
delete chptr;
delete msptr;
return;
}
/* remove_user_from_channels()
*
* input - user to remove from all channels
* output -
* side effects - user is removed from all channels
*/
void
chan::remove_user_from_channels(client *client_p)
{
chan *chptr;
membership *msptr;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
if(client_p == NULL)
return;
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->user->channel.head)
{
msptr = (membership *)ptr->data;
chptr = msptr->chan;
rb_dlinkDelete(&msptr->channode, &chptr->members);
if(client_p->servptr == &me)
rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
if(!(chptr->mode.mode & mode::PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
delete chptr;
delete msptr;
}
client_p->user->channel.head = client_p->user->channel.tail = NULL;
client_p->user->channel.length = 0;
}
/* invalidate_bancache_user()
*
* input - user to invalidate ban cache for
* output -
* side effects - ban cache is invalidated for all memberships of that user
* to be used after a nick change
*/
void
chan::invalidate_bancache_user(client *client_p)
{
membership *msptr;
rb_dlink_node *ptr;
if(client_p == NULL)
return;
RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
{
msptr = (membership *)ptr->data;
msptr->bants = 0;
msptr->flags &= ~BANNED;
}
}
/* check_channel_name()
*
* input - channel name
* output - true if valid channel name, else false
* side effects -
*/
bool
chan::check_channel_name(const char *name)
{
s_assert(name != NULL);
if(name == NULL)
return false;
for (; *name; ++name)
{
if(!rfc1459::is_chan(*name))
return false;
}
return true;
}
/* free_channel_list()
*
* input - rb_dlink list to free
* output -
* side effects - list of b/e/I modes is cleared
*/
void
chan::free_channel_list(rb_dlink_list * list)
{
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
{
const auto actualBan(reinterpret_cast<ban *>(ptr->data));
delete actualBan;
}
list->head = list->tail = NULL;
list->length = 0;
}
/* channel_pub_or_secret()
*
* input - channel
* output - "=" if public, "@" if secret, else "*"
* side effects -
*/
static const char *
channel_pub_or_secret(chan::chan *const &chptr)
{
return chan::pub(chptr)? "=":
chan::secret(chptr)? "@":
"*";
}
/* channel_member_names()
*
* input - channel to list, client to list to, show endofnames
* output -
* side effects - client is given list of users on channel
*/
void
chan::channel_member_names(chan *chptr, client *client_p, int show_eon)
{
membership *msptr;
client *target_p;
rb_dlink_node *ptr;
char lbuf[BUFSIZE];
char *t;
int mlen;
int tlen;
int cur_len;
int stack = IsCapable(client_p, CLICAP_MULTI_PREFIX);
if(can_show(chptr, client_p))
{
cur_len = mlen = sprintf(lbuf, form_str(RPL_NAMREPLY),
me.name, client_p->name,
channel_pub_or_secret(chptr), chptr->name.c_str());
t = lbuf + cur_len;
RB_DLINK_FOREACH(ptr, chptr->members.head)
{
msptr = (membership *)ptr->data;
target_p = msptr->client;
if(IsInvisible(target_p) && !is_member(chptr, client_p))
continue;
if (IsCapable(client_p, CLICAP_USERHOST_IN_NAMES))
{
/* space, possible "@+" prefix */
if (cur_len + strlen(target_p->name) + strlen(target_p->username) + strlen(target_p->host) + 5 >= BUFSIZE - 5)
{
*(t - 1) = '\0';
sendto_one(client_p, "%s", lbuf);
cur_len = mlen;
t = lbuf + mlen;
}
tlen = sprintf(t, "%s%s!%s@%s ", find_status(msptr, stack),
target_p->name, target_p->username, target_p->host);
}
else
{
/* space, possible "@+" prefix */
if(cur_len + strlen(target_p->name) + 3 >= BUFSIZE - 3)
{
*(t - 1) = '\0';
sendto_one(client_p, "%s", lbuf);
cur_len = mlen;
t = lbuf + mlen;
}
tlen = sprintf(t, "%s%s ", find_status(msptr, stack),
target_p->name);
}
cur_len += tlen;
t += tlen;
}
/* The old behaviour here was to always output our buffer,
* even if there are no clients we can show. This happens
* when a client does "NAMES" with no parameters, and all
* the clients on a -sp channel are +i. I dont see a good
* reason for keeping that behaviour, as it just wastes
* bandwidth. --anfl
*/
if(cur_len != mlen)
{
*(t - 1) = '\0';
sendto_one(client_p, "%s", lbuf);
}
}
if(show_eon)
sendto_one(client_p, form_str(RPL_ENDOFNAMES),
me.name, client_p->name, chptr->name.c_str());
}
/* del_invite()
*
* input - channel to remove invite from, client to remove
* output -
* side effects - user is removed from invite list, if exists
*/
void
chan::del_invite(chan *chptr, client *who)
{
rb_dlinkFindDestroy(who, &chptr->invites);
rb_dlinkFindDestroy(chptr, &who->user->invited);
}
/* is_banned_list()
*
* input - channel to check bans for, ban list (banlist or quietlist),
* user to check bans against, optional prebuilt buffers,
* optional forward channel pointer
* output - 1 if banned, else 0
* side effects -
*/
static int
is_banned_list(chan::chan *chptr, rb_dlink_list *list,
Client *who, chan::membership *msptr,
const char *s, const char *s2, const char **forward)
{
using namespace chan;
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
char src_ip4host[NICKLEN + USERLEN + HOSTLEN + 6];
char *s3 = NULL;
char *s4 = NULL;
struct sockaddr_in ip4;
rb_dlink_node *ptr;
ban *actualBan = NULL;
ban *actualExcept = NULL;
if(!MyClient(who))
return 0;
/* if the buffers havent been built, do it here */
if(s == NULL)
{
sprintf(src_host, "%s!%s@%s", who->name, who->username, who->host);
sprintf(src_iphost, "%s!%s@%s", who->name, who->username, who->sockhost);
s = src_host;
s2 = src_iphost;
}
if(who->localClient->mangledhost != NULL)
{
/* if host mangling mode enabled, also check their real host */
if(!strcmp(who->host, who->localClient->mangledhost))
{
sprintf(src_althost, "%s!%s@%s", who->name, who->username, who->orighost);
s3 = src_althost;
}
/* if host mangling mode not enabled and no other spoof,
* also check the mangled form of their host */
else if (!IsDynSpoof(who))
{
sprintf(src_althost, "%s!%s@%s", who->name, who->username, who->localClient->mangledhost);
s3 = src_althost;
}
}
#ifdef RB_IPV6
if(GET_SS_FAMILY(&who->localClient->ip) == AF_INET6 &&
rb_ipv4_from_ipv6((const struct sockaddr_in6 *)&who->localClient->ip, &ip4))
{
sprintf(src_ip4host, "%s!%s@", who->name, who->username);
s4 = src_ip4host + strlen(src_ip4host);
rb_inet_ntop_sock((struct sockaddr *)&ip4,
s4, src_ip4host + sizeof src_ip4host - s4);
s4 = src_ip4host;
}
#endif
RB_DLINK_FOREACH(ptr, list->head)
{
actualBan = (ban *)ptr->data;
if(match(actualBan->banstr.c_str(), s) ||
match(actualBan->banstr.c_str(), s2) ||
match_cidr(actualBan->banstr.c_str(), s2) ||
match_extban(actualBan->banstr.c_str(), who, chptr, mode::BAN) ||
(s3 != NULL && match(actualBan->banstr.c_str(), s3))
#ifdef RB_IPV6
||
(s4 != NULL && (match(actualBan->banstr.c_str(), s4) || match_cidr(actualBan->banstr.c_str(), s4)))
#endif
)
break;
else
actualBan = NULL;
}
if((actualBan != NULL) && ircd::ConfigChannel.use_except)
{
RB_DLINK_FOREACH(ptr, chptr->exceptlist.head)
{
actualExcept = (ban *)ptr->data;
/* theyre exempted.. */
if(match(actualExcept->banstr.c_str(), s) ||
match(actualExcept->banstr.c_str(), s2) ||
match_cidr(actualExcept->banstr.c_str(), s2) ||
match_extban(actualExcept->banstr.c_str(), who, chptr, mode::EXCEPTION) ||
(s3 != NULL && match(actualExcept->banstr.c_str(), s3)))
{
/* cache the fact theyre not banned */
if(msptr != NULL)
{
msptr->bants = chptr->bants;
msptr->flags &= ~BANNED;
}
return mode::EXCEPTION;
}
}
}
/* cache the banned/not banned status */
if(msptr != NULL)
{
msptr->bants = chptr->bants;
if(actualBan != NULL)
{
msptr->flags |= BANNED;
return mode::BAN;
}
else
{
msptr->flags &= ~BANNED;
return 0;
}
}
if (actualBan && !actualBan->forward.empty() && forward)
*forward = actualBan->forward.c_str(); //TODO: XXX: ???
return actualBan? mode::BAN : mode::type(0);
}
/* is_banned()
*
* input - channel to check bans for, user to check bans against
* optional prebuilt buffers, optional forward channel pointer
* output - 1 if banned, else 0
* side effects -
*/
int
chan::is_banned(chan *chptr, client *who, membership *msptr,
const char *s, const char *s2, const char **forward)
{
if (chptr->last_checked_client != NULL &&
who == chptr->last_checked_client &&
chptr->last_checked_type == mode::BAN &&
chptr->last_checked_ts > chptr->bants)
return chptr->last_checked_result;
chptr->last_checked_client = who;
chptr->last_checked_type = mode::BAN;
chptr->last_checked_result = is_banned_list(chptr, &chptr->banlist, who, msptr, s, s2, forward);
chptr->last_checked_ts = rb_current_time();
return chptr->last_checked_result;
}
/* is_quieted()
*
* input - channel to check bans for, user to check bans against
* optional prebuilt buffers
* output - 1 if banned, else 0
* side effects -
*/
int
chan::is_quieted(chan *chptr, client *who, membership *msptr,
const char *s, const char *s2)
{
if (chptr->last_checked_client != NULL &&
who == chptr->last_checked_client &&
chptr->last_checked_type == mode::QUIET &&
chptr->last_checked_ts > chptr->bants)
return chptr->last_checked_result;
chptr->last_checked_client = who;
chptr->last_checked_type = mode::QUIET;
chptr->last_checked_result = is_banned_list(chptr, &chptr->quietlist, who, msptr, s, s2, NULL);
chptr->last_checked_ts = rb_current_time();
return chptr->last_checked_result;
}
/* can_join()
*
* input - client to check, channel to check for, key
* output - reason for not being able to join, else 0, channel name to forward to
* side effects -
* caveats - this function should only be called on a local user.
*/
int
chan::can_join(client *source_p, chan *chptr, const char *key, const char **forward)
{
rb_dlink_node *invite = NULL;
rb_dlink_node *ptr;
ban *invex = NULL;
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
int use_althost = 0;
int i = 0;
hook_data_channel moduledata;
s_assert(source_p->localClient != NULL);
moduledata.client = source_p;
moduledata.chptr = chptr;
moduledata.approved = 0;
sprintf(src_host, "%s!%s@%s", source_p->name, source_p->username, source_p->host);
sprintf(src_iphost, "%s!%s@%s", source_p->name, source_p->username, source_p->sockhost);
if(source_p->localClient->mangledhost != NULL)
{
/* if host mangling mode enabled, also check their real host */
if(!strcmp(source_p->host, source_p->localClient->mangledhost))
{
sprintf(src_althost, "%s!%s@%s", source_p->name, source_p->username, source_p->orighost);
use_althost = 1;
}
/* if host mangling mode not enabled and no other spoof,
* also check the mangled form of their host */
else if (!IsDynSpoof(source_p))
{
sprintf(src_althost, "%s!%s@%s", source_p->name, source_p->username, source_p->localClient->mangledhost);
use_althost = 1;
}
}
if((is_banned(chptr, source_p, NULL, src_host, src_iphost, forward)) == mode::BAN)
{
moduledata.approved = ERR_BANNEDFROMCHAN;
goto finish_join_check;
}
if(*chptr->mode.key && (EmptyString(key) || irccmp(chptr->mode.key, key)))
{
moduledata.approved = ERR_BADCHANNELKEY;
goto finish_join_check;
}
/* All checks from this point on will forward... */
if(forward)
*forward = chptr->mode.forward;
if(chptr->mode.mode & mode::INVITEONLY)
{
RB_DLINK_FOREACH(invite, source_p->user->invited.head)
{
if(invite->data == chptr)
break;
}
if(invite == NULL)
{
if(!ConfigChannel.use_invex)
moduledata.approved = ERR_INVITEONLYCHAN;
RB_DLINK_FOREACH(ptr, chptr->invexlist.head)
{
invex = (ban *)ptr->data;
if(match(invex->banstr.c_str(), src_host)
|| match(invex->banstr.c_str(), src_iphost)
|| match_cidr(invex->banstr.c_str(), src_iphost)
|| match_extban(invex->banstr.c_str(), source_p, chptr, mode::INVEX)
|| (use_althost && match(invex->banstr.c_str(), src_althost)))
break;
}
if(ptr == NULL)
moduledata.approved = ERR_INVITEONLYCHAN;
}
}
if(chptr->mode.limit &&
rb_dlink_list_length(&chptr->members) >= (unsigned long) chptr->mode.limit)
i = ERR_CHANNELISFULL;
if(chptr->mode.mode & mode::REGONLY && EmptyString(source_p->user->suser))
i = ERR_NEEDREGGEDNICK;
/* join throttling stuff --nenolod */
else if(chptr->mode.join_num > 0 && chptr->mode.join_time > 0)
{
if ((rb_current_time() - chptr->join_delta <=
chptr->mode.join_time) && (chptr->join_count >=
chptr->mode.join_num))
i = ERR_THROTTLE;
}
/* allow /invite to override +l/+r/+j also -- jilles */
if (i != 0 && invite == NULL)
{
RB_DLINK_FOREACH(invite, source_p->user->invited.head)
{
if(invite->data == chptr)
break;
}
if (invite == NULL)
moduledata.approved = i;
}
finish_join_check:
call_hook(h_can_join, &moduledata);
return moduledata.approved;
}
/* can_send()
*
* input - user to check in channel, membership pointer
* output - whether can explicitly send or not, else CAN_SEND_NONOP
* side effects -
*/
int
chan::can_send(chan *chptr, client *source_p, membership *msptr)
{
hook_data_channel_approval moduledata;
moduledata.approved = CAN_SEND_NONOP;
moduledata.dir = MODE_QUERY;
if(IsServer(source_p) || IsService(source_p))
return CAN_SEND_OPV;
if(MyClient(source_p) && hash_find_resv(chptr->name.c_str()) &&
!IsOper(source_p) && !IsExemptResv(source_p))
moduledata.approved = CAN_SEND_NO;
if(msptr == NULL)
{
msptr = find_channel_membership(chptr, source_p);
if(msptr == NULL)
{
/* if its +m or +n and theyre not in the channel,
* they cant send. we dont check bans here because
* theres no possibility of caching them --fl
*/
if(chptr->mode.mode & mode::NOPRIVMSGS || chptr->mode.mode & mode::MODERATED)
moduledata.approved = CAN_SEND_NO;
else
moduledata.approved = CAN_SEND_NONOP;
return moduledata.approved;
}
}
if(chptr->mode.mode & mode::MODERATED)
moduledata.approved = CAN_SEND_NO;
if(MyClient(source_p))
{
/* cached can_send */
if(msptr->bants == chptr->bants)
{
if(can_send_banned(msptr))
moduledata.approved = CAN_SEND_NO;
}
else if(is_banned(chptr, source_p, msptr, NULL, NULL, NULL) == mode::BAN
|| is_quieted(chptr, source_p, msptr, NULL, NULL) == mode::BAN)
moduledata.approved = CAN_SEND_NO;
}
if(is_chanop_voiced(msptr))
moduledata.approved = CAN_SEND_OPV;
moduledata.client = source_p;
moduledata.chptr = msptr->chan;
moduledata.msptr = msptr;
moduledata.target = NULL;
moduledata.dir = moduledata.approved == CAN_SEND_NO? MODE_ADD : MODE_QUERY;
call_hook(h_can_send, &moduledata);
return moduledata.approved;
}
/*
* flood_attack_channel
* inputs - flag 0 if PRIVMSG 1 if NOTICE. RFC
* says NOTICE must not auto reply
* - pointer to source Client
* - pointer to target channel
* output - true if target is under flood attack
* side effects - check for flood attack on target chptr
*/
bool
chan::flood_attack_channel(int p_or_n, client *source_p, chan *chptr)
{
int delta;
if(GlobalSetOptions.floodcount && MyClient(source_p))
{
if((chptr->first_received_message_time + 1) < rb_current_time())
{
delta = rb_current_time() - chptr->first_received_message_time;
chptr->received_number_of_privmsgs -= delta;
chptr->first_received_message_time = rb_current_time();
if(chptr->received_number_of_privmsgs <= 0)
{
chptr->received_number_of_privmsgs = 0;
chptr->flood_noticed = 0;
}
}
if((chptr->received_number_of_privmsgs >= GlobalSetOptions.floodcount)
|| chptr->flood_noticed)
{
if(chptr->flood_noticed == 0)
{
sendto_realops_snomask(SNO_BOTS, chptr->name[0] == '&' ? L_ALL : L_NETWIDE,
"Possible Flooder %s[%s@%s] on %s target: %s",
source_p->name, source_p->username,
source_p->orighost,
source_p->servptr->name, chptr->name.c_str());
chptr->flood_noticed = 1;
/* Add a bit of penalty */
chptr->received_number_of_privmsgs += 2;
}
if(MyClient(source_p) && (p_or_n != 1))
sendto_one(source_p,
":%s NOTICE %s :*** Message to %s throttled due to flooding",
me.name, source_p->name, chptr->name.c_str());
return true;
}
else
chptr->received_number_of_privmsgs++;
}
return false;
}
/* find_bannickchange_channel()
* Input: client to check
* Output: channel preventing nick change
*/
chan::chan *
chan::find_bannickchange_channel(client *client_p)
{
chan *chptr;
membership *msptr;
rb_dlink_node *ptr;
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
if (!MyClient(client_p))
return NULL;
sprintf(src_host, "%s!%s@%s", client_p->name, client_p->username, client_p->host);
sprintf(src_iphost, "%s!%s@%s", client_p->name, client_p->username, client_p->sockhost);
RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
{
msptr = (membership *)ptr->data;
chptr = msptr->chan;
if (is_chanop_voiced(msptr))
continue;
/* cached can_send */
if (msptr->bants == chptr->bants)
{
if (can_send_banned(msptr))
return chptr;
}
else if (is_banned(chptr, client_p, msptr, src_host, src_iphost, NULL) == mode::BAN
|| is_quieted(chptr, client_p, msptr, src_host, src_iphost) == mode::BAN)
return chptr;
}
return NULL;
}
/* void check_spambot_warning(client *source_p)
* Input: Client to check, channel name or NULL if this is a part.
* Output: none
* Side-effects: Updates the client's oper_warn_count_down, warns the
* IRC operators if necessary, and updates join_leave_countdown as
* needed.
*/
void
chan::check_spambot_warning(client *source_p, const char *name)
{
int t_delta;
int decrement_count;
if((GlobalSetOptions.spam_num &&
(source_p->localClient->join_leave_count >= GlobalSetOptions.spam_num)))
{
if(source_p->localClient->oper_warn_count_down > 0)
source_p->localClient->oper_warn_count_down--;
else
source_p->localClient->oper_warn_count_down = 0;
if(source_p->localClient->oper_warn_count_down == 0 &&
name != NULL)
{
/* Its already known as a possible spambot */
sendto_realops_snomask(SNO_BOTS, L_NETWIDE,
"User %s (%s@%s) trying to join %s is a possible spambot",
source_p->name,
source_p->username, source_p->orighost, name);
source_p->localClient->oper_warn_count_down = OPER_SPAM_COUNTDOWN;
}
}
else
{
if((t_delta =
(rb_current_time() - source_p->localClient->last_leave_time)) >
JOIN_LEAVE_COUNT_EXPIRE_TIME)
{
decrement_count = (t_delta / JOIN_LEAVE_COUNT_EXPIRE_TIME);
if(name != NULL)
;
else if(decrement_count > source_p->localClient->join_leave_count)
source_p->localClient->join_leave_count = 0;
else
source_p->localClient->join_leave_count -= decrement_count;
}
else
{
if((rb_current_time() -
(source_p->localClient->last_join_time)) < GlobalSetOptions.spam_time)
{
/* oh, its a possible spambot */
source_p->localClient->join_leave_count++;
}
}
if(name != NULL)
source_p->localClient->last_join_time = rb_current_time();
else
source_p->localClient->last_leave_time = rb_current_time();
}
}
/* check_splitmode()
*
* input -
* output -
* side effects - compares usercount and servercount against their split
* values and adjusts splitmode accordingly
*/
void
chan::check_splitmode(void *unused)
{
if(splitchecking && (ConfigChannel.no_join_on_split || ConfigChannel.no_create_on_split))
{
/* not split, we're being asked to check now because someone
* has left
*/
if(!splitmode)
{
if(eob_count < split_servers || Count.total < split_users)
{
splitmode = 1;
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Network split, activating splitmode");
check_splitmode_ev = rb_event_addish("check_splitmode", check_splitmode, NULL, 2);
}
}
/* in splitmode, check whether its finished */
else if(eob_count >= split_servers && Count.total >= split_users)
{
splitmode = 0;
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Network rejoined, deactivating splitmode");
rb_event_delete(check_splitmode_ev);
check_splitmode_ev = NULL;
}
}
}
/* set_channel_topic()
*
* input - channel, topic to set, topic info and topic ts
* output -
* side effects - channels topic, topic info and TS are set.
*/
void
chan::set_channel_topic(chan *chptr, const char *topic, const char *topic_info, time_t topicts)
{
//TODO: XXX: is the topic* len previously truncated at TOPICLEN
//TODO: XXX: is the topc_info* previously truncated at USERHOST_REPLYLEN
if(strlen(topic) > 0)
{
chptr->topic.text = topic;
chptr->topic.info = topic_info;
chptr->topic.time = topicts;
}
else
{
chptr->topic.text.clear();
chptr->topic.info.clear();
chptr->topic.time = 0;
}
}
/* channel_modes()
*
* inputs - pointer to channel
* - pointer to client
* output - string with simple modes
* side effects - result from previous calls overwritten
*
* Stolen from ShadowIRCd 4 --nenolod
*/
const char *
chan::channel_modes(chan *chptr, client *client_p)
{
int i;
char buf1[BUFSIZE];
char buf2[BUFSIZE];
static char final[BUFSIZE];
char *mbuf = buf1;
char *pbuf = buf2;
*mbuf++ = '+';
*pbuf = '\0';
for (i = 0; i < 256; i++)
{
if(mode::table[i].set_func == mode::functor::hidden && (!IsOper(client_p) || !IsClient(client_p)))
continue;
if(chptr->mode.mode & mode::table[i].type)
*mbuf++ = i;
}
if(chptr->mode.limit)
{
*mbuf++ = 'l';
if(!IsClient(client_p) || is_member(chptr, client_p))
pbuf += sprintf(pbuf, " %d", chptr->mode.limit);
}
if(*chptr->mode.key)
{
*mbuf++ = 'k';
if(pbuf > buf2 || !IsClient(client_p) || is_member(chptr, client_p))
pbuf += sprintf(pbuf, " %s", chptr->mode.key);
}
if(chptr->mode.join_num)
{
*mbuf++ = 'j';
if(pbuf > buf2 || !IsClient(client_p) || is_member(chptr, client_p))
pbuf += sprintf(pbuf, " %d:%d", chptr->mode.join_num,
chptr->mode.join_time);
}
if(*chptr->mode.forward &&
(ConfigChannel.use_forward || !IsClient(client_p)))
{
*mbuf++ = 'f';
if(pbuf > buf2 || !IsClient(client_p) || is_member(chptr, client_p))
pbuf += sprintf(pbuf, " %s", chptr->mode.forward);
}
*mbuf = '\0';
rb_strlcpy(final, buf1, sizeof final);
rb_strlcat(final, buf2, sizeof final);
return final;
}
/* void send_cap_mode_changes(client *client_p,
* client *source_p,
* chan *chptr, int cap, int nocap)
* Input: The client sending(client_p), the source client(source_p),
* the channel to send mode changes for(chptr)
* Output: None.
* Side-effects: Sends the appropriate mode changes to capable servers.
*
* Reverted back to my original design, except that we now keep a count
* of the number of servers which each combination as an optimisation, so
* the capabs combinations which are not needed are not worked out. -A1kmm
*
* Removed most code here because we don't need to be compatible with ircd
* 2.8.21+CSr and stuff. --nenolod
*/
void
chan::send_cap_mode_changes(client *client_p, client *source_p,
chan *chptr, mode::change mode_changes[], int mode_count)
{
static char modebuf[BUFSIZE];
static char parabuf[BUFSIZE];
int i, mbl, pbl, nc, mc, preflen, len;
char *pbuf;
const char *arg;
int dir;
int arglen = 0;
/* Now send to servers... */
mc = 0;
nc = 0;
pbl = 0;
parabuf[0] = 0;
pbuf = parabuf;
dir = MODE_QUERY;
mbl = preflen = sprintf(modebuf, ":%s TMODE %ld %s ",
use_id(source_p), (long) chptr->channelts,
chptr->name.c_str());
/* loop the list of - modes we have */
for (i = 0; i < mode_count; i++)
{
/* if they dont support the cap we need, or they do support a cap they
* cant have, then dont add it to the modebuf.. that way they wont see
* the mode
*/
if (mode_changes[i].letter == 0)
continue;
if (!EmptyString(mode_changes[i].id))
arg = mode_changes[i].id;
else
arg = mode_changes[i].arg;
if(arg)
{
arglen = strlen(arg);
/* dont even think about it! --fl */
if(arglen > mode::BUFLEN - 5)
continue;
}
/* if we're creeping past the buf size, we need to send it and make
* another line for the other modes
* XXX - this could give away server topology with uids being
* different lengths, but not much we can do, except possibly break
* them as if they were the longest of the nick or uid at all times,
* which even then won't work as we don't always know the uid -A1kmm.
*/
if(arg && ((mc == mode::MAXPARAMSSERV) ||
((mbl + pbl + arglen + 4) > (BUFSIZE - 3))))
{
if(nc != 0)
sendto_server(client_p, chptr, NOCAPS, NOCAPS,
"%s %s", modebuf, parabuf);
nc = 0;
mc = 0;
mbl = preflen;
pbl = 0;
pbuf = parabuf;
parabuf[0] = 0;
dir = MODE_QUERY;
}
if(dir != mode_changes[i].dir)
{
modebuf[mbl++] = (mode_changes[i].dir == MODE_ADD) ? '+' : '-';
dir = mode_changes[i].dir;
}
modebuf[mbl++] = mode_changes[i].letter;
modebuf[mbl] = 0;
nc++;
if(arg != NULL)
{
len = sprintf(pbuf, "%s ", arg);
pbuf += len;
pbl += len;
mc++;
}
}
if(pbl && parabuf[pbl - 1] == ' ')
parabuf[pbl - 1] = 0;
if(nc != 0)
sendto_server(client_p, chptr, NOCAPS, NOCAPS, "%s %s", modebuf, parabuf);
}
void
chan::resv_chan_forcepart(const char *name, const char *reason, int temp_time)
{
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
chan *chptr;
membership *msptr;
client *target_p;
if(!ConfigChannel.resv_forcepart)
return;
/* for each user on our server in the channel list
* send them a PART, and notify opers.
*/
chptr = find_channel(name);
if(chptr != NULL)
{
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->locmembers.head)
{
msptr = (membership *)ptr->data;
target_p = msptr->client;
if(IsExemptResv(target_p))
continue;
sendto_server(target_p, chptr, CAP_TS6, NOCAPS,
":%s PART %s", target_p->id, chptr->name.c_str());
sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s :%s",
target_p->name, target_p->username,
target_p->host, chptr->name.c_str(), target_p->name);
remove_user_from_channel(msptr);
/* notify opers & user they were removed from the channel */
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Forced PART for %s!%s@%s from %s (%s)",
target_p->name, target_p->username,
target_p->host, name, reason);
if(temp_time > 0)
sendto_one_notice(target_p, ":*** Channel %s is temporarily unavailable on this server.",
name);
else
sendto_one_notice(target_p, ":*** Channel %s is no longer available on this server.",
name);
}
}
}
Reference in a new issue View git blame Copy permalink