static void free_topic(struct Channel *chptr);
static int h_can_join;
+static int h_can_send;
+int h_get_channel_access;
/* init_channels()
*
member_heap = rb_bh_create(sizeof(struct membership), MEMBER_HEAP_SIZE, "member_heap");
h_can_join = register_hook("can_join");
+ h_can_send = register_hook("can_send");
+ h_get_channel_access = register_hook("get_channel_access");
}
/*
free_channel(struct Channel *chptr)
{
rb_free(chptr->chname);
+ rb_free(chptr->mode_lock);
rb_bh_free(channel_heap, chptr);
}
struct Ban *
-allocate_ban(const char *banstr, const char *who)
+allocate_ban(const char *banstr, const char *who, const char *forward)
{
struct Ban *bptr;
bptr = rb_bh_alloc(ban_heap);
bptr->banstr = rb_strdup(banstr);
bptr->who = rb_strdup(who);
+ bptr->forward = forward ? rb_strdup(forward) : NULL;
return (bptr);
}
{
rb_free(bptr->banstr);
rb_free(bptr->who);
+ rb_free(bptr->forward);
rb_bh_free(ban_heap, bptr);
}
+/*
+ * send_channel_join()
+ *
+ * input - channel to join, client joining.
+ * output - none
+ * side effects - none
+ */
+void
+send_channel_join(struct Channel *chptr, struct Client *client_p)
+{
+ if (!IsClient(client_p))
+ return;
+
+ sendto_channel_local_with_capability(ALL_MEMBERS, NOCAPS, CLICAP_EXTENDED_JOIN, chptr, ":%s!%s@%s JOIN %s",
+ client_p->name, client_p->username, client_p->host, chptr->chname);
+
+ sendto_channel_local_with_capability(ALL_MEMBERS, CLICAP_EXTENDED_JOIN, NOCAPS, chptr, ":%s!%s@%s JOIN %s %s :%s",
+ client_p->name, client_p->username, client_p->host, chptr->chname,
+ EmptyString(client_p->user->suser) ? "*" : client_p->user->suser,
+ client_p->info);
+}
/* find_channel_membership()
*
*/
int
is_banned(struct Channel *chptr, struct Client *who, struct membership *msptr,
- const char *s, const char *s2)
+ const char *s, const char *s2, const char **forward)
{
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
}
}
+ if (actualBan && actualBan->forward && forward)
+ *forward = actualBan->forward;
+
return ((actualBan ? CHFL_BAN : 0));
}
/* can_join()
*
* input - client to check, channel to check for, key
- * output - reason for not being able to join, else 0
+ * 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
-can_join(struct Client *source_p, struct Channel *chptr, char *key)
+can_join(struct Client *source_p, struct Channel *chptr, char *key, char **forward)
{
rb_dlink_node *invite = NULL;
rb_dlink_node *ptr;
s_assert(source_p->localClient != NULL);
+ moduledata.client = source_p;
+ moduledata.chptr = chptr;
+ moduledata.approved = 0;
+
rb_sprintf(src_host, "%s!%s@%s", source_p->name, source_p->username, source_p->host);
rb_sprintf(src_iphost, "%s!%s@%s", source_p->name, source_p->username, source_p->sockhost);
if(source_p->localClient->mangledhost != NULL)
}
}
- if((is_banned(chptr, source_p, NULL, src_host, src_iphost)) == CHFL_BAN)
- return (ERR_BANNEDFROMCHAN);
+ if((is_banned(chptr, source_p, NULL, src_host, src_iphost, forward)) == CHFL_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)
{
if(invite == NULL)
{
if(!ConfigChannel.use_invex)
- return (ERR_INVITEONLYCHAN);
+ moduledata.approved = ERR_INVITEONLYCHAN;
RB_DLINK_FOREACH(ptr, chptr->invexlist.head)
{
invex = ptr->data;
break;
}
if(ptr == NULL)
- return (ERR_INVITEONLYCHAN);
+ moduledata.approved = ERR_INVITEONLYCHAN;
}
}
- if(*chptr->mode.key && (EmptyString(key) || irccmp(chptr->mode.key, key)))
- return (ERR_BADCHANNELKEY);
-
if(chptr->mode.limit &&
rb_dlink_list_length(&chptr->members) >= (unsigned long) chptr->mode.limit)
i = ERR_CHANNELISFULL;
break;
}
if (invite == NULL)
- return i;
+ moduledata.approved = i;
}
- moduledata.client = source_p;
- moduledata.chptr = chptr;
- moduledata.approved = 0;
-
+finish_join_check:
call_hook(h_can_join, &moduledata);
return moduledata.approved;
int
can_send(struct Channel *chptr, struct Client *source_p, struct membership *msptr)
{
+ hook_data_channel_approval moduledata;
+
+ moduledata.approved = CAN_SEND_NONOP;
+
if(IsServer(source_p) || IsService(source_p))
return CAN_SEND_OPV;
if(MyClient(source_p) && hash_find_resv(chptr->chname) &&
!IsOper(source_p) && !IsExemptResv(source_p))
- return CAN_SEND_NO;
+ moduledata.approved = CAN_SEND_NO;
if(msptr == NULL)
{
* theres no possibility of caching them --fl
*/
if(chptr->mode.mode & MODE_NOPRIVMSGS || chptr->mode.mode & MODE_MODERATED)
- return CAN_SEND_NO;
+ moduledata.approved = CAN_SEND_NO;
else
- return CAN_SEND_NONOP;
+ moduledata.approved = CAN_SEND_NONOP;
+
+ return moduledata.approved;
}
}
- if(is_chanop_voiced(msptr))
- return CAN_SEND_OPV;
-
if(chptr->mode.mode & MODE_MODERATED)
- return CAN_SEND_NO;
+ moduledata.approved = CAN_SEND_NO;
if(MyClient(source_p))
{
if(msptr->bants == chptr->bants)
{
if(can_send_banned(msptr))
- return CAN_SEND_NO;
+ moduledata.approved = CAN_SEND_NO;
}
- else if(is_banned(chptr, source_p, msptr, NULL, NULL) == CHFL_BAN
+ else if(is_banned(chptr, source_p, msptr, NULL, NULL, NULL) == CHFL_BAN
|| is_quieted(chptr, source_p, msptr, NULL, NULL) == CHFL_BAN)
- return CAN_SEND_NO;
+ moduledata.approved = CAN_SEND_NO;
+ }
+
+ if(is_chanop_voiced(msptr))
+ moduledata.approved = CAN_SEND_OPV;
+
+ moduledata.client = source_p;
+ moduledata.chptr = msptr->chptr;
+ moduledata.msptr = msptr;
+ moduledata.target = NULL;
+
+ 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 - 1 if target is under flood attack
+ * side effects - check for flood attack on target chptr
+ */
+int
+flood_attack_channel(int p_or_n, struct Client *source_p, struct Channel *chptr, char *chname)
+{
+ 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->chname == '&' ? 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->chname);
+ 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->chname);
+ return 1;
+ }
+ else
+ chptr->received_number_of_privmsgs++;
}
- return CAN_SEND_NONOP;
+ return 0;
}
/* find_bannickchange_channel()
if (can_send_banned(msptr))
return chptr;
}
- else if (is_banned(chptr, client_p, msptr, src_host, src_iphost) == CHFL_BAN
+ else if (is_banned(chptr, client_p, msptr, src_host, src_iphost, NULL) == CHFL_BAN
|| is_quieted(chptr, client_p, msptr, src_host, src_iphost) == CHFL_BAN)
return chptr;
}
chptr->mode.join_time);
}
- if(*chptr->mode.forward && (ConfigChannel.use_forward || !IsClient(client_p)))
+ if(*chptr->mode.forward &&
+ (ConfigChannel.use_forward || !IsClient(client_p)))
{
*mbuf++ = 'f';
sendto_server(client_p, chptr, cap, nocap, "%s %s", modebuf, parabuf);
}
}
+
+void
+resv_chan_forcepart(const char *name, const char *reason, int temp_time)
+{
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
+ struct Channel *chptr;
+ struct membership *msptr;
+ struct 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 = ptr->data;
+ target_p = msptr->client_p;
+
+ if(IsExemptResv(target_p))
+ continue;
+
+ sendto_server(target_p, chptr, CAP_TS6, NOCAPS,
+ ":%s PART %s", target_p->id, chptr->chname);
+
+ sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s :%s",
+ target_p->name, target_p->username,
+ target_p->host, chptr->chname, 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);
+ }
+ }
+}
projects / solanum.git / blobdiff