*
* $Id$
*/
+#include "config.h"
+
#include "send.h"
#include "channel.h"
#include "class.h"
#include "match.h"
#include "msg.h"
#include "numnicks.h"
+#include "parse.h"
#include "s_bsd.h"
#include "s_debug.h"
#include "s_misc.h"
#include "s_user.h"
-#include "sprintf_irc.h"
#include "struct.h"
#include "sys.h"
static int sentalong_marker;
struct SLink *opsarray[32]; /* don't use highest bit unless you change
atoi to strtoul in sendto_op_mask() */
+static struct Connection *send_queues = 0;
+
/*
* dead_link
*
static void dead_link(struct Client *to, char *notice)
{
- to->flags |= FLAGS_DEADSOCKET;
+ cli_flags(to) |= FLAGS_DEADSOCKET;
/*
* If because of BUFFERPOOL problem then clean dbuf's now so that
* notices don't hurt operators below.
*/
- DBufClear(&to->recvQ);
- MsgQClear(&to->sendQ);
+ DBufClear(&(cli_recvQ(to)));
+ MsgQClear(&(cli_sendQ(to)));
+ client_drop_sendq(cli_connect(to));
/*
* Keep a copy of the last comment, for later use...
*/
- ircd_strncpy(to->info, notice, REALLEN);
+ ircd_strncpy(cli_info(to), notice, REALLEN);
- if (!IsUser(to) && !IsUnknown(to) && !(to->flags & FLAGS_CLOSING))
- sendto_opmask_butone(0, SNO_OLDSNO, "%s for %s", to->info, to->name);
- Debug((DEBUG_ERROR, to->info));
+ if (!IsUser(to) && !IsUnknown(to) && !(cli_flags(to) & FLAGS_CLOSING))
+ sendto_opmask_butone(0, SNO_OLDSNO, "%s for %s", cli_info(to), cli_name(to));
+ Debug((DEBUG_ERROR, cli_info(to)));
}
static int can_send(struct Client* to)
{
assert(0 != to);
- return (IsDead(to) || IsMe(to) || -1 == to->fd) ? 0 : 1;
+ return (IsDead(to) || IsMe(to) || -1 == cli_fd(to)) ? 0 : 1;
}
/*
send_queued(cptr);
}
else {
- int i;
- for (i = HighestFd; i >= 0; i--) {
- if ((cptr = LocalClientArray[i]))
- send_queued(cptr);
+ struct Connection* con;
+ for (con = send_queues; con; con = con_next(con)) {
+ assert(0 < MsgQLength(&(con_sendQ(con))));
+ send_queued(con_client(con));
}
}
}
-/*
- * flush_sendq_except - run through local client array and flush
- * the sendq for each client, if the address of the client sendq
- * is the same as the one specified, it is skipped. This is used
- * by dbuf_put to try to get some more memory before bailing and
- * causing the client to be disconnected.
- */
-void flush_sendq_except(void)
-{
- int i;
- struct Client* cptr;
- for (i = HighestFd; i >= 0; i--) {
- if ( (cptr = LocalClientArray[i]))
- send_queued(cptr);
- }
-}
-
/*
* send_queued
*
void send_queued(struct Client *to)
{
assert(0 != to);
- assert(0 != to->local);
+ assert(0 != cli_local(to));
if (IsBlocked(to) || !can_send(to))
return; /* Don't bother */
- while (MsgQLength(&to->sendQ) > 0) {
+ while (MsgQLength(&(cli_sendQ(to))) > 0) {
unsigned int len;
- if ((len = deliver_it(to, &to->sendQ))) {
- msgq_delete(&to->sendQ, len);
- to->lastsq = MsgQLength(&to->sendQ) / 1024;
- if (IsBlocked(to))
- break;
+ if ((len = deliver_it(to, &(cli_sendQ(to))))) {
+ msgq_delete(&(cli_sendQ(to)), len);
+ cli_lastsq(to) = MsgQLength(&(cli_sendQ(to))) / 1024;
+ if (IsBlocked(to)) {
+ update_write(to);
+ return;
+ }
}
else {
if (IsDead(to)) {
char tmp[512];
- sprintf(tmp,"Write error: %s",(strerror(to->error)) ? (strerror(to->error)) : "Unknown error" );
+ sprintf(tmp,"Write error: %s",(strerror(cli_error(to))) ? (strerror(cli_error(to))) : "Unknown error" );
dead_link(to, tmp);
}
- break;
+ return;
}
}
+
+ /* Ok, sendq is now empty... */
+ client_drop_sendq(cli_connect(to));
+ update_write(to);
}
void send_buffer(struct Client* to, struct MsgBuf* buf, int prio)
assert(0 != to);
assert(0 != buf);
- if (to->from)
- to = to->from;
+ if (cli_from(to))
+ to = cli_from(to);
if (!can_send(to))
/*
*/
return;
- if (MsgQLength(&to->sendQ) > get_sendq(to)) {
+ if (MsgQLength(&(cli_sendQ(to))) > get_sendq(to)) {
if (IsServer(to))
sendto_opmask_butone(0, SNO_OLDSNO, "Max SendQ limit exceeded for %C: "
- "%zu > %zu", to, MsgQLength(&to->sendQ),
+ "%zu > %zu", to, MsgQLength(&(cli_sendQ(to))),
get_sendq(to));
dead_link(to, "Max sendQ exceeded");
return;
}
- Debug((DEBUG_SEND, "Sending [%p] to %s", buf, to->name));
+ Debug((DEBUG_SEND, "Sending [%p] to %s", buf, cli_name(to)));
- msgq_add(&to->sendQ, buf, prio);
+ msgq_add(&(cli_sendQ(to)), buf, prio);
+ client_add_sendq(cli_connect(to), &send_queues);
+ update_write(to);
/*
* Update statistics. The following is slightly incorrect
* because it counts messages even if queued, but bytes
* only really sent. Queued bytes get updated in SendQueued.
*/
- ++to->sendM;
- ++me.sendM;
+ ++(cli_sendM(to));
+ ++(cli_sendM(&me));
/*
* This little bit is to stop the sendQ from growing too large when
* there is no need for it to. Thus we call send_queued() every time
* trying to flood that link with data (possible during the net
* relinking done by servers with a large load).
*/
- if (MsgQLength(&to->sendQ) / 1024 > to->lastsq)
+ if (MsgQLength(&(cli_sendQ(to))) / 1024 > cli_lastsq(to))
send_queued(to);
}
switch (what)
{
case MATCH_HOST:
- return (match(mask, one->user->host) == 0);
+ return (match(mask, cli_user(one)->host) == 0);
case MATCH_SERVER:
default:
- return (match(mask, one->user->server->name) == 0);
+ return (match(mask, cli_name(cli_user(one)->server)) == 0);
}
}
void sendcmdto_one(struct Client *from, const char *cmd, const char *tok,
struct Client *to, const char *pattern, ...)
{
- va_list vl;
+ struct VarData vd;
+ struct MsgBuf *mb;
- va_start(vl, pattern);
- vsendcmdto_one(from, cmd, tok, to, pattern, vl);
- va_end(vl);
+ to = cli_from(to);
+
+ vd.vd_format = pattern; /* set up the struct VarData for %v */
+ va_start(vd.vd_args, pattern);
+
+ mb = msgq_make(to, "%:#C %s %v", from, IsServer(to) || IsMe(to) ? tok : cmd,
+ &vd);
+
+ va_end(vd.vd_args);
+
+ send_buffer(to, mb, 0);
+
+ msgq_clean(mb);
}
-void vsendcmdto_one(struct Client *from, const char *cmd, const char *tok,
- struct Client *to, const char *pattern, va_list vl)
+/*
+ * Send a (prefixed) command to a single client in the priority queue;
+ * select which of <cmd> <tok> to use depending on if to is a server
+ *or not. <from> is the originator of the command.
+ */
+void sendcmdto_prio_one(struct Client *from, const char *cmd, const char *tok,
+ struct Client *to, const char *pattern, ...)
{
struct VarData vd;
struct MsgBuf *mb;
- to = to->from;
+ to = cli_from(to);
vd.vd_format = pattern; /* set up the struct VarData for %v */
- vd.vd_args = vl;
+ va_start(vd.vd_args, pattern);
mb = msgq_make(to, "%:#C %s %v", from, IsServer(to) || IsMe(to) ? tok : cmd,
&vd);
- send_buffer(to, mb, 0);
+ va_end(vd.vd_args);
+
+ send_buffer(to, mb, 1);
msgq_clean(mb);
}
va_end(vd.vd_args);
/* send it to our downlinks */
- for (lp = me.serv->down; lp; lp = lp->next) {
- if (one && lp->value.cptr == one->from)
+ for (lp = cli_serv(&me)->down; lp; lp = lp->next) {
+ if (one && lp->value.cptr == cli_from(one))
continue;
send_buffer(lp->value.cptr, mb, 0);
}
struct Membership *member;
assert(0 != from);
- assert(0 != from->from);
+ assert(0 != cli_from(from));
assert(0 != pattern);
assert(!IsServer(from) && !IsMe(from));
va_end(vd.vd_args);
sentalong_marker++;
- if (-1 < from->from->fd)
- sentalong[from->from->fd] = sentalong_marker;
+ if (-1 < cli_fd(cli_from(from)))
+ sentalong[cli_fd(cli_from(from))] = sentalong_marker;
/*
* loop through from's channels, and the members on their channels
*/
- for (chan = from->user->channel; chan; chan = chan->next_channel)
+ for (chan = cli_user(from)->channel; chan; chan = chan->next_channel)
for (member = chan->channel->members; member;
member = member->next_member)
- if (MyConnect(member->user) && -1 < member->user->from->fd &&
- sentalong[member->user->from->fd] != sentalong_marker) {
- sentalong[member->user->from->fd] = sentalong_marker;
+ if (MyConnect(member->user) && -1 < cli_fd(cli_from(member->user)) &&
+ sentalong[cli_fd(cli_from(member->user))] != sentalong_marker) {
+ sentalong[cli_fd(cli_from(member->user))] = sentalong_marker;
send_buffer(member->user, mb, 0);
}
sentalong_marker++;
for (member = to->members; member; member = member->next_member) {
/* skip one, zombies, and deaf users... */
- if (member->user->from == one || IsZombie(member) ||
+ if (cli_from(member->user) == one || IsZombie(member) ||
(skip & SKIP_DEAF && IsDeaf(member->user)) ||
(skip & SKIP_NONOPS && !IsChanOp(member)) ||
- (skip & SKIP_BURST && IsBurstOrBurstAck(member->user->from)) ||
- member->user->from->fd < 0 ||
- sentalong[member->user->from->fd] == sentalong_marker)
+ (skip & SKIP_BURST && IsBurstOrBurstAck(cli_from(member->user))) ||
+ cli_fd(cli_from(member->user)) < 0 ||
+ sentalong[cli_fd(cli_from(member->user))] == sentalong_marker)
continue;
- sentalong[member->user->from->fd] = sentalong_marker;
+ sentalong[cli_fd(cli_from(member->user))] = sentalong_marker;
if (MyConnect(member->user)) /* pick right buffer to send */
send_buffer(member->user, user_mb, 0);
* Send a (prefixed) command to all users except <one> that have
* <flag> set.
*/
-/* XXX sentalong_marker used XXX
- *
- * Again, we can solve this use of sentalong_marker by adding a field
- * to connections--a count of the number of +w users, and another count
- * of +g users. Then, just walk through the local clients to send
- * those messages, and another walk through the connected servers list,
- * sending only if there's a non-zero count. No caveats here, either,
- * beyond remembering to decrement the count when a user /quit's or is
- * killed, or a server is squit. -Kev
- */
-void sendcmdto_flag_butone(struct Client *from, const char *cmd,
- const char *tok, struct Client *one,
- unsigned int flag, const char *pattern, ...)
+void sendwallto_group_butone(struct Client *from, int type, struct Client *one,
+ const char *pattern, ...)
{
struct VarData vd;
struct Client *cptr;
- struct MsgBuf *user_mb;
- struct MsgBuf *serv_mb;
+ struct MsgBuf *mb;
+ struct DLink *lp;
+ char *prefix=NULL;
+ char *tok=NULL;
+ int i;
vd.vd_format = pattern;
/* Build buffer to send to users */
va_start(vd.vd_args, pattern);
- user_mb = msgq_make(0, "%:#C " MSG_WALLOPS " %v", from, &vd);
+ switch (type) {
+ case WALL_DESYNCH:
+ prefix="";
+ tok=TOK_DESYNCH;
+ break;
+ case WALL_WALLOPS:
+ prefix="* ";
+ tok=TOK_WALLOPS;
+ break;
+ case WALL_WALLUSERS:
+ prefix="$ ";
+ tok=TOK_WALLUSERS;
+ break;
+ default:
+ assert(0);
+ }
+ mb = msgq_make(0, "%:#C " MSG_WALLOPS " :%s%v", from, prefix,&vd);
va_end(vd.vd_args);
+ /* send buffer along! */
+ for (i = 0; i <= HighestFd; i++) {
+ if (!(cptr = LocalClientArray[i])
+ || (cli_fd(cli_from(cptr)) < 0)
+ || (type==WALL_DESYNCH && (cli_flags(cptr)&FLAGS_DEBUG==0))
+ || (type==WALL_WALLOPS && (cli_flags(cptr)&FLAGS_WALLOP==0))
+ || (type==WALL_WALLUSERS && (cli_flags(cptr)&FLAGS_WALLOP==0)))
+ continue; /* skip it */
+ send_buffer(cptr, mb, 1);
+ }
+
+ msgq_clean(mb);
+
/* Build buffer to send to servers */
va_start(vd.vd_args, pattern);
- serv_mb = msgq_make(&me, "%C %s %v", from, tok, &vd);
+ mb = msgq_make(&me, "%C %s :%v", from, tok, &vd);
va_end(vd.vd_args);
/* send buffer along! */
- sentalong_marker++;
- for (cptr = GlobalClientList; cptr; cptr = cptr->next) {
- if (cptr->from == one || IsServer(cptr) || !(cptr->flags & flag) ||
- cptr->from->fd < 0 || sentalong[cptr->from->fd] == sentalong_marker)
- continue; /* skip it */
- sentalong[cptr->from->fd] = sentalong_marker;
-
- if (MyConnect(cptr)) /* send right buffer */
- send_buffer(cptr, user_mb, 1);
- else
- send_buffer(cptr, serv_mb, 1);
+ for (lp = cli_serv(&me)->down; lp; lp = lp->next) {
+ if (one && lp->value.cptr == cli_from(one))
+ continue;
+ send_buffer(lp->value.cptr, mb, 1);
}
- msgq_clean(user_mb);
- msgq_clean(serv_mb);
+ msgq_clean(mb);
}
/*
/* send buffer along */
sentalong_marker++;
- for (cptr = GlobalClientList; cptr; cptr = cptr->next) {
- if (cptr->from == one || IsServer(cptr) || IsMe(cptr) ||
- !match_it(cptr, to, who) || cptr->from->fd < 0 ||
- sentalong[cptr->from->fd] == sentalong_marker)
+ for (cptr = GlobalClientList; cptr; cptr = cli_next(cptr)) {
+ if (!IsRegistered(cptr) || cli_from(cptr) == one || IsServer(cptr) ||
+ IsMe(cptr) || !match_it(cptr, to, who) || cli_fd(cli_from(cptr)) < 0 ||
+ sentalong[cli_fd(cli_from(cptr))] == sentalong_marker)
continue; /* skip it */
- sentalong[cptr->from->fd] = sentalong_marker;
+ sentalong[cli_fd(cli_from(cptr))] = sentalong_marker;
if (MyConnect(cptr)) /* send right buffer */
send_buffer(cptr, user_mb, 0);
va_end(vl);
}
+/*
+ * Send a server notice to all users subscribing to the indicated <mask>
+ * except for <one> - Ratelimited 1 / 30sec
+ */
+void sendto_opmask_butone_ratelimited(struct Client *one, unsigned int mask,
+ time_t *rate, const char *pattern, ...)
+{
+ va_list vl;
+
+ if ((CurrentTime - *rate) < 30)
+ return;
+ else
+ *rate = CurrentTime;
+
+ va_start(vl, pattern);
+ vsendto_opmask_butone(one, mask, pattern, vl);
+ va_end(vl);
+
+}
+
+
/*
* Same as above, except called with a variable argument list
*/
*/
vd.vd_format = pattern;
vd.vd_args = vl;
- mb = msgq_make(0, ":%s " MSG_NOTICE " * :*** Notice -- %v", me.name, &vd);
+ mb = msgq_make(0, ":%s " MSG_NOTICE " * :*** Notice -- %v", cli_name(&me),
+ &vd);
for (; opslist; opslist = opslist->next)
send_buffer(opslist->value.cptr, mb, 0);
projects / ircu2.10.12-pk.git / blobdiff