2007-01-25 07:40:21 +01:00
|
|
|
/*
|
|
|
|
* ircd-ratbox: A slightly useful ircd.
|
|
|
|
* channel.c: Controls channels.
|
|
|
|
*
|
2014-03-03 05:25:47 +01:00
|
|
|
* 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
|
2016-08-19 07:58:17 +02:00
|
|
|
* Copyright (C) 2005-2016 Charybdis Development Team
|
|
|
|
* Copyright (C) 2016 Jason Volk <jason@zemos.net>
|
2007-01-25 07:40:21 +01:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
using namespace ircd;
|
2016-08-13 05:05:54 +02:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
int h_can_join;
|
|
|
|
int h_can_send;
|
|
|
|
int h_get_channel_access;
|
2008-06-28 09:54:51 +02:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
struct config_channel_entry ircd::ConfigChannel;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
rb_dlink_list chan::global_channel_list;
|
|
|
|
//std::map<std::string, std::unique_ptr<chan::chan>> chan::chans;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::init()
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
h_can_join = register_hook("can_join");
|
2010-12-07 07:09:46 +01:00
|
|
|
h_can_send = register_hook("can_send");
|
2010-12-07 05:57:28 +01:00
|
|
|
h_get_channel_access = register_hook("get_channel_access");
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::chan::chan(const std::string &name)
|
|
|
|
:name{name}
|
|
|
|
,mode{}
|
|
|
|
,mode_lock{}
|
|
|
|
,topic{}
|
|
|
|
,members{0}
|
|
|
|
,locmembers{0}
|
|
|
|
,invites{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}
|
2016-08-19 07:58:17 +02:00
|
|
|
,last_checked_type{mode::type(0)}
|
2016-08-18 07:33:38 +02:00
|
|
|
,last_checked_result{0}
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::chan::~chan()
|
|
|
|
noexcept
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
rb_dlink_node *ptr, *next_ptr;
|
|
|
|
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, invites.head)
|
|
|
|
del_invite(this, reinterpret_cast<client *>(ptr->data));
|
|
|
|
|
|
|
|
rb_dlinkDelete(&node, &global_channel_list);
|
|
|
|
del_from_channel_hash(name.c_str(), this);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::membership::membership()
|
|
|
|
:channode{0}
|
|
|
|
,locchannode{0}
|
|
|
|
,usernode{0}
|
|
|
|
,chan{nullptr}
|
|
|
|
,client{nullptr}
|
|
|
|
,flags{0}
|
|
|
|
,bants{0}
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::membership::~membership()
|
|
|
|
noexcept
|
|
|
|
{
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
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,
|
2016-08-19 07:58:17 +02:00
|
|
|
const std::string &forward,
|
|
|
|
const time_t &when)
|
2016-08-18 07:33:38 +02:00
|
|
|
:banstr{banstr}
|
|
|
|
,who{who}
|
|
|
|
,forward{forward}
|
2016-08-19 07:58:17 +02:00
|
|
|
,when{when}
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-12-16 07:09:29 +01:00
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::send_join(chan &chan,
|
|
|
|
Client &client)
|
2010-12-16 07:09:29 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
if (!IsClient(&client))
|
2010-12-16 07:09:29 +01:00
|
|
|
return;
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
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);
|
2010-12-16 07:09:29 +01:00
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
/* find_channel_membership()
|
|
|
|
*
|
|
|
|
* input - channel to find them in, client to find
|
|
|
|
* output - membership of client in channel, else NULL
|
|
|
|
* side effects -
|
|
|
|
*/
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::membership *
|
|
|
|
chan::find_channel_membership(chan *chptr, client *client_p)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
struct membership *msptr;
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlink_node *ptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2008-04-01 22:41:52 +02:00
|
|
|
if(rb_dlink_list_length(&chptr->members) < rb_dlink_list_length(&client_p->user->channel))
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2008-04-01 22:43:10 +02:00
|
|
|
RB_DLINK_FOREACH(ptr, chptr->members.head)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-07-13 07:17:21 +02:00
|
|
|
msptr = (membership *)ptr->data;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(msptr->client == client_p)
|
2007-01-25 07:40:21 +01:00
|
|
|
return msptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-04-01 22:43:10 +02:00
|
|
|
RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-07-13 07:17:21 +02:00
|
|
|
msptr = (membership *)ptr->data;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(msptr->chan == chptr)
|
2007-01-25 07:40:21 +01:00
|
|
|
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 *
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::find_status(const membership *const &msptr,
|
|
|
|
const int &combine)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
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
|
2014-03-03 05:25:47 +01:00
|
|
|
* output -
|
2007-01-25 07:40:21 +01:00
|
|
|
* side effects - user is added to channel
|
|
|
|
*/
|
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::add_user_to_channel(chan *chptr, client *client_p, int flags)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
membership *msptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
s_assert(client_p->user != NULL);
|
|
|
|
if(client_p->user == NULL)
|
|
|
|
return;
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
msptr = new membership;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
msptr->chan = chptr;
|
|
|
|
msptr->client = client_p;
|
2007-01-25 07:40:21 +01:00
|
|
|
msptr->flags = flags;
|
|
|
|
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlinkAdd(msptr, &msptr->usernode, &client_p->user->channel);
|
|
|
|
rb_dlinkAdd(msptr, &msptr->channode, &chptr->members);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
if(MyClient(client_p))
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlinkAdd(msptr, &msptr->locchannode, &chptr->locmembers);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* remove_user_from_channel()
|
|
|
|
*
|
|
|
|
* input - membership pointer to remove from channel
|
|
|
|
* output -
|
|
|
|
* side effects - membership (thus user) is removed from channel
|
|
|
|
*/
|
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::remove_user_from_channel(membership *msptr)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
client *client_p;
|
|
|
|
chan *chptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
s_assert(msptr != NULL);
|
|
|
|
if(msptr == NULL)
|
|
|
|
return;
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
client_p = msptr->client;
|
|
|
|
chptr = msptr->chan;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlinkDelete(&msptr->usernode, &client_p->user->channel);
|
|
|
|
rb_dlinkDelete(&msptr->channode, &chptr->members);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
if(client_p->servptr == &me)
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-17 05:01:20 +02:00
|
|
|
if(!(chptr->mode.mode & mode::PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
|
2016-08-18 07:33:38 +02:00
|
|
|
delete chptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
delete msptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove_user_from_channels()
|
|
|
|
*
|
|
|
|
* input - user to remove from all channels
|
|
|
|
* output -
|
|
|
|
* side effects - user is removed from all channels
|
|
|
|
*/
|
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::remove_user_from_channels(client *client_p)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
chan *chptr;
|
|
|
|
membership *msptr;
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlink_node *ptr;
|
2008-04-02 00:47:17 +02:00
|
|
|
rb_dlink_node *next_ptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
if(client_p == NULL)
|
|
|
|
return;
|
|
|
|
|
2008-04-02 00:47:17 +02:00
|
|
|
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->user->channel.head)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-07-13 07:17:21 +02:00
|
|
|
msptr = (membership *)ptr->data;
|
2016-08-18 07:33:38 +02:00
|
|
|
chptr = msptr->chan;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlinkDelete(&msptr->channode, &chptr->members);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
if(client_p->servptr == &me)
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-17 05:01:20 +02:00
|
|
|
if(!(chptr->mode.mode & mode::PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
|
2016-08-18 07:33:38 +02:00
|
|
|
delete chptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
delete msptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::invalidate_bancache_user(client *client_p)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
membership *msptr;
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlink_node *ptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
if(client_p == NULL)
|
|
|
|
return;
|
|
|
|
|
2008-04-01 22:43:10 +02:00
|
|
|
RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-07-13 07:17:21 +02:00
|
|
|
msptr = (membership *)ptr->data;
|
2007-01-25 07:40:21 +01:00
|
|
|
msptr->bants = 0;
|
2016-08-18 07:33:38 +02:00
|
|
|
msptr->flags &= ~BANNED;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* channel_pub_or_secret()
|
|
|
|
*
|
|
|
|
* input - channel
|
|
|
|
* output - "=" if public, "@" if secret, else "*"
|
|
|
|
* side effects -
|
|
|
|
*/
|
|
|
|
static const char *
|
2016-08-18 07:33:38 +02:00
|
|
|
channel_pub_or_secret(chan::chan *const &chptr)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 01:33:46 +02:00
|
|
|
return chan::is_public(chptr)? "=":
|
|
|
|
chan::is_secret(chptr)? "@":
|
|
|
|
"*";
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::channel_member_names(chan *chptr, client *client_p, int show_eon)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
membership *msptr;
|
|
|
|
client *target_p;
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlink_node *ptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
char lbuf[BUFSIZE];
|
|
|
|
char *t;
|
|
|
|
int mlen;
|
|
|
|
int tlen;
|
|
|
|
int cur_len;
|
|
|
|
int stack = IsCapable(client_p, CLICAP_MULTI_PREFIX);
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(can_show(chptr, client_p))
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-02-10 02:25:32 +01:00
|
|
|
cur_len = mlen = sprintf(lbuf, form_str(RPL_NAMREPLY),
|
2007-01-25 07:40:21 +01:00
|
|
|
me.name, client_p->name,
|
2016-08-18 07:33:38 +02:00
|
|
|
channel_pub_or_secret(chptr), chptr->name.c_str());
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
t = lbuf + cur_len;
|
|
|
|
|
2008-04-01 22:43:10 +02:00
|
|
|
RB_DLINK_FOREACH(ptr, chptr->members.head)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-07-13 07:17:21 +02:00
|
|
|
msptr = (membership *)ptr->data;
|
2016-08-18 07:33:38 +02:00
|
|
|
target_p = msptr->client;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(IsInvisible(target_p) && !is_member(chptr, client_p))
|
2007-01-25 07:40:21 +01:00
|
|
|
continue;
|
|
|
|
|
2015-02-28 08:06:38 +01:00
|
|
|
if (IsCapable(client_p, CLICAP_USERHOST_IN_NAMES))
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2015-02-28 08:06:38 +01:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
tlen = sprintf(t, "%s%s!%s@%s ", find_status(msptr, stack),
|
2015-02-28 08:06:38 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
tlen = sprintf(t, "%s%s ", find_status(msptr, stack),
|
2015-02-28 08:06:38 +01:00
|
|
|
target_p->name);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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),
|
2016-08-18 07:33:38 +02:00
|
|
|
me.name, client_p->name, chptr->name.c_str());
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* del_invite()
|
|
|
|
*
|
|
|
|
* input - channel to remove invite from, client to remove
|
|
|
|
* output -
|
|
|
|
* side effects - user is removed from invite list, if exists
|
|
|
|
*/
|
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::del_invite(chan *chptr, client *who)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlinkFindDestroy(who, &chptr->invites);
|
|
|
|
rb_dlinkFindDestroy(chptr, &who->user->invited);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
bool
|
|
|
|
chan::cache_check(const chan &chan,
|
|
|
|
const mode::type &type,
|
|
|
|
const client &who,
|
|
|
|
bool &result)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
using namespace mode;
|
2016-08-18 07:33:38 +02:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (chan.last_checked_client != &who)
|
|
|
|
return false;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (chan.last_checked_ts <= chan.bants)
|
|
|
|
return false;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
switch (type)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
case BAN:
|
|
|
|
case QUIET:
|
|
|
|
result = chan.last_checked_result;
|
|
|
|
return true;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
default:
|
|
|
|
return false;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
2016-08-19 07:58:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
chan::cache_result(chan &chan,
|
|
|
|
const mode::type &type,
|
|
|
|
const client &client,
|
|
|
|
const bool &result,
|
|
|
|
membership *const &membership)
|
|
|
|
{
|
|
|
|
using namespace mode;
|
|
|
|
|
|
|
|
switch (type)
|
2012-01-08 16:39:11 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
case BAN:
|
|
|
|
case QUIET:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return;
|
2012-01-08 16:39:11 +01:00
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
chan.last_checked_client = &client;
|
|
|
|
chan.last_checked_type = type;
|
|
|
|
chan.last_checked_result = result;
|
|
|
|
chan.last_checked_ts = rb_current_time();
|
|
|
|
|
|
|
|
if (membership)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
membership->bants = chan.bants;
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
membership->flags |= BANNED;
|
2007-01-25 07:40:21 +01:00
|
|
|
else
|
2016-08-19 07:58:17 +02:00
|
|
|
membership->flags &= ~BANNED;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
2016-08-19 07:58:17 +02:00
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
bool
|
|
|
|
chan::check(chan &chan,
|
|
|
|
const mode::type &type,
|
|
|
|
const client &client,
|
|
|
|
check_data *const &data)
|
|
|
|
{
|
|
|
|
bool result;
|
|
|
|
if (cache_check(chan, type, client, result))
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (!my(client))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
enum srcs { HOST, IPHOST, ALTHOST, IP4HOST, _NUM_ };
|
|
|
|
char src[num_of<srcs>()][NICKLEN + USERLEN + HOSTLEN + 6];
|
|
|
|
const char *s[num_of<srcs>()]
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
data? data->host : nullptr,
|
|
|
|
data? data->iphost : nullptr
|
|
|
|
};
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
// if the buffers havent been built, do it here
|
|
|
|
if (!s[HOST])
|
|
|
|
{
|
|
|
|
sprintf(src[HOST], "%s!%s@%s", client.name, client.username, client.host);
|
|
|
|
s[HOST] = src[HOST];
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (!s[IPHOST])
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
sprintf(src[IPHOST], "%s!%s@%s", client.name, client.username, client.sockhost);
|
|
|
|
s[IPHOST] = src[IPHOST];
|
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (client.localClient->mangledhost)
|
|
|
|
{
|
|
|
|
// if host mangling mode enabled, also check their real host
|
|
|
|
if (strcmp(client.host, client.localClient->mangledhost) == 0)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
sprintf(src[ALTHOST], "%s!%s@%s", client.name, client.username, client.orighost);
|
|
|
|
s[ALTHOST] = src[ALTHOST];
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
2016-08-19 07:58:17 +02:00
|
|
|
// if host mangling mode not enabled and no other spoof, check the mangled form of their host
|
|
|
|
else if (!IsDynSpoof(&client))
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
sprintf(src[ALTHOST], "%s!%s@%s", client.name, client.username, client.localClient->mangledhost);
|
|
|
|
s[ALTHOST] = src[ALTHOST];
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
#ifdef RB_IPV6
|
|
|
|
struct sockaddr_in ip4;
|
|
|
|
if (GET_SS_FAMILY(&client.localClient->ip) == AF_INET6 &&
|
|
|
|
rb_ipv4_from_ipv6((const struct sockaddr_in6 *)&client.localClient->ip, &ip4))
|
|
|
|
{
|
|
|
|
sprintf(src[IP4HOST], "%s!%s@", client.name, client.username);
|
|
|
|
char *const pos(src[IP4HOST] + strlen(src[IP4HOST]));
|
|
|
|
rb_inet_ntop_sock((struct sockaddr *)&ip4, pos, src[IP4HOST] + sizeof(src[IP4HOST]) - pos);
|
|
|
|
s[IP4HOST] = src[IP4HOST];
|
|
|
|
}
|
|
|
|
#endif
|
2011-08-13 02:33:10 +02:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
const auto matched([&s, &chan, &client]
|
|
|
|
(const ban &ban)
|
|
|
|
{
|
|
|
|
const auto &mask(ban.banstr);
|
|
|
|
if (match(mask, s[HOST]))
|
|
|
|
return true;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (match(mask, s[IPHOST]))
|
|
|
|
return true;
|
2012-01-08 16:21:07 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (match_cidr(mask, s[IPHOST]))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (s[ALTHOST] && match(mask, s[ALTHOST]))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (match_extban(mask.c_str(), const_cast<Client *>(&client), &chan, mode::BAN))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
#ifdef RB_IPV6
|
|
|
|
if (s[IP4HOST] && match(mask, s[IP4HOST]))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (s[IP4HOST] && match_cidr(mask, s[IP4HOST]))
|
|
|
|
return true;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return false;
|
|
|
|
});
|
|
|
|
|
|
|
|
const auto &list(get(chan, type));
|
|
|
|
const auto it(std::find_if(begin(list), end(list), matched));
|
|
|
|
const auto msptr(data? data->msptr : nullptr);
|
|
|
|
result = it != end(list);
|
|
|
|
|
|
|
|
if (result && ircd::ConfigChannel.use_except)
|
|
|
|
{
|
|
|
|
const auto &list(get(chan, mode::EXCEPTION));
|
|
|
|
if (std::any_of(begin(list), end(list), matched))
|
|
|
|
{
|
|
|
|
cache_result(chan, type, client, false, msptr);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (result && data && data->forward)
|
|
|
|
{
|
|
|
|
const auto &ban(*it);
|
|
|
|
if (!ban.forward.empty())
|
|
|
|
*data->forward = ban.forward.c_str(); //TODO: XXX: ???
|
|
|
|
}
|
|
|
|
|
|
|
|
cache_result(chan, type, client, result, msptr);
|
|
|
|
return result;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* can_join()
|
|
|
|
*
|
|
|
|
* input - client to check, channel to check for, key
|
2011-08-13 02:33:10 +02:00
|
|
|
* output - reason for not being able to join, else 0, channel name to forward to
|
2007-01-25 07:40:21 +01:00
|
|
|
* side effects -
|
2010-08-29 21:07:44 +02:00
|
|
|
* caveats - this function should only be called on a local user.
|
2007-01-25 07:40:21 +01:00
|
|
|
*/
|
|
|
|
int
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::can_join(client *source_p, chan *chptr, const char *key, const char **forward)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlink_node *invite = NULL;
|
|
|
|
rb_dlink_node *ptr;
|
2016-08-18 07:33:38 +02:00
|
|
|
ban *invex = NULL;
|
2007-01-25 07:40:21 +01:00
|
|
|
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;
|
2007-03-15 19:09:08 +01:00
|
|
|
int i = 0;
|
2007-01-25 07:40:21 +01:00
|
|
|
hook_data_channel moduledata;
|
|
|
|
|
|
|
|
s_assert(source_p->localClient != NULL);
|
|
|
|
|
2010-12-07 06:52:44 +01:00
|
|
|
moduledata.client = source_p;
|
|
|
|
moduledata.chptr = chptr;
|
|
|
|
moduledata.approved = 0;
|
|
|
|
|
2016-02-10 02:25:32 +01:00
|
|
|
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);
|
2007-01-25 07:40:21 +01:00
|
|
|
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))
|
|
|
|
{
|
2016-02-10 02:25:32 +01:00
|
|
|
sprintf(src_althost, "%s!%s@%s", source_p->name, source_p->username, source_p->orighost);
|
2007-01-25 07:40:21 +01:00
|
|
|
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))
|
|
|
|
{
|
2016-02-10 02:25:32 +01:00
|
|
|
sprintf(src_althost, "%s!%s@%s", source_p->name, source_p->username, source_p->localClient->mangledhost);
|
2007-01-25 07:40:21 +01:00
|
|
|
use_althost = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
check_data data
|
|
|
|
{
|
|
|
|
nullptr,
|
|
|
|
src_host,
|
|
|
|
src_iphost,
|
|
|
|
forward
|
|
|
|
};
|
|
|
|
|
|
|
|
if (check(*chptr, mode::BAN, *source_p, &data))
|
2010-12-07 06:52:44 +01:00
|
|
|
{
|
|
|
|
moduledata.approved = ERR_BANNEDFROMCHAN;
|
|
|
|
goto finish_join_check;
|
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (*chptr->mode.key && (EmptyString(key) || irccmp(chptr->mode.key, key)))
|
2011-08-13 02:33:10 +02:00
|
|
|
{
|
|
|
|
moduledata.approved = ERR_BADCHANNELKEY;
|
|
|
|
goto finish_join_check;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* All checks from this point on will forward... */
|
2016-08-19 07:58:17 +02:00
|
|
|
if (forward)
|
2011-08-13 02:33:10 +02:00
|
|
|
*forward = chptr->mode.forward;
|
|
|
|
|
2016-08-19 07:58:17 +02:00
|
|
|
if (chptr->mode.mode & mode::INVITEONLY)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2008-04-01 22:43:10 +02:00
|
|
|
RB_DLINK_FOREACH(invite, source_p->user->invited.head)
|
2016-08-19 07:58:17 +02:00
|
|
|
if (invite->data == chptr)
|
2007-01-25 07:40:21 +01:00
|
|
|
break;
|
2016-08-19 07:58:17 +02:00
|
|
|
|
|
|
|
if (!invite)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
if (!ConfigChannel.use_invex)
|
2010-12-07 06:52:44 +01:00
|
|
|
moduledata.approved = ERR_INVITEONLYCHAN;
|
2016-08-19 07:58:17 +02:00
|
|
|
|
|
|
|
const auto &list(get(*chptr, mode::INVEX));
|
|
|
|
const bool matched(std::any_of(begin(list), end(list), [&]
|
|
|
|
(const auto &ban)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-19 07:58:17 +02:00
|
|
|
const auto &mask(ban.banstr);
|
|
|
|
if (match(mask, src_host))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (match(mask, src_iphost))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (match_cidr(mask, src_iphost))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (match_extban(mask.c_str(), source_p, chptr, mode::INVEX))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (use_althost && match(mask, src_althost))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}));
|
|
|
|
|
|
|
|
if (!matched)
|
2010-12-07 06:52:44 +01:00
|
|
|
moduledata.approved = ERR_INVITEONLYCHAN;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(chptr->mode.limit &&
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlink_list_length(&chptr->members) >= (unsigned long) chptr->mode.limit)
|
2007-03-15 19:09:08 +01:00
|
|
|
i = ERR_CHANNELISFULL;
|
2016-08-17 05:01:20 +02:00
|
|
|
if(chptr->mode.mode & mode::REGONLY && EmptyString(source_p->user->suser))
|
2007-03-15 19:09:08 +01:00
|
|
|
i = ERR_NEEDREGGEDNICK;
|
2007-01-25 07:40:21 +01:00
|
|
|
/* join throttling stuff --nenolod */
|
2007-03-15 19:09:08 +01:00
|
|
|
else if(chptr->mode.join_num > 0 && chptr->mode.join_time > 0)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2014-03-03 05:25:47 +01:00
|
|
|
if ((rb_current_time() - chptr->join_delta <=
|
2007-01-25 07:40:21 +01:00
|
|
|
chptr->mode.join_time) && (chptr->join_count >=
|
|
|
|
chptr->mode.join_num))
|
2007-03-15 19:09:08 +01:00
|
|
|
i = ERR_THROTTLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow /invite to override +l/+r/+j also -- jilles */
|
|
|
|
if (i != 0 && invite == NULL)
|
|
|
|
{
|
2008-04-01 22:43:10 +02:00
|
|
|
RB_DLINK_FOREACH(invite, source_p->user->invited.head)
|
2007-03-15 19:09:08 +01:00
|
|
|
{
|
|
|
|
if(invite->data == chptr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (invite == NULL)
|
2010-12-07 06:52:44 +01:00
|
|
|
moduledata.approved = i;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2010-12-07 06:52:44 +01:00
|
|
|
finish_join_check:
|
2007-01-25 07:40:21 +01:00
|
|
|
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
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::can_send(chan *chptr, client *source_p, membership *msptr)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2010-12-07 07:09:46 +01:00
|
|
|
hook_data_channel_approval moduledata;
|
|
|
|
|
|
|
|
moduledata.approved = CAN_SEND_NONOP;
|
2015-12-10 08:00:32 +01:00
|
|
|
moduledata.dir = MODE_QUERY;
|
2010-12-07 07:09:46 +01:00
|
|
|
|
2007-01-25 07:40:21 +01:00
|
|
|
if(IsServer(source_p) || IsService(source_p))
|
|
|
|
return CAN_SEND_OPV;
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(MyClient(source_p) && hash_find_resv(chptr->name.c_str()) &&
|
2007-01-25 07:40:21 +01:00
|
|
|
!IsOper(source_p) && !IsExemptResv(source_p))
|
2010-12-07 07:09:46 +01:00
|
|
|
moduledata.approved = CAN_SEND_NO;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2016-08-17 05:01:20 +02:00
|
|
|
if(chptr->mode.mode & mode::NOPRIVMSGS || chptr->mode.mode & mode::MODERATED)
|
2010-12-07 07:09:46 +01:00
|
|
|
moduledata.approved = CAN_SEND_NO;
|
2007-01-25 07:40:21 +01:00
|
|
|
else
|
2010-12-07 07:09:46 +01:00
|
|
|
moduledata.approved = CAN_SEND_NONOP;
|
2010-12-15 05:57:23 +01:00
|
|
|
|
|
|
|
return moduledata.approved;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-17 05:01:20 +02:00
|
|
|
if(chptr->mode.mode & mode::MODERATED)
|
2010-12-07 07:09:46 +01:00
|
|
|
moduledata.approved = CAN_SEND_NO;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
if(MyClient(source_p))
|
|
|
|
{
|
|
|
|
/* cached can_send */
|
|
|
|
if(msptr->bants == chptr->bants)
|
|
|
|
{
|
|
|
|
if(can_send_banned(msptr))
|
2010-12-07 07:09:46 +01:00
|
|
|
moduledata.approved = CAN_SEND_NO;
|
2016-08-19 07:58:17 +02:00
|
|
|
} else {
|
|
|
|
check_data data
|
|
|
|
{
|
|
|
|
msptr
|
|
|
|
};
|
|
|
|
|
|
|
|
if (check(*chptr, mode::BAN, *source_p, &data))
|
|
|
|
moduledata.approved = CAN_SEND_NO;
|
|
|
|
|
|
|
|
if (check(*chptr, mode::QUIET, *source_p, &data))
|
|
|
|
moduledata.approved = CAN_SEND_NO;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-12 03:21:47 +01:00
|
|
|
if(is_chanop_voiced(msptr))
|
|
|
|
moduledata.approved = CAN_SEND_OPV;
|
|
|
|
|
2011-02-13 15:50:25 +01:00
|
|
|
moduledata.client = source_p;
|
2016-08-18 07:33:38 +02:00
|
|
|
moduledata.chptr = msptr->chan;
|
2011-02-13 15:50:25 +01:00
|
|
|
moduledata.msptr = msptr;
|
|
|
|
moduledata.target = NULL;
|
2016-08-18 07:33:38 +02:00
|
|
|
moduledata.dir = moduledata.approved == CAN_SEND_NO? MODE_ADD : MODE_QUERY;
|
2011-02-13 15:50:25 +01:00
|
|
|
|
2010-12-07 07:09:46 +01:00
|
|
|
call_hook(h_can_send, &moduledata);
|
|
|
|
|
|
|
|
return moduledata.approved;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2010-12-10 00:29:56 +01:00
|
|
|
/*
|
|
|
|
* flood_attack_channel
|
|
|
|
* inputs - flag 0 if PRIVMSG 1 if NOTICE. RFC
|
|
|
|
* says NOTICE must not auto reply
|
2014-03-03 05:25:47 +01:00
|
|
|
* - pointer to source Client
|
2016-03-24 07:19:30 +01:00
|
|
|
* - pointer to target channel
|
|
|
|
* output - true if target is under flood attack
|
2010-12-10 00:29:56 +01:00
|
|
|
* side effects - check for flood attack on target chptr
|
|
|
|
*/
|
2016-03-24 07:19:30 +01:00
|
|
|
bool
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::flood_attack_channel(int p_or_n, client *source_p, chan *chptr)
|
2010-12-10 00:29:56 +01:00
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
sendto_realops_snomask(SNO_BOTS, chptr->name[0] == '&' ? L_ALL : L_NETWIDE,
|
2010-12-10 00:29:56 +01:00
|
|
|
"Possible Flooder %s[%s@%s] on %s target: %s",
|
|
|
|
source_p->name, source_p->username,
|
|
|
|
source_p->orighost,
|
2016-08-18 07:33:38 +02:00
|
|
|
source_p->servptr->name, chptr->name.c_str());
|
2010-12-10 00:29:56 +01:00
|
|
|
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",
|
2016-08-18 07:33:38 +02:00
|
|
|
me.name, source_p->name, chptr->name.c_str());
|
2016-03-24 07:19:30 +01:00
|
|
|
return true;
|
2010-12-10 00:29:56 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
chptr->received_number_of_privmsgs++;
|
|
|
|
}
|
|
|
|
|
2016-03-24 07:19:30 +01:00
|
|
|
return false;
|
2010-12-10 00:29:56 +01:00
|
|
|
}
|
|
|
|
|
2007-01-25 07:40:21 +01:00
|
|
|
/* find_bannickchange_channel()
|
|
|
|
* Input: client to check
|
|
|
|
* Output: channel preventing nick change
|
|
|
|
*/
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::chan *
|
|
|
|
chan::find_bannickchange_channel(client *client_p)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
chan *chptr;
|
|
|
|
membership *msptr;
|
2008-04-01 22:41:52 +02:00
|
|
|
rb_dlink_node *ptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
|
|
|
|
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
|
|
|
|
|
|
|
|
if (!MyClient(client_p))
|
|
|
|
return NULL;
|
|
|
|
|
2016-02-10 02:25:32 +01:00
|
|
|
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);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2008-04-01 22:43:10 +02:00
|
|
|
RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-07-13 07:17:21 +02:00
|
|
|
msptr = (membership *)ptr->data;
|
2016-08-18 07:33:38 +02:00
|
|
|
chptr = msptr->chan;
|
2007-01-25 07:40:21 +01:00
|
|
|
if (is_chanop_voiced(msptr))
|
|
|
|
continue;
|
|
|
|
/* cached can_send */
|
|
|
|
if (msptr->bants == chptr->bants)
|
|
|
|
{
|
|
|
|
if (can_send_banned(msptr))
|
|
|
|
return chptr;
|
2016-08-19 07:58:17 +02:00
|
|
|
} else {
|
|
|
|
check_data data
|
|
|
|
{
|
|
|
|
msptr,
|
|
|
|
src_host,
|
|
|
|
src_iphost,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (check(*chptr, mode::BAN, *client_p, &data))
|
|
|
|
return chptr;
|
|
|
|
|
|
|
|
if (check(*chptr, mode::QUIET, *client_p, &data))
|
|
|
|
return chptr;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
2016-08-19 07:58:17 +02:00
|
|
|
|
2007-01-25 07:40:21 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
/* void check_spambot_warning(client *source_p)
|
2007-01-25 07:40:21 +01:00
|
|
|
* 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
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::check_spambot_warning(client *source_p, const char *name)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
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;
|
2008-11-08 17:22:41 +01:00
|
|
|
if(source_p->localClient->oper_warn_count_down == 0 &&
|
|
|
|
name != NULL)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
/* Its already known as a possible spambot */
|
2008-11-08 17:22:41 +01:00
|
|
|
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);
|
2007-01-25 07:40:21 +01:00
|
|
|
source_p->localClient->oper_warn_count_down = OPER_SPAM_COUNTDOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if((t_delta =
|
2008-04-02 01:53:20 +02:00
|
|
|
(rb_current_time() - source_p->localClient->last_leave_time)) >
|
2007-01-25 07:40:21 +01:00
|
|
|
JOIN_LEAVE_COUNT_EXPIRE_TIME)
|
|
|
|
{
|
|
|
|
decrement_count = (t_delta / JOIN_LEAVE_COUNT_EXPIRE_TIME);
|
2010-02-21 01:29:41 +01:00
|
|
|
if(name != NULL)
|
|
|
|
;
|
|
|
|
else if(decrement_count > source_p->localClient->join_leave_count)
|
2007-01-25 07:40:21 +01:00
|
|
|
source_p->localClient->join_leave_count = 0;
|
|
|
|
else
|
|
|
|
source_p->localClient->join_leave_count -= decrement_count;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-04-02 01:53:20 +02:00
|
|
|
if((rb_current_time() -
|
2007-01-25 07:40:21 +01:00
|
|
|
(source_p->localClient->last_join_time)) < GlobalSetOptions.spam_time)
|
|
|
|
{
|
|
|
|
/* oh, its a possible spambot */
|
|
|
|
source_p->localClient->join_leave_count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(name != NULL)
|
2008-04-02 01:53:20 +02:00
|
|
|
source_p->localClient->last_join_time = rb_current_time();
|
2007-01-25 07:40:21 +01:00
|
|
|
else
|
2008-04-02 01:53:20 +02:00
|
|
|
source_p->localClient->last_leave_time = rb_current_time();
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check_splitmode()
|
|
|
|
*
|
|
|
|
* input -
|
|
|
|
* output -
|
|
|
|
* side effects - compares usercount and servercount against their split
|
|
|
|
* values and adjusts splitmode accordingly
|
|
|
|
*/
|
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::check_splitmode(void *unused)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
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");
|
2008-04-02 02:56:51 +02:00
|
|
|
check_splitmode_ev = rb_event_addish("check_splitmode", check_splitmode, NULL, 2);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* 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");
|
|
|
|
|
2008-04-02 02:56:51 +02:00
|
|
|
rb_event_delete(check_splitmode_ev);
|
2008-06-29 01:37:11 +02:00
|
|
|
check_splitmode_ev = NULL;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::set_channel_topic(chan *chptr, const char *topic, const char *topic_info, time_t topicts)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
//TODO: XXX: is the topic* len previously truncated at TOPICLEN
|
|
|
|
//TODO: XXX: is the topc_info* previously truncated at USERHOST_REPLYLEN
|
|
|
|
|
2007-01-25 07:40:21 +01:00
|
|
|
if(strlen(topic) > 0)
|
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
chptr->topic.text = topic;
|
|
|
|
chptr->topic.info = topic_info;
|
|
|
|
chptr->topic.time = topicts;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-08-18 07:33:38 +02:00
|
|
|
chptr->topic.text.clear();
|
|
|
|
chptr->topic.info.clear();
|
|
|
|
chptr->topic.time = 0;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-02 22:29:22 +02:00
|
|
|
/* channel_modes()
|
2007-01-25 07:40:21 +01:00
|
|
|
*
|
|
|
|
* inputs - pointer to channel
|
|
|
|
* - pointer to client
|
2007-04-27 01:01:16 +02:00
|
|
|
* output - string with simple modes
|
|
|
|
* side effects - result from previous calls overwritten
|
2007-01-25 07:40:21 +01:00
|
|
|
*
|
|
|
|
* Stolen from ShadowIRCd 4 --nenolod
|
|
|
|
*/
|
|
|
|
const char *
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::channel_modes(chan *chptr, client *client_p)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char buf1[BUFSIZE];
|
|
|
|
char buf2[BUFSIZE];
|
|
|
|
static char final[BUFSIZE];
|
|
|
|
char *mbuf = buf1;
|
|
|
|
char *pbuf = buf2;
|
|
|
|
|
|
|
|
*mbuf++ = '+';
|
|
|
|
*pbuf = '\0';
|
|
|
|
|
2008-06-24 18:45:19 +02:00
|
|
|
for (i = 0; i < 256; i++)
|
2016-01-13 23:34:27 +01:00
|
|
|
{
|
2016-08-17 05:01:20 +02:00
|
|
|
if(mode::table[i].set_func == mode::functor::hidden && (!IsOper(client_p) || !IsClient(client_p)))
|
2016-01-13 23:34:27 +01:00
|
|
|
continue;
|
2016-08-17 05:01:20 +02:00
|
|
|
if(chptr->mode.mode & mode::table[i].type)
|
2008-06-24 18:45:19 +02:00
|
|
|
*mbuf++ = i;
|
2016-01-13 23:34:27 +01:00
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2010-05-02 22:29:22 +02:00
|
|
|
if(chptr->mode.limit)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
*mbuf++ = 'l';
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(!IsClient(client_p) || is_member(chptr, client_p))
|
2016-02-10 02:25:32 +01:00
|
|
|
pbuf += sprintf(pbuf, " %d", chptr->mode.limit);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2010-05-02 22:29:22 +02:00
|
|
|
if(*chptr->mode.key)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
*mbuf++ = 'k';
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(pbuf > buf2 || !IsClient(client_p) || is_member(chptr, client_p))
|
2016-02-10 02:25:32 +01:00
|
|
|
pbuf += sprintf(pbuf, " %s", chptr->mode.key);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2010-05-02 22:29:22 +02:00
|
|
|
if(chptr->mode.join_num)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
*mbuf++ = 'j';
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(pbuf > buf2 || !IsClient(client_p) || is_member(chptr, client_p))
|
2016-02-10 02:25:32 +01:00
|
|
|
pbuf += sprintf(pbuf, " %d:%d", chptr->mode.join_num,
|
2010-05-02 22:29:22 +02:00
|
|
|
chptr->mode.join_time);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
2011-09-25 16:22:29 +02:00
|
|
|
if(*chptr->mode.forward &&
|
|
|
|
(ConfigChannel.use_forward || !IsClient(client_p)))
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
*mbuf++ = 'f';
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
if(pbuf > buf2 || !IsClient(client_p) || is_member(chptr, client_p))
|
2016-02-10 02:25:32 +01:00
|
|
|
pbuf += sprintf(pbuf, " %s", chptr->mode.forward);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
*mbuf = '\0';
|
|
|
|
|
2008-04-20 06:40:40 +02:00
|
|
|
rb_strlcpy(final, buf1, sizeof final);
|
2008-04-20 06:44:04 +02:00
|
|
|
rb_strlcat(final, buf2, sizeof final);
|
2007-01-25 07:40:21 +01:00
|
|
|
return final;
|
|
|
|
}
|
|
|
|
|
2016-08-18 07:33:38 +02:00
|
|
|
/* void send_cap_mode_changes(client *client_p,
|
|
|
|
* client *source_p,
|
|
|
|
* chan *chptr, int cap, int nocap)
|
2007-01-25 07:40:21 +01:00
|
|
|
* 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
|
2012-02-04 08:47:46 +01:00
|
|
|
*
|
|
|
|
* Removed most code here because we don't need to be compatible with ircd
|
|
|
|
* 2.8.21+CSr and stuff. --nenolod
|
2007-01-25 07:40:21 +01:00
|
|
|
*/
|
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::send_cap_mode_changes(client *client_p, client *source_p,
|
|
|
|
chan *chptr, mode::change mode_changes[], int mode_count)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
|
|
|
static char modebuf[BUFSIZE];
|
|
|
|
static char parabuf[BUFSIZE];
|
|
|
|
int i, mbl, pbl, nc, mc, preflen, len;
|
|
|
|
char *pbuf;
|
|
|
|
const char *arg;
|
2012-02-04 08:47:46 +01:00
|
|
|
int dir;
|
2016-06-01 21:58:53 +02:00
|
|
|
int arglen = 0;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
|
|
|
/* Now send to servers... */
|
2012-02-04 08:47:46 +01:00
|
|
|
mc = 0;
|
|
|
|
nc = 0;
|
|
|
|
pbl = 0;
|
|
|
|
parabuf[0] = 0;
|
|
|
|
pbuf = parabuf;
|
|
|
|
dir = MODE_QUERY;
|
|
|
|
|
2016-02-10 02:25:32 +01:00
|
|
|
mbl = preflen = sprintf(modebuf, ":%s TMODE %ld %s ",
|
2012-02-04 08:47:46 +01:00
|
|
|
use_id(source_p), (long) chptr->channelts,
|
2016-08-18 07:33:38 +02:00
|
|
|
chptr->name.c_str());
|
2012-02-04 08:47:46 +01:00
|
|
|
|
|
|
|
/* loop the list of - modes we have */
|
|
|
|
for (i = 0; i < mode_count; i++)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2012-02-04 08:47:46 +01:00
|
|
|
/* 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)
|
2007-01-25 07:40:21 +01:00
|
|
|
continue;
|
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
if (!EmptyString(mode_changes[i].id))
|
|
|
|
arg = mode_changes[i].id;
|
|
|
|
else
|
|
|
|
arg = mode_changes[i].arg;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
if(arg)
|
2007-01-25 07:40:21 +01:00
|
|
|
{
|
2012-02-04 08:47:46 +01:00
|
|
|
arglen = strlen(arg);
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
/* dont even think about it! --fl */
|
2016-08-17 05:01:20 +02:00
|
|
|
if(arglen > mode::BUFLEN - 5)
|
2012-02-04 08:47:46 +01:00
|
|
|
continue;
|
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
/* 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.
|
|
|
|
*/
|
2016-08-17 05:01:20 +02:00
|
|
|
if(arg && ((mc == mode::MAXPARAMSSERV) ||
|
2012-02-04 08:47:46 +01:00
|
|
|
((mbl + pbl + arglen + 4) > (BUFSIZE - 3))))
|
|
|
|
{
|
|
|
|
if(nc != 0)
|
2014-05-29 16:07:45 +02:00
|
|
|
sendto_server(client_p, chptr, NOCAPS, NOCAPS,
|
2012-02-04 08:47:46 +01:00
|
|
|
"%s %s", modebuf, parabuf);
|
|
|
|
nc = 0;
|
|
|
|
mc = 0;
|
|
|
|
|
|
|
|
mbl = preflen;
|
|
|
|
pbl = 0;
|
|
|
|
pbuf = parabuf;
|
|
|
|
parabuf[0] = 0;
|
|
|
|
dir = MODE_QUERY;
|
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
if(dir != mode_changes[i].dir)
|
|
|
|
{
|
|
|
|
modebuf[mbl++] = (mode_changes[i].dir == MODE_ADD) ? '+' : '-';
|
|
|
|
dir = mode_changes[i].dir;
|
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
modebuf[mbl++] = mode_changes[i].letter;
|
|
|
|
modebuf[mbl] = 0;
|
|
|
|
nc++;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
if(arg != NULL)
|
|
|
|
{
|
2016-02-10 02:25:32 +01:00
|
|
|
len = sprintf(pbuf, "%s ", arg);
|
2012-02-04 08:47:46 +01:00
|
|
|
pbuf += len;
|
|
|
|
pbl += len;
|
|
|
|
mc++;
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
2012-02-04 08:47:46 +01:00
|
|
|
}
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
if(pbl && parabuf[pbl - 1] == ' ')
|
|
|
|
parabuf[pbl - 1] = 0;
|
2007-01-25 07:40:21 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
if(nc != 0)
|
2014-05-29 16:07:45 +02:00
|
|
|
sendto_server(client_p, chptr, NOCAPS, NOCAPS, "%s %s", modebuf, parabuf);
|
2007-01-25 07:40:21 +01:00
|
|
|
}
|
2010-03-27 16:13:57 +01:00
|
|
|
|
2012-02-04 08:47:46 +01:00
|
|
|
void
|
2016-08-18 07:33:38 +02:00
|
|
|
chan::resv_chan_forcepart(const char *name, const char *reason, int temp_time)
|
2010-03-27 16:13:57 +01:00
|
|
|
{
|
|
|
|
rb_dlink_node *ptr;
|
|
|
|
rb_dlink_node *next_ptr;
|
2016-08-18 07:33:38 +02:00
|
|
|
chan *chptr;
|
|
|
|
membership *msptr;
|
|
|
|
client *target_p;
|
2010-03-27 16:13:57 +01:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2016-07-13 07:17:21 +02:00
|
|
|
msptr = (membership *)ptr->data;
|
2016-08-18 07:33:38 +02:00
|
|
|
target_p = msptr->client;
|
2010-03-27 16:13:57 +01:00
|
|
|
|
|
|
|
if(IsExemptResv(target_p))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
sendto_server(target_p, chptr, CAP_TS6, NOCAPS,
|
2016-08-18 07:33:38 +02:00
|
|
|
":%s PART %s", target_p->id, chptr->name.c_str());
|
2010-03-27 16:13:57 +01:00
|
|
|
|
|
|
|
sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s :%s",
|
|
|
|
target_p->name, target_p->username,
|
2016-08-18 07:33:38 +02:00
|
|
|
target_p->host, chptr->name.c_str(), target_p->name);
|
2010-03-27 16:13:57 +01:00
|
|
|
|
|
|
|
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)",
|
2014-03-03 05:25:47 +01:00
|
|
|
target_p->name, target_p->username,
|
2010-03-27 16:13:57 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-08-19 07:58:17 +02:00
|
|
|
|
|
|
|
bool
|
|
|
|
chan::add(chan &chan,
|
|
|
|
const mode::type &type,
|
|
|
|
const std::string &mask,
|
|
|
|
client &source,
|
|
|
|
const std::string &forward)
|
|
|
|
|
|
|
|
{
|
|
|
|
// dont let local clients overflow the banlist, or set redundant bans
|
|
|
|
if (my(source))
|
|
|
|
{
|
|
|
|
const bool large(chan.mode & mode::EXLIMIT);
|
|
|
|
const size_t &max(large? ConfigChannel.max_bans_large : ConfigChannel.max_bans);
|
|
|
|
if (lists_size(chan) > max)
|
|
|
|
{
|
|
|
|
sendto_one(&source, form_str(ERR_BANLISTFULL),
|
|
|
|
me.name,
|
|
|
|
source.name,
|
|
|
|
chan.name.c_str(),
|
|
|
|
mask.c_str());
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto matches([&mask](const ban &ban)
|
|
|
|
{
|
|
|
|
return match_mask(ban.banstr, mask);
|
|
|
|
});
|
|
|
|
|
|
|
|
const auto &list(get(chan, type));
|
|
|
|
if (std::any_of(begin(list), end(list), matches))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto &list(get(chan, type));
|
|
|
|
auto insertion(list.emplace(mask, std::string{}, forward, rb_current_time()));
|
|
|
|
if (!insertion.second)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
auto &ban(const_cast<struct ban &>(*insertion.first));
|
|
|
|
if (is_person(source))
|
|
|
|
{
|
|
|
|
static char who[USERHOST_REPLYLEN];
|
|
|
|
snprintf(who, sizeof(who), "%s!%s@%s", source.name, source.username, source.host);
|
|
|
|
ban.who = who;
|
|
|
|
}
|
|
|
|
else ban.who = source.name;
|
|
|
|
|
|
|
|
cache_invalidate(chan, type, ban.when);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
chan::del(chan &chan,
|
|
|
|
const mode::type &type,
|
|
|
|
const std::string &mask)
|
|
|
|
|
|
|
|
{
|
|
|
|
if (mask.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
auto &list(get(chan, type));
|
|
|
|
if (!list.erase(mask))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
cache_invalidate(chan, type);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const chan::ban &
|
|
|
|
chan::get(const chan &chan,
|
|
|
|
const mode::type &type,
|
|
|
|
const std::string &mask)
|
|
|
|
{
|
|
|
|
const auto &list(get(chan, type));
|
|
|
|
const auto &it(list.find(mask));
|
|
|
|
if (it == end(list))
|
|
|
|
throw not_found();
|
|
|
|
|
|
|
|
return *it;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
chan::cache_invalidate(chan &chan,
|
|
|
|
const mode::type &type,
|
|
|
|
time_t time)
|
|
|
|
{
|
|
|
|
using namespace mode;
|
|
|
|
|
|
|
|
if (!time)
|
|
|
|
time = rb_current_time();
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case BAN:
|
|
|
|
case QUIET:
|
|
|
|
case EXCEPTION:
|
|
|
|
chan.bants = time;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
chan::lists_size(const chan &chan)
|
|
|
|
{
|
|
|
|
using namespace mode;
|
|
|
|
|
|
|
|
return size(chan, BAN) +
|
|
|
|
size(chan, EXCEPTION) +
|
|
|
|
size(chan, INVEX) +
|
|
|
|
size(chan, QUIET);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
chan::size(const chan &chan,
|
|
|
|
const mode::type &type)
|
|
|
|
{
|
|
|
|
return get(chan, type).size();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
chan::empty(const chan &chan,
|
|
|
|
const mode::type &type)
|
|
|
|
{
|
|
|
|
return get(chan, type).empty();
|
|
|
|
}
|
|
|
|
|
|
|
|
chan::list &
|
|
|
|
chan::get(chan &chan,
|
|
|
|
const mode::type &type)
|
|
|
|
{
|
|
|
|
using namespace mode;
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case BAN: return chan.bans;
|
|
|
|
case EXCEPTION: return chan.excepts;
|
|
|
|
case INVEX: return chan.invexs;
|
|
|
|
case QUIET: return chan.quiets;
|
|
|
|
default:
|
|
|
|
throw invalid_list();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const chan::list &
|
|
|
|
chan::get(const chan &chan,
|
|
|
|
const mode::type &type)
|
|
|
|
{
|
|
|
|
using namespace mode;
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case BAN: return chan.bans;
|
|
|
|
case EXCEPTION: return chan.excepts;
|
|
|
|
case INVEX: return chan.invexs;
|
|
|
|
case QUIET: return chan.quiets;
|
|
|
|
default:
|
|
|
|
throw invalid_list();
|
|
|
|
}
|
|
|
|
}
|