Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/VibeDevelopers/Comet.
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265/* * ircd-ratbox: A slightly useful ircd. * m_message.c: Sends a (PRIVMSG|NOTICE) message to a user or channel. * * 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 */
#include "stdinc.h"#include "client.h"#include "ircd.h"#include "numeric.h"#include "s_conf.h"#include "s_serv.h"#include "msg.h"#include "parse.h"#include "modules.h"#include "channel.h"#include "match.h"#include "hash.h"#include "class.h"#include "msg.h"#include "packet.h"#include "send.h"#include "s_newconf.h"#include "s_stats.h"#include "tgchange.h"#include "client_tags.h"#include "response.h"#include "s_assert.h"#include "inline/stringops.h"
static const char message_desc[] = "Provides the PRIVMSG, NOTICE, TAGMSG commands to send messages to users and channels";
static const char shortname[MESSAGE_TYPE_COUNT] = { [MESSAGE_TYPE_PRIVMSG] = 'P', [MESSAGE_TYPE_NOTICE] = 'N', [MESSAGE_TYPE_TAGMSG] = 'T',};
static const char *cmdname[MESSAGE_TYPE_COUNT] = { [MESSAGE_TYPE_PRIVMSG] = "PRIVMSG", [MESSAGE_TYPE_NOTICE] = "NOTICE", [MESSAGE_TYPE_TAGMSG] = "TAGMSG"};
static const char *cmdname_lower[MESSAGE_TYPE_COUNT] = { [MESSAGE_TYPE_PRIVMSG] = "privmsg", [MESSAGE_TYPE_NOTICE] = "notice", [MESSAGE_TYPE_TAGMSG] = "tagmsg"};
static void m_message(enum message_type, struct MsgBuf *, struct Client *, struct Client *, int, const char **);static void m_privmsg(struct MsgBuf *, struct Client *, struct Client *, int, const char **);static void m_notice(struct MsgBuf *, struct Client *, struct Client *, int, const char **);static void m_tagmsg(struct MsgBuf *, struct Client *, struct Client *, int, const char **);static void m_echo(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
static void echo_msg(struct Client *, struct Client *, enum message_type, const char *text, struct MsgBuf *msgbuf_p);
static void expire_tgchange(void *unused);static struct ev_entry *expire_tgchange_event;
static uint64_t CAP_ECHO;
struct entity{ union { struct Client *target_p; struct Channel *chptr; }; char mask[NICKLEN + HOSTLEN + 2]; int type; int flags;};
static intmodinit(void){ expire_tgchange_event = rb_event_addish("expire_tgchange", expire_tgchange, NULL, 300); expire_tgchange(NULL); return 0;}
static voidmoddeinit(void){ rb_event_delete(expire_tgchange_event);}
struct Message privmsg_msgtab = { "PRIVMSG", 0, 0, 0, 0, {mg_unreg, {m_privmsg, 0}, {m_privmsg, 0}, mg_ignore, mg_ignore, {m_privmsg, 0}}};struct Message notice_msgtab = { "NOTICE", 0, 0, 0, 0, {mg_unreg, {m_notice, 0}, {m_notice, 0}, {m_notice, 0}, mg_ignore, {m_notice, 0}}};struct Message tagmsg_msgtab = { "TAGMSG", 0, 0, 0, 0, {mg_unreg, {m_tagmsg, 0}, {m_tagmsg, 0}, mg_ignore, mg_ignore, {m_tagmsg, 0}}};struct Message echo_msgtab = { "ECHO", 0, 0, 0, 0, {mg_unreg, mg_ignore, {m_echo, 3}, mg_ignore, mg_ignore, mg_ignore}};
mapi_clist_av1 message_clist[] = { &privmsg_msgtab, ¬ice_msgtab, &echo_msgtab, &tagmsg_msgtab, NULL };
mapi_cap_list_av2 message_cap_list[] = { { MAPI_CAP_SERVER, "ECHO", NULL, &CAP_ECHO }, { 0, NULL, NULL, NULL }};
DECLARE_MODULE_AV2(message, modinit, moddeinit, message_clist, NULL, NULL, message_cap_list, NULL, message_desc);
static int build_target_list(enum message_type msgtype, struct Client *client_p, struct Client *source_p, const char *nicks_channels, const char *text, struct MsgBuf *msgbuf_p);
static bool flood_attack_client(enum message_type msgtype, struct Client *source_p, struct Client *target_p);
/* Fifteen seconds should be plenty for a client to reply a ctcp */#define LARGE_CTCP_TIME 15
#define ENTITY_NONE 0#define ENTITY_CHANNEL 1#define ENTITY_CHANNEL_OPMOD 2#define ENTITY_CHANOPS_ON_CHANNEL 3#define ENTITY_CLIENT 4#define ENTITY_TARGET_ON_SERVER 5#define ENTITY_MASS_MESSAGE 6
static struct entity targets[512];static int ntargets = 0;
static void msg_channel(enum message_type msgtype, struct Client *client_p, struct Client *source_p, struct Channel *chptr, const char *text, struct MsgBuf *msgbuf_p);
static void msg_channel_opmod(enum message_type msgtype, struct Client *client_p, struct Client *source_p, struct Channel *chptr, const char *text, struct MsgBuf *msgbuf_p);
static void msg_channel_flags(enum message_type msgtype, struct Client *client_p, struct Client *source_p, struct Channel *chptr, int flags, const char *text, struct MsgBuf *msgbuf_p);
static void msg_client(enum message_type msgtype, struct Client *source_p, struct Client *target_p, const char *text, struct MsgBuf *msgbuf_p);
static void msg_client_targeted(enum message_type msgtype, struct Client *source_p, const char *nick, struct Client *target_p, const char *text, struct MsgBuf *msgbuf_p);
static void msg_mass(enum message_type msgtype, struct Client *client_p, struct Client *source_p, const char *mask, const char *text, struct MsgBuf *msgbuf_p);
/*** m_privmsg**** massive cleanup** rev argv 6/91**** Another massive cleanup Nov, 2000** (I don't think there is a single line left from 6/91. Maybe.)** m_privmsg and m_notice do basically the same thing.** in the original 2.8.2 code base, they were the same function** "m_message.c." When we did the great cleanup in conjuncton with bleep** of ircu fame, we split m_privmsg.c and m_notice.c.** I don't see the point of that now. Its harder to maintain, its** easier to introduce bugs into one version and not the other etc.** Really, the penalty of an extra function call isn't that big a deal folks.** -db Nov 13, 2000***/
static voidm_privmsg(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]){ m_message(MESSAGE_TYPE_PRIVMSG, msgbuf_p, client_p, source_p, parc, parv);}
static voidm_notice(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]){ m_message(MESSAGE_TYPE_NOTICE, msgbuf_p, client_p, source_p, parc, parv);}
static voidm_tagmsg(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]) { if (MyClient(source_p) && !IsClientCapable(source_p, CLICAP_MESSAGE_TAGS)) return;
m_message(MESSAGE_TYPE_TAGMSG, msgbuf_p, client_p, source_p, parc, parv);}
/* * inputs - flag privmsg or notice * - pointer to client_p * - pointer to source_p * - pointer to channel */static voidm_message(enum message_type msgtype, struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]){ /* let hooks work on a copy of msgbuf_p so they don't mutate the tags in incoming_message */ struct MsgBuf msgbuf; memcpy(&msgbuf, msgbuf_p, sizeof(struct MsgBuf));
if (parc < 2 || EmptyString(parv[1])) { if (msgtype != MESSAGE_TYPE_NOTICE) sendto_one(source_p, form_str(ERR_NORECIPIENT), me.name, source_p->name, cmdname[msgtype]); return; }
if (msgtype != MESSAGE_TYPE_TAGMSG && (parc < 3 || EmptyString(parv[2]))) { if (msgtype == MESSAGE_TYPE_PRIVMSG) sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name); return; }
if (msgtype == MESSAGE_TYPE_TAGMSG) { bool found_client_tag = false; for (int i = 0; i < msgbuf_p->n_tags; i++) { if (*msgbuf_p->tags[i].key == '+') { found_client_tag = true; break; } }
if (!found_client_tag) return; }
/* Finish the flood grace period if they're not messaging themselves * as some clients (ircN) do this as a "lag check" */ if (MyClient(source_p) && !IsFloodDone(source_p) && irccmp(source_p->name, parv[1])) flood_endgrace(source_p);
/* Lots of things dereference text and it'll be NULL if we get a TAGMSG. * Normalize to empty string to avoid segfaults. */ const char *text = parv[2]; if (text == NULL) text = "";
/* start a batch for multi-target messages */ if (strchr(parv[1], ',') != NULL) begin_local_response_batch();
build_target_list(msgtype, client_p, source_p, parv[1], text, &msgbuf); if (ntargets <= 0) return;
/* if any targets are remote, start a remote batch since the echo-message will come from the remote server */ int remote_targets = 0; int remote_chain_length = 0; const char *serv_mask = NULL;
for (int i = 0; i < ntargets; i++) { if (targets[i].type != ENTITY_CLIENT || MyConnect(targets[i].target_p)) continue;
remote_targets++;
if (serv_mask == NULL) serv_mask = targets[i].target_p->servptr->name; else if (strcmp(serv_mask, targets[i].target_p->servptr->name) != 0) /* if there's more than one remote server, use * since the s2s tag only accepts one mask */ serv_mask = "*";
/* in the event serv_mask == "*" we need to know how many servers we'll expect a response from */ for (struct Client *sptr = targets[i].target_p->servptr; !IsMe(sptr); sptr = sptr->servptr) remote_chain_length++; }
if (serv_mask != NULL) begin_remote_response_batch(*serv_mask == '*' ? remote_chain_length : remote_targets, serv_mask);
for (int i = 0; i < ntargets; i++) { switch (targets[i].type) { case ENTITY_CHANNEL: msg_channel(msgtype, client_p, source_p, targets[i].chptr, text, &msgbuf); break;
case ENTITY_CHANNEL_OPMOD: msg_channel_opmod(msgtype, client_p, source_p, targets[i].chptr, text, &msgbuf); break;
case ENTITY_CHANOPS_ON_CHANNEL: msg_channel_flags(msgtype, client_p, source_p, targets[i].chptr, targets[i].flags, text, &msgbuf); break;
case ENTITY_CLIENT: msg_client(msgtype, source_p, targets[i].target_p, text, &msgbuf); break;
case ENTITY_TARGET_ON_SERVER: msg_client_targeted(msgtype, source_p, targets[i].mask, targets[i].target_p, text, &msgbuf); break;
case ENTITY_MASS_MESSAGE: msg_mass(msgtype, client_p, source_p, targets[i].mask, text, &msgbuf); break; } }}
static voidm_echo(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]){ struct Client *target_p = find_person(parv[2]); enum message_type msgtype;
if (target_p == NULL) return;
switch (parv[1][0]) { case 'P': msgtype = MESSAGE_TYPE_PRIVMSG; break; case 'N': msgtype = MESSAGE_TYPE_NOTICE; break; case 'T': msgtype = MESSAGE_TYPE_TAGMSG; break; default: return; }
const char *text = parv[3]; if (text == NULL) text = "";
echo_msg(source_p, target_p, msgtype, parv[3], msgbuf_p);}
/* * duplicate_* * * inputs - pointer to check * - pointer to table of entities * - number of valid entities so far * output - true if duplicate pointer in table, false if not. * note, this does the canonize using pointers * side effects - NONE */static boolduplicate_client(struct Client *ptr){ for (int i = 0; i < ntargets; i++) if (targets[i].target_p == ptr) return true; return false;}
static boolduplicate_channel(struct Channel *ptr){ for (int i = 0; i < ntargets; i++) if (targets[i].chptr == ptr) return true; return false;}
static boolduplicate_mask(const char *mask){ for (int i = 0; i < ntargets; i++) if (!strcmp(targets[i].mask, mask)) return true; return false;}
/* * build_target_list * * inputs - pointer to given client_p (server) * - pointer to given source (oper/client etc.) * - pointer to list of nicks/channels * - pointer to table to place results * - pointer to text (only used if source_p is an oper) * - tags * output - number of valid entities * side effects - target_table is modified to contain a list of * pointers to channels or clients * if source client is an oper * all the classic old bizzare oper privmsg tricks * are parsed and sent as is, if prefixed with $ * to disambiguate. */
static intbuild_target_list(enum message_type msgtype, struct Client *client_p, struct Client *source_p, const char *nicks_channels, const char *text, struct MsgBuf *msgbuf_p){ int type; char *p, *nick, *target_list; struct Channel *chptr = NULL; struct Client *target_p;
target_list = LOCAL_COPY(nicks_channels); /* skip strcpy for non-lazyleafs */
ntargets = 0;
for(nick = rb_strtok_r(target_list, ",", &p); nick; nick = rb_strtok_r(NULL, ",", &p)) { char *with_prefix; rb_strlcpy(targets[ntargets].mask, nick, sizeof(targets[ntargets].mask)); /* * channels are privmsg'd a lot more than other clients, moved up * here plain old channel msg? */
if(IsChanPrefix(*nick)) { /* ignore send of local channel to a server (should not happen) */ if(IsServer(client_p) && *nick == '&') continue;
if((chptr = find_channel(nick)) != NULL) { if(!duplicate_channel(chptr)) { if(ntargets >= ConfigFileEntry.max_targets) { sendto_one(source_p, form_str(ERR_TOOMANYTARGETS), me.name, source_p->name, nick); return (1); } targets[ntargets].chptr = chptr; targets[ntargets++].type = ENTITY_CHANNEL; } }
/* non-existent channel */ else if(msgtype == MESSAGE_TYPE_PRIVMSG) sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), nick);
continue; }
if(MyClient(source_p)) target_p = find_named_person(nick); else target_p = find_person(nick);
/* look for a privmsg to another client */ if(target_p) { if(!duplicate_client(target_p)) { if(ntargets >= ConfigFileEntry.max_targets) { sendto_one(source_p, form_str(ERR_TOOMANYTARGETS), me.name, source_p->name, nick); return (1); } targets[ntargets].target_p = target_p; targets[ntargets].type = ENTITY_CLIENT; targets[ntargets++].flags = 0; } continue; }
/* @#channel or +#channel message ? */
type = 0; with_prefix = nick; /* allow %+@ if someone wants to do that */ for(;;) { if(*nick == '@') type |= CHFL_CHANOP; else if(*nick == '%') type |= CHFL_CHANOP | CHFL_HALFOP; else if(*nick == '+') type |= CHFL_CHANOP | CHFL_HALFOP | CHFL_VOICE; else break; nick++; }
if(type != 0) { /* no recipient.. */ if(EmptyString(nick)) { sendto_one(source_p, form_str(ERR_NORECIPIENT), me.name, source_p->name, cmdname[msgtype]); continue; }
/* At this point, nick+1 should be a channel name i.e. #foo or &foo * if the channel is found, fine, if not report an error */
if((chptr = find_channel(nick)) != NULL) { struct membership *msptr;
msptr = find_channel_membership(chptr, source_p);
if(!IsServer(source_p) && !IsService(source_p) && !(msptr && msptr->flags & (CHFL_CHANOP | CHFL_HALFOP | CHFL_VOICE))) { sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED), get_id(&me, source_p), get_id(source_p, source_p), with_prefix); continue; }
if(!duplicate_channel(chptr)) { if(ntargets >= ConfigFileEntry.max_targets) { sendto_one(source_p, form_str(ERR_TOOMANYTARGETS), me.name, source_p->name, nick); return (1); } targets[ntargets].chptr = chptr; targets[ntargets].type = ENTITY_CHANOPS_ON_CHANNEL; targets[ntargets++].flags = type; } } else if(msgtype == MESSAGE_TYPE_PRIVMSG) { sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), nick); }
continue; }
if(IsServer(client_p) && *nick == '=' && nick[1] == '#') { nick++; if((chptr = find_channel(nick)) != NULL) { if(!duplicate_channel(chptr)) { if(ntargets >= ConfigFileEntry.max_targets) { sendto_one(source_p, form_str(ERR_TOOMANYTARGETS), me.name, source_p->name, nick); return (1); } targets[ntargets].chptr = chptr; targets[ntargets++].type = ENTITY_CHANNEL_OPMOD; } }
/* non existant channel */ else if(msgtype == MESSAGE_TYPE_PRIVMSG) sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), nick);
continue; }
char *server = strchr(targets[ntargets].mask, '@'); if (server != NULL) { *server++ = '\0'; target_p = find_server(source_p, server); if (target_p == NULL) { if (msgtype == MESSAGE_TYPE_PRIVMSG) sendto_one_numeric(source_p, ERR_NOSUCHSERVER, form_str(ERR_NOSUCHSERVER), server); continue; }
/* This was not very useful except for bypassing certain * restrictions. Note that we still allow sending to * remote servers this way, for messaging pseudoservers * securely whether they have a service{} block or not. * -- jilles */ if (IsMe(target_p)) { if (msgtype == MESSAGE_TYPE_PRIVMSG) sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), nick); continue; }
if (!duplicate_client(target_p) && !duplicate_mask(targets[ntargets].mask)) { if (ntargets >= ConfigFileEntry.max_targets) { sendto_one(source_p, form_str(ERR_TOOMANYTARGETS), me.name, source_p->name, nick); return 1; }
targets[ntargets].target_p = target_p; targets[ntargets++].type = ENTITY_TARGET_ON_SERVER; }
continue; }
if (*nick == '$') { if (MyClient(source_p) && !IsOperMassNotice(source_p)) { if (!IsOper(source_p)) sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES)); else sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "mass_notice"); continue; }
if (*(nick + 1) != '$' && *(nick + 1) != '#') { sendto_one(source_p, ":%s NOTICE %s :The command %s %s is no longer supported, please use $%s", me.name, source_p->name, cmdname[msgtype], nick, nick); continue; }
if (!duplicate_mask(targets[ntargets].mask)) { if (ntargets >= ConfigFileEntry.max_targets) { sendto_one(source_p, form_str(ERR_TOOMANYTARGETS), me.name, source_p->name, nick); return 1; }
targets[ntargets].target_p = NULL; targets[ntargets++].type = ENTITY_MASS_MESSAGE; }
continue; }
/* no matching anything found - error if PRIVMSG */ if(msgtype == MESSAGE_TYPE_PRIVMSG) { /* dont give this numeric when source is local, * because its misleading --anfl */ if(!MyClient(source_p) && IsDigit(*nick)) sendto_one(source_p, ":%s %d %s * :Target left IRC. " "Failed to deliver: [%.20s]", get_id(&me, source_p), ERR_NOSUCHNICK, get_id(source_p, source_p), text); else sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), nick); }
} return (1);}
/* * msg_channel * * inputs - flag privmsg or notice * - pointer to client_p * - pointer to source_p * - pointer to channel * output - NONE * side effects - message given channel * * XXX - We need to rework this a bit, it's a tad ugly. --nenolod */static voidmsg_channel(enum message_type msgtype, struct Client *client_p, struct Client *source_p, struct Channel *chptr, const char *text, struct MsgBuf *msgbuf_p){ int result; hook_data_privmsg_channel hdata; uint64_t cli_cap = NOCAPS; uint64_t serv_cap = NOCAPS; const char *fmt = "%s %s :%s";
if (msgtype == MESSAGE_TYPE_TAGMSG) { cli_cap = CLICAP_MESSAGE_TAGS; serv_cap = CAP_STAG; fmt = "%s %s"; }
if(MyClient(source_p)) { /* idle time shouldn't be reset by notices or tagmsg */ if(msgtype == MESSAGE_TYPE_PRIVMSG) source_p->localClient->last = rb_current_time(); }
hdata.msgtype = msgtype; hdata.source_p = source_p; hdata.chptr = chptr; hdata.text = text; hdata.approved = 0; hdata.msgbuf = msgbuf_p;
call_hook(h_privmsg_channel, &hdata);
/* memory buffer address may have changed, update pointer */ text = hdata.text;
if (hdata.approved != 0) return;
/* hook may have reduced the string to nothing. */ if (EmptyString(text) && msgtype != MESSAGE_TYPE_TAGMSG) { /* could be empty after colour stripping and * that would cause problems later */ if(msgtype != MESSAGE_TYPE_NOTICE) sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name); return; }
/* chanops and voiced can flood their own channel with impunity */ if((result = can_send(chptr, source_p, NULL))) { if(result != CAN_SEND_OPV && MyClient(source_p) && !IsOperGeneral(source_p) && !add_channel_target(source_p, chptr)) { sendto_one(source_p, form_str(ERR_TARGCHANGE), me.name, source_p->name, chptr->chname); return; } if(result == CAN_SEND_OPV || !flood_attack_channel(msgtype, source_p, chptr, chptr->chname)) { sendto_channel_flags_tags(client_p, ALL_MEMBERS, source_p, chptr, cli_cap, NOCAPS, serv_cap, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, fmt, cmdname[msgtype], chptr->chname, text); } } else if(chptr->mode.mode & MODE_OPMODERATE && (!(chptr->mode.mode & MODE_NOPRIVMSGS) || IsMember(source_p, chptr))) { if(MyClient(source_p) && !IsOperGeneral(source_p) && !add_channel_target(source_p, chptr)) { sendto_one(source_p, form_str(ERR_TARGCHANGE), me.name, source_p->name, chptr->chname); return; } if(!flood_attack_channel(msgtype, source_p, chptr, chptr->chname)) { sendto_channel_opmod_tags(client_p, source_p, chptr, cli_cap, NOCAPS, serv_cap, NOCAPS, cmdname[msgtype], text, msgbuf_p->n_tags, msgbuf_p->tags); } } else { if(msgtype == MESSAGE_TYPE_PRIVMSG) sendto_one_numeric(source_p, ERR_CANNOTSENDTOCHAN, form_str(ERR_CANNOTSENDTOCHAN), chptr->chname); }}/* * msg_channel_opmod * * inputs - flag privmsg or notice * - pointer to client_p * - pointer to source_p * - pointer to channel * output - NONE * side effects - message given channel ops * * XXX - We need to rework this a bit, it's a tad ugly. --nenolod */static voidmsg_channel_opmod(enum message_type msgtype, struct Client *client_p, struct Client *source_p, struct Channel *chptr, const char *text, struct MsgBuf *msgbuf_p){ hook_data_privmsg_channel hdata; uint64_t cli_cap = msgtype == MESSAGE_TYPE_TAGMSG ? CLICAP_MESSAGE_TAGS : NOCAPS; uint64_t serv_cap = msgtype == MESSAGE_TYPE_TAGMSG ? CAP_STAG : NOCAPS;
hdata.msgtype = msgtype; hdata.source_p = source_p; hdata.chptr = chptr; hdata.text = text; hdata.approved = 0; hdata.msgbuf = msgbuf_p;
call_hook(h_privmsg_channel, &hdata);
/* memory buffer address may have changed, update pointer */ text = hdata.text;
if (hdata.approved != 0) return;
/* hook may have reduced the string to nothing. */ if (EmptyString(text) && msgtype != MESSAGE_TYPE_TAGMSG) { /* could be empty after colour stripping and * that would cause problems later */ if(msgtype != MESSAGE_TYPE_NOTICE) sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name); return; }
if(chptr->mode.mode & MODE_OPMODERATE && (!(chptr->mode.mode & MODE_NOPRIVMSGS) || IsMember(source_p, chptr))) { if(!flood_attack_channel(msgtype, source_p, chptr, chptr->chname)) { sendto_channel_opmod_tags(client_p, source_p, chptr, cli_cap, NOCAPS, serv_cap, NOCAPS, cmdname[msgtype], text, msgbuf_p->n_tags, msgbuf_p->tags); } } else { if(msgtype == MESSAGE_TYPE_PRIVMSG) sendto_one_numeric(source_p, ERR_CANNOTSENDTOCHAN, form_str(ERR_CANNOTSENDTOCHAN), chptr->chname); }}
/* * msg_channel_flags * * inputs - flag 0 if PRIVMSG 1 if NOTICE. RFC * say NOTICE must not auto reply * - pointer to client_p * - pointer to source_p * - pointer to channel * - flags * - pointer to text to send * output - NONE * side effects - message given channel either chanop or voice */static voidmsg_channel_flags(enum message_type msgtype, struct Client *client_p, struct Client *source_p, struct Channel *chptr, int flags, const char *text, struct MsgBuf *msgbuf_p){ int type; char c; hook_data_privmsg_channel hdata; uint64_t cli_cap = NOCAPS; uint64_t serv_cap = NOCAPS; const char *fmt = "%s %c%s :%s";
if (msgtype == MESSAGE_TYPE_TAGMSG) { cli_cap = CLICAP_MESSAGE_TAGS; serv_cap = CAP_STAG; fmt = "%s %c%s"; }
if(flags & CHFL_VOICE) { type = ONLY_CHANOPSHALFOPSVOICED; c = '+'; } else if(flags & CHFL_HALFOP) { type = ONLY_CHANOPSHALFOPS; c = '%'; } else { type = ONLY_CHANOPS; c = '@'; }
if(MyClient(source_p)) { /* idle time shouldn't be reset by notices or tagmsg */ if(msgtype == MESSAGE_TYPE_PRIVMSG) source_p->localClient->last = rb_current_time(); }
hdata.msgtype = msgtype; hdata.source_p = source_p; hdata.chptr = chptr; hdata.text = text; hdata.approved = 0; hdata.msgbuf = msgbuf_p;
call_hook(h_privmsg_channel, &hdata);
/* memory buffer address may have changed, update pointer */ text = hdata.text;
if (hdata.approved != 0) return;
if (EmptyString(text) && msgtype != MESSAGE_TYPE_TAGMSG) { /* could be empty after colour stripping and * that would cause problems later */ if(msgtype != MESSAGE_TYPE_NOTICE) sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name); return; }
sendto_channel_flags_tags(client_p, type, source_p, chptr, cli_cap, NOCAPS, serv_cap, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, fmt, cmdname[msgtype], c, chptr->chname, text);}
static voidexpire_tgchange(void *unused){ tgchange *target; rb_dlink_node *ptr, *next_ptr;
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, tgchange_list.head) { target = ptr->data;
if(target->expiry < rb_current_time()) { rb_dlinkDelete(ptr, &tgchange_list); rb_patricia_remove(tgchange_tree, target->pnode); rb_free(target->ip); rb_free(target); } }}
static voidecho_msg(struct Client *source_p, struct Client *target_p, enum message_type msgtype, const char *text, struct MsgBuf *msgbuf_p){ const char *fmt = msgtype == MESSAGE_TYPE_TAGMSG ? ":%s!%s@%s %s %s" : ":%s!%s@%s %s %s :%s";
/* avoid pointless s2s traffic by echoing messages from services back to services */ if (IsService(target_p)) return;
if (MyClient(target_p)) { if (!IsClientCapable(target_p, CLICAP_ECHO_MESSAGE)) return;
sendto_one_tags(target_p, NOCAPS, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, fmt, target_p->name, target_p->username, target_p->host, cmdname[msgtype], source_p->name, text); return; }
sendto_one_tags(target_p, CAP_ECHO, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, ":%s ECHO %c %s :%s", use_id(source_p), shortname[msgtype], use_id(target_p), text);}
/* * msg_client * * inputs - flag 0 if PRIVMSG 1 if NOTICE. RFC * say NOTICE must not auto reply * - pointer to source_p source (struct Client *) * - pointer to target_p target (struct Client *) * - pointer to text * output - NONE * side effects - message given channel either chanop or voice */static voidmsg_client(enum message_type msgtype, struct Client *source_p, struct Client *target_p, const char *text, struct MsgBuf *msgbuf_p){ int do_floodcount = 0; hook_data_privmsg_user hdata;
if(MyClient(source_p)) { /* idle time shouldn't be reset by notices or tagmsg */ if(msgtype == MESSAGE_TYPE_PRIVMSG) source_p->localClient->last = rb_current_time();
/* auto cprivmsg/cnotice */ do_floodcount = !IsOperGeneral(source_p) && !find_allowing_channel(source_p, target_p);
/* target change stuff, dont limit ctcp replies as that * would allow people to start filling up random users * targets just by ctcping them */ if((msgtype == MESSAGE_TYPE_PRIVMSG || *text != '\001') && ConfigFileEntry.target_change && do_floodcount) { if(!add_target(source_p, target_p)) { sendto_one(source_p, form_str(ERR_TARGCHANGE), me.name, source_p->name, target_p->name); return; } }
if (do_floodcount && msgtype == MESSAGE_TYPE_NOTICE && *text == '\001' && target_p->large_ctcp_sent + LARGE_CTCP_TIME >= rb_current_time()) do_floodcount = 0;
if (do_floodcount && flood_attack_client(msgtype, source_p, target_p)) return; } else if(source_p->from == target_p->from) { sendto_realops_snomask(SNO_DEBUG, L_NETWIDE, "Send message to %s[%s] dropped from %s(Fake Dir)", target_p->name, target_p->from->name, source_p->name); return; }
if(MyConnect(source_p) && (msgtype == MESSAGE_TYPE_PRIVMSG) && target_p->user && target_p->user->away) sendto_one_numeric(source_p, RPL_AWAY, form_str(RPL_AWAY), target_p->name, target_p->user->away);
hdata.msgtype = msgtype; hdata.source_p = source_p; hdata.target_p = target_p; hdata.text = text; hdata.approved = 0; hdata.msgbuf = msgbuf_p;
call_hook(h_privmsg_user, &hdata);
/* buffer location may have changed. */ text = hdata.text;
if (hdata.approved != 0) return;
if (MyClient(target_p)) { if (EmptyString(text) && msgtype != MESSAGE_TYPE_TAGMSG) { /* could be empty after colour stripping and * that would cause problems later */ if(msgtype != MESSAGE_TYPE_NOTICE) sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name); return; }
/* suppress labeled-response on the primary message if they're messaging themselves */ struct ResponseInfo *info = outgoing_response_info; if (source_p == target_p) suspend_response_batch();
if (msgtype == MESSAGE_TYPE_TAGMSG && IsClientCapable(target_p, CLICAP_MESSAGE_TAGS)) { add_reply_target(target_p, source_p); sendto_anywhere_tags(target_p, source_p, cmdname[msgtype], NOCAPS, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, ""); } else if (msgtype != MESSAGE_TYPE_TAGMSG) { add_reply_target(target_p, source_p); sendto_anywhere_tags(target_p, source_p, cmdname[msgtype], NOCAPS, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, ":%s", text); }
resume_response_batch(info); echo_msg(target_p, source_p, msgtype, text, msgbuf_p); } else { sendto_anywhere_tags(target_p, source_p, cmdname[msgtype], msgtype == MESSAGE_TYPE_TAGMSG ? CAP_STAG : NOCAPS, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, msgtype == MESSAGE_TYPE_TAGMSG ? "" : ":%s", text);
/* if the remote doesn't support ECHO, generate a local echo-message instead */ if (!IsServerCapable(target_p->from, CAP_ECHO)) echo_msg(target_p, source_p, msgtype, text, msgbuf_p); }}
static voidmsg_client_targeted(enum message_type msgtype, struct Client *source_p, const char *nick, struct Client *target_p, const char *text, struct MsgBuf *msgbuf_p){ s_assert(!IsMe(target_p) && IsServer(target_p));
sendto_one_tags(target_p, msgtype == MESSAGE_TYPE_TAGMSG ? CAP_STAG : NOCAPS, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, msgtype == MESSAGE_TYPE_TAGMSG ? ":%s %s %s@%s" : ":%s %s %s@%s :%s", get_id(source_p, target_p), cmdname[msgtype], nick, target_p->name, text);
/* ECHO doesn't work with special syntax, so generate a local echo instead */ if (MyClient(source_p) && IsClientCapable(source_p, CLICAP_ECHO_MESSAGE)) { const char *fmt = msgtype == MESSAGE_TYPE_TAGMSG ? ":%s!%s@%s %s %s@%s" : ":%s!%s@%s %s %s@%s :%s";
sendto_one_tags(source_p, NOCAPS, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, fmt, source_p->name, source_p->username, source_p->host, cmdname[msgtype], nick, target_p->name, text); }}
static voidmsg_mass(enum message_type msgtype, struct Client *client_p, struct Client *source_p, const char *mask, const char *text, struct MsgBuf *msgbuf_p){ uint64_t cli_cap = msgtype == MESSAGE_TYPE_TAGMSG ? CLICAP_MESSAGE_TAGS : NOCAPS; uint64_t serv_cap = msgtype == MESSAGE_TYPE_TAGMSG ? CAP_STAG : NOCAPS;
/* skip past initial '$' */ mask++;
begin_local_response_batch();
if (MyClient(source_p)) { /* tag data could easily exceed max IRC message length, so including the tags in the snote * text isn't really workable. Sending a mass-tagmsg in itself is already pretty questionable, * but the spec allows for it. */ sendto_realops_snomask(SNO_GENERAL, L_ALL | L_NETWIDE, msgtype == MESSAGE_TYPE_TAGMSG ? "%s sent mass-%s to %s" : "%s sent mass-%s to %s: %s", get_oper_name(source_p), cmdname_lower[msgtype], mask, text); }
/* suppress labeled-response on the message (it might be going to themselves) */ struct ResponseInfo *info = suspend_response_batch();
sendto_match_butone_tags(IsServer(client_p) ? client_p : NULL, source_p, mask + 1, (*mask == '#') ? MATCH_HOST : MATCH_SERVER, cli_cap, NOCAPS, serv_cap, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, msgtype == MESSAGE_TYPE_TAGMSG ? "%s $%s" : "%s $%s :%s", cmdname[msgtype], mask, text);
if (msgtype == MESSAGE_TYPE_PRIVMSG && *text == '\001') source_p->large_ctcp_sent = rb_current_time();
resume_response_batch(info);
/* ECHO doesn't work with special syntax, so generate a local echo instead */ if (MyClient(source_p) && IsClientCapable(source_p, CLICAP_ECHO_MESSAGE)) { const char *fmt = msgtype == MESSAGE_TYPE_TAGMSG ? ":%s!%s@%s %s %s" : ":%s!%s@%s %s %s :%s";
sendto_one_tags(source_p, NOCAPS, NOCAPS, msgbuf_p->n_tags, msgbuf_p->tags, fmt, source_p->name, source_p->username, source_p->host, cmdname[msgtype], mask, text); }}
/* * flood_attack_client * inputs - flag 0 if PRIVMSG 1 if NOTICE. RFC * says NOTICE must not auto reply * - pointer to source Client * - pointer to target Client * output - true if target is under flood attack * side effects - check for flood attack on target target_p */static boolflood_attack_client(enum message_type msgtype, struct Client *source_p, struct Client *target_p){ int delta;
/* Services could get many messages legitimately and * can be messaged without rate limiting via aliases * and msg user@server. * -- jilles */ if(GlobalSetOptions.floodcount && IsClient(source_p) && source_p != target_p && !IsService(target_p) && !HasPrivilege(target_p, "oper:free_target")) { if((target_p->first_received_message_time + 1) < rb_current_time()) { delta = rb_current_time() - target_p->first_received_message_time; target_p->received_number_of_privmsgs -= delta; target_p->first_received_message_time = rb_current_time(); if(target_p->received_number_of_privmsgs <= 0) { target_p->received_number_of_privmsgs = 0; target_p->flood_noticed = 0; } }
if((target_p->received_number_of_privmsgs >= GlobalSetOptions.floodcount) || target_p->flood_noticed) { if(target_p->flood_noticed == 0) { sendto_realops_snomask(SNO_BOTS, L_NETWIDE, "Possible Flooder %s[%s@%s] on %s target: %s", source_p->name, source_p->username, source_p->orighost, source_p->servptr->name, target_p->name); target_p->flood_noticed = 1; /* add a bit of penalty */ target_p->received_number_of_privmsgs += 2; } if(MyClient(source_p) && (msgtype == MESSAGE_TYPE_PRIVMSG)) sendto_one(source_p, ":%s NOTICE %s :*** Message to %s throttled due to flooding", me.name, source_p->name, target_p->name); return true; } else target_p->received_number_of_privmsgs++; }
return false;}