/[svn]/ircd-hybrid-7.2/src/send.c
ViewVC logotype

Contents of /ircd-hybrid-7.2/src/send.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 189 - (show annotations)
Sun Oct 23 21:35:38 2005 UTC (14 years, 1 month ago) by db
File MIME type: text/x-chdr
File size: 34092 byte(s)
- backported fix from HEAD done by Michael
- Fixed bug in sendto_channel_remote() that would cause
  multiple copies of the same message to be sent to the
  uplinked server.


1 /*
2 * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 * send.c: Functions for sending messages.
4 *
5 * Copyright (C) 2002 by the past and present ircd coders, and others.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 * USA
21 *
22 * $Id$
23 */
24
25 #include "stdinc.h"
26 #include "tools.h"
27 #include "send.h"
28 #include "channel.h"
29 #include "client.h"
30 #include "common.h"
31 #include "dbuf.h"
32 #include "irc_string.h"
33 #include "ircd.h"
34 #include "handlers.h"
35 #include "numeric.h"
36 #include "fdlist.h"
37 #include "s_bsd.h"
38 #include "s_serv.h"
39 #include "sprintf_irc.h"
40 #include "s_conf.h"
41 #include "list.h"
42 #include "s_log.h"
43 #include "memory.h"
44 #include "hook.h"
45 #include "irc_getnameinfo.h"
46 #include "packet.h"
47
48 #define LOG_BUFSIZE 2048
49
50 struct Callback *iosend_cb = NULL;
51 struct Callback *iosendctrl_cb = NULL;
52
53 static void send_message(struct Client *, char *, int);
54 static void send_message_remote(struct Client *, struct Client *, char *, int);
55
56 static unsigned long current_serial = 0L;
57
58 /* send_format()
59 *
60 * inputs - buffer to format into
61 * - size of the buffer
62 * - format pattern to use
63 * - var args
64 * output - number of bytes formatted output
65 * side effects - modifies sendbuf
66 */
67 static inline int
68 send_format(char *lsendbuf, int bufsize, const char *pattern, va_list args)
69 {
70 int len;
71
72 /*
73 * from rfc1459
74 *
75 * IRC messages are always lines of characters terminated with a CR-LF
76 * (Carriage Return - Line Feed) pair, and these messages shall not
77 * exceed 512 characters in length, counting all characters
78 * including the trailing CR-LF.
79 * Thus, there are 510 characters maximum allowed
80 * for the command and its parameters. There is no provision for
81 * continuation message lines. See section 7 for more details about
82 * current implementations.
83 */
84 len = vsnprintf(lsendbuf, bufsize - 1, pattern, args);
85 if (len > bufsize - 2)
86 len = bufsize - 2; /* required by some versions of vsnprintf */
87
88 lsendbuf[len++] = '\r';
89 lsendbuf[len++] = '\n';
90 return (len);
91 }
92
93 /*
94 * iosend_default - append a packet to the client's sendq.
95 */
96 void *
97 iosend_default(va_list args)
98 {
99 struct Client *to = va_arg(args, struct Client *);
100 int length = va_arg(args, int);
101 char *buf = va_arg(args, char *);
102
103 dbuf_put(&to->localClient->buf_sendq, buf, length);
104 return NULL;
105 }
106
107 /*
108 ** send_message
109 ** Internal utility which appends given buffer to the sockets
110 ** sendq.
111 */
112 static void
113 send_message(struct Client *to, char *buf, int len)
114 {
115 #ifdef INVARIANTS
116 if (IsMe(to))
117 {
118 sendto_realops_flags(UMODE_ALL, L_ALL,
119 "Trying to send message to myself!");
120 return;
121 }
122 #endif
123
124 if (dbuf_length(&to->localClient->buf_sendq) + len > get_sendq(to))
125 {
126 if (IsServer(to))
127 sendto_realops_flags(UMODE_ALL, L_ALL,
128 "Max SendQ limit exceeded for %s: %lu > %lu",
129 get_client_name(to, HIDE_IP),
130 (unsigned long)(dbuf_length(&to->localClient->buf_sendq) + len),
131 get_sendq(to));
132 if (IsClient(to))
133 SetSendQExceeded(to);
134 dead_link_on_write(to, 0);
135 return;
136 }
137
138 execute_callback(iosend_cb, to, len, buf);
139
140 /*
141 ** Update statistics. The following is slightly incorrect
142 ** because it counts messages even if queued, but bytes
143 ** only really sent. Queued bytes get updated in SendQueued.
144 */
145 ++to->localClient->send.messages;
146 ++me.localClient->send.messages;
147
148 if (dbuf_length(&to->localClient->buf_sendq) >
149 (IsServer(to) ? (unsigned int) 1024 : (unsigned int) 4096))
150 send_queued_write(to);
151 }
152
153 /* send_message_remote()
154 *
155 * inputs - pointer to client from message is being sent
156 * - pointer to client to send to
157 * - pointer to preformatted buffer
158 * - length of input buffer
159 * output - none
160 * side effects - Despite the function name, this only sends to directly
161 * connected clients.
162 *
163 */
164 static void
165 send_message_remote(struct Client *to, struct Client *from,
166 char *buf, int len)
167 {
168 if (!MyConnect(to))
169 {
170 sendto_realops_flags(UMODE_ALL, L_ALL,
171 "server send message to %s [%s] dropped from %s(Not local server)",
172 to->name, to->from->name, from->name);
173 return;
174 }
175
176 if (ServerInfo.hub && IsCapable(to, CAP_LL))
177 {
178 if (((from->lazyLinkClientExists &
179 to->localClient->serverMask) == 0))
180 client_burst_if_needed(to, from);
181 }
182
183 /* Optimize by checking if (from && to) before everything */
184 /* we set to->from up there.. */
185
186 if (!MyClient(from) && IsClient(to) && (to == from->from))
187 {
188 if (IsServer(from))
189 {
190 sendto_realops_flags(UMODE_ALL, L_ALL,
191 "Send message to %s [%s] dropped from %s(Fake Dir)",
192 to->name, to->from->name, from->name);
193 return;
194 }
195
196 sendto_realops_flags(UMODE_ALL, L_ALL,
197 "Ghosted: %s[%s@%s] from %s[%s@%s] (%s)",
198 to->name, to->username, to->host,
199 from->name, from->username, from->host,
200 to->from->name);
201
202 sendto_server(NULL, to, NULL, CAP_TS6, NOCAPS, NOFLAGS,
203 ":%s KILL %s :%s (%s[%s@%s] Ghosted %s)",
204 me.id, to->name, me.name, to->name,
205 to->username, to->host, to->from->name);
206 sendto_server(NULL, to, NULL, NOCAPS, CAP_TS6, NOFLAGS,
207 ":%s KILL %s :%s (%s[%s@%s] Ghosted %s)",
208 me.name, to->name, me.name, to->name,
209 to->username, to->host, to->from->name);
210
211 SetKilled(to);
212
213 if (IsClient(from))
214 sendto_one(from, form_str(ERR_GHOSTEDCLIENT),
215 me.name, from->name, to->name, to->username,
216 to->host, to->from);
217
218 exit_client(to, &me, "Ghosted client");
219
220 return;
221 }
222
223 send_message(to, buf, len);
224 }
225
226 /*
227 ** sendq_unblocked
228 ** Called when a socket is ready for writing.
229 */
230 void
231 sendq_unblocked(fde_t *fd, struct Client *client_p)
232 {
233 ClearSendqBlocked(client_p);
234 /* let send_queued_write be executed by send_queued_all */
235
236 #ifdef HAVE_LIBCRYPTO
237 if (fd->flags.pending_read)
238 {
239 fd->flags.pending_read = 0;
240 read_packet(fd, client_p);
241 }
242 #endif
243 }
244
245 /*
246 ** slinkq_unblocked
247 ** Called when a server control socket is ready for writing.
248 */
249 static void
250 slinkq_unblocked(fde_t *fd, struct Client *client_p)
251 {
252 ClearSlinkqBlocked(client_p);
253 send_queued_slink_write(client_p);
254 }
255
256 /*
257 ** send_queued_write
258 ** This is called when there is a chance that some output would
259 ** be possible. This attempts to empty the send queue as far as
260 ** possible, and then if any data is left, a write is rescheduled.
261 */
262 void
263 send_queued_write(struct Client *to)
264 {
265 int retlen;
266 struct dbuf_block *first;
267
268 /*
269 ** Once socket is marked dead, we cannot start writing to it,
270 ** even if the error is removed...
271 */
272 if (IsDead(to) || IsSendqBlocked(to))
273 return; /* no use calling send() now */
274
275 /* Next, lets try to write some data */
276
277 if (dbuf_length(&to->localClient->buf_sendq))
278 {
279 do {
280 first = to->localClient->buf_sendq.blocks.head->data;
281
282 #ifdef HAVE_LIBCRYPTO
283 if (to->localClient->fd.ssl)
284 {
285 retlen = SSL_write(to->localClient->fd.ssl, first->data, first->size);
286
287 /* translate openssl error codes, sigh */
288 if (retlen < 0)
289 switch (SSL_get_error(to->localClient->fd.ssl, retlen))
290 {
291 case SSL_ERROR_WANT_READ:
292 return; /* retry later, don't register for write events */
293
294 case SSL_ERROR_WANT_WRITE:
295 errno = EWOULDBLOCK;
296 case SSL_ERROR_SYSCALL:
297 break;
298
299 default:
300 retlen = errno = 0; /* either an SSL-specific error or EOF */
301 }
302 }
303 else
304 #endif
305 retlen = send(to->localClient->fd.fd, first->data, first->size, 0);
306
307 if (retlen <= 0)
308 {
309 #ifdef _WIN32
310 errno = WSAGetLastError();
311 #endif
312 break;
313 }
314
315 dbuf_delete(&to->localClient->buf_sendq, retlen);
316
317 /* We have some data written .. update counters */
318 to->localClient->send.bytes += retlen;
319 me.localClient->send.bytes += retlen;
320 } while (dbuf_length(&to->localClient->buf_sendq));
321
322 if ((retlen < 0) && (ignoreErrno(errno)))
323 {
324 /* we have a non-fatal error, reschedule a write */
325 SetSendqBlocked(to);
326 comm_setselect(&to->localClient->fd, COMM_SELECT_WRITE,
327 (PF *)sendq_unblocked, (void *)to, 0);
328 }
329 else if (retlen <= 0)
330 {
331 dead_link_on_write(to, errno);
332 return;
333 }
334 }
335 }
336
337 /*
338 ** send_queued_slink_write
339 ** This is called when there is a chance the some output would
340 ** be possible. This attempts to empty the send queue as far as
341 ** possible, and then if any data is left, a write is rescheduled.
342 */
343 void
344 send_queued_slink_write(struct Client *to)
345 {
346 int retlen;
347
348 /*
349 ** Once socket is marked dead, we cannot start writing to it,
350 ** even if the error is removed...
351 */
352 if (IsDead(to) || IsSlinkqBlocked(to))
353 return; /* no use calling send() now */
354
355 /* Next, lets try to write some data */
356 if (to->localClient->slinkq != NULL)
357 {
358 retlen = send(to->localClient->ctrlfd.fd,
359 to->localClient->slinkq + to->localClient->slinkq_ofs,
360 to->localClient->slinkq_len, 0);
361 if (retlen < 0)
362 {
363 /* If we have a fatal error */
364 if (!ignoreErrno(errno))
365 {
366 dead_link_on_write(to, errno);
367 return;
368 }
369 }
370 else if (retlen == 0)
371 {
372 /* 0 bytes is an EOF .. */
373 dead_link_on_write(to, 0);
374 return;
375 }
376 else
377 {
378 execute_callback(iosendctrl_cb, to, retlen,
379 to->localClient->slinkq + to->localClient->slinkq_ofs);
380 to->localClient->slinkq_len -= retlen;
381
382 assert(to->localClient->slinkq_len >= 0);
383 if (to->localClient->slinkq_len)
384 to->localClient->slinkq_ofs += retlen;
385 else
386 {
387 to->localClient->slinkq_ofs = 0;
388 MyFree(to->localClient->slinkq);
389 to->localClient->slinkq = NULL;
390 }
391 }
392
393 /* Finally, if we have any more data, reschedule a write */
394 if (to->localClient->slinkq_len)
395 {
396 SetSlinkqBlocked(to);
397 comm_setselect(&to->localClient->ctrlfd, COMM_SELECT_WRITE,
398 (PF *)slinkq_unblocked, (void *)to, 0);
399 }
400 }
401 }
402
403 /* send_queued_all()
404 *
405 * input - NONE
406 * output - NONE
407 * side effects - try to flush sendq of each client
408 */
409 void
410 send_queued_all(void)
411 {
412 dlink_node *ptr;
413
414 /* Servers are processed first, mainly because this can generate
415 * a notice to opers, which is to be delivered by this function.
416 */
417 DLINK_FOREACH(ptr, serv_list.head)
418 send_queued_write((struct Client *) ptr->data);
419
420 DLINK_FOREACH(ptr, unknown_list.head)
421 send_queued_write((struct Client *) ptr->data);
422
423 DLINK_FOREACH(ptr, local_client_list.head)
424 send_queued_write((struct Client *) ptr->data);
425
426 /* NOTE: This can still put clients on aborted_list; unfortunately,
427 * exit_aborted_clients takes precedence over send_queued_all,
428 * because exiting clients can generate server/oper traffic.
429 * The easiest approach is dealing with aborted clients in the next I/O lap.
430 * -adx
431 */
432 }
433
434 /* sendto_one()
435 *
436 * inputs - pointer to destination client
437 * - var args message
438 * output - NONE
439 * side effects - send message to single client
440 */
441 void
442 sendto_one(struct Client *to, const char *pattern, ...)
443 {
444 va_list args;
445 char buffer[IRCD_BUFSIZE];
446 int len;
447
448 if (to->from != NULL)
449 to = to->from;
450 if (IsDead(to))
451 return; /* This socket has already been marked as dead */
452
453 va_start(args, pattern);
454 len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
455 va_end(args);
456
457 send_message(to, buffer, len);
458 }
459
460 /* sendto_channel_butone()
461 *
462 * inputs - pointer to client(server) to NOT send message to
463 * - pointer to client that is sending this message
464 * - pointer to channel being sent to
465 * - vargs message
466 * output - NONE
467 * side effects - message as given is sent to given channel members.
468 *
469 * WARNING - +D clients are ignored
470 */
471 void
472 sendto_channel_butone(struct Client *one, struct Client *from,
473 struct Channel *chptr, const char *command,
474 const char *pattern, ...)
475 {
476 va_list args;
477 char local_buf[IRCD_BUFSIZE];
478 char remote_buf[IRCD_BUFSIZE];
479 char uid_buf[IRCD_BUFSIZE];
480 int local_len, remote_len, uid_len;
481 dlink_node *ptr;
482 dlink_node *ptr_next;
483 struct Client *target_p;
484
485 if (IsServer(from))
486 local_len = ircsprintf(local_buf, ":%s %s %s ",
487 from->name, command, chptr->chname);
488 else
489 local_len = ircsprintf(local_buf, ":%s!%s@%s %s %s ",
490 from->name, from->username, from->host,
491 command, chptr->chname);
492 remote_len = ircsprintf(remote_buf, ":%s %s %s ",
493 from->name, command, chptr->chname);
494 uid_len = ircsprintf(uid_buf, ":%s %s %s ",
495 ID(from), command, chptr->chname);
496
497 va_start(args, pattern);
498 local_len += send_format(&local_buf[local_len], IRCD_BUFSIZE - local_len,
499 pattern, args);
500 remote_len += send_format(&remote_buf[remote_len], IRCD_BUFSIZE - remote_len,
501 pattern, args);
502 uid_len += send_format(&uid_buf[uid_len], IRCD_BUFSIZE - uid_len, pattern,
503 args);
504 va_end(args);
505
506 ++current_serial;
507
508 DLINK_FOREACH_SAFE(ptr, ptr_next, chptr->members.head)
509 {
510 target_p = ((struct Membership *)ptr->data)->client_p;
511 assert(target_p != NULL);
512
513 if (IsDefunct(target_p) || IsDeaf(target_p) || target_p->from == one)
514 continue;
515
516 if (MyClient(target_p))
517 {
518 if (target_p->serial != current_serial)
519 {
520 send_message(target_p, local_buf, local_len);
521 target_p->serial = current_serial;
522 }
523 }
524 else
525 {
526 /* Now check whether a message has been sent to this
527 * remote link already
528 */
529 if (target_p->from->serial != current_serial)
530 {
531 if (IsCapable(target_p->from, CAP_TS6))
532 send_message_remote(target_p->from, from, uid_buf, uid_len);
533 else
534 send_message_remote(target_p->from, from, remote_buf, remote_len);
535 target_p->from->serial = current_serial;
536 }
537 }
538 }
539 }
540
541 /* sendto_server()
542 *
543 * inputs - pointer to client to NOT send to
544 * - pointer to source client required by LL (if any)
545 * - pointer to channel required by LL (if any)
546 * - caps or'd together which must ALL be present
547 * - caps or'd together which must ALL NOT be present
548 * - LL flags: LL_ICLIENT | LL_ICHAN
549 * - printf style format string
550 * - args to format string
551 * output - NONE
552 * side effects - Send a message to all connected servers, except the
553 * client 'one' (if non-NULL), as long as the servers
554 * support ALL capabs in 'caps', and NO capabs in 'nocaps'.
555 * If the server is a lazylink client, then it must know
556 * about source_p if non-NULL (unless LL_ICLIENT is specified,
557 * when source_p will be introduced where required) and
558 * chptr if non-NULL (unless LL_ICHANNEL is specified, when
559 * chptr will be introduced where required).
560 * Note: nothing will be introduced to a LazyLeaf unless
561 * the message is actually sent.
562 *
563 * This function was written in an attempt to merge together the other
564 * billion sendto_*serv*() functions, which sprung up with capabs,
565 * lazylinks, uids, etc.
566 * -davidt
567 */
568 void
569 sendto_server(struct Client *one, struct Client *source_p,
570 struct Channel *chptr, unsigned long caps,
571 unsigned long nocaps, unsigned long llflags,
572 const char *format, ...)
573 {
574 va_list args;
575 struct Client *client_p;
576 dlink_node *ptr;
577 char buffer[IRCD_BUFSIZE];
578 int len;
579
580 if (chptr != NULL)
581 {
582 if (chptr->chname[0] != '#')
583 return;
584 }
585
586 va_start(args, format);
587 len = send_format(buffer, IRCD_BUFSIZE, format, args);
588 va_end(args);
589
590 DLINK_FOREACH(ptr, serv_list.head)
591 {
592 client_p = ptr->data;
593
594 /* If dead already skip */
595 if (IsDead(client_p))
596 continue;
597 /* check against 'one' */
598 if (one != NULL && (client_p == one->from))
599 continue;
600 /* check we have required capabs */
601 if ((client_p->localClient->caps & caps) != caps)
602 continue;
603 /* check we don't have any forbidden capabs */
604 if ((client_p->localClient->caps & nocaps) != 0)
605 continue;
606
607 if (ServerInfo.hub && IsCapable(client_p, CAP_LL))
608 {
609 /* check LL channel */
610 if (chptr != NULL &&
611 ((chptr->lazyLinkChannelExists &
612 client_p->localClient->serverMask) == 0))
613 {
614 /* Only introduce the channel if we really will send this message */
615 if (!(llflags & LL_ICLIENT) && source_p &&
616 ((source_p->lazyLinkClientExists &
617 client_p->localClient->serverMask) == 0))
618 continue; /* we can't introduce the unknown source_p, skip */
619
620 if (llflags & LL_ICHAN)
621 burst_channel(client_p, chptr);
622 else
623 continue; /* we can't introduce the unknown chptr, skip */
624 }
625 /* check LL client */
626 if (source_p &&
627 ((source_p->lazyLinkClientExists &
628 client_p->localClient->serverMask) == 0))
629 {
630 if (llflags & LL_ICLIENT)
631 client_burst_if_needed(client_p,source_p);
632 else
633 continue; /* we can't introduce the unknown source_p, skip */
634 }
635 }
636 send_message(client_p, buffer, len);
637 }
638 }
639
640 /* sendto_common_channels_local()
641 *
642 * inputs - pointer to client
643 * - pattern to send
644 * output - NONE
645 * side effects - Sends a message to all people on local server who are
646 * in same channel with user.
647 * used by m_nick.c and exit_one_client.
648 */
649 void
650 sendto_common_channels_local(struct Client *user, int touser,
651 const char *pattern, ...)
652 {
653 va_list args;
654 dlink_node *uptr;
655 dlink_node *cptr;
656 struct Channel *chptr;
657 struct Membership *ms;
658 struct Client *target_p;
659 char buffer[IRCD_BUFSIZE];
660 int len;
661
662 va_start(args, pattern);
663 len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
664 va_end(args);
665
666 ++current_serial;
667
668 DLINK_FOREACH(cptr, user->channel.head)
669 {
670 chptr = ((struct Membership *) cptr->data)->chptr;
671 assert(chptr != NULL);
672
673 DLINK_FOREACH(uptr, chptr->locmembers.head)
674 {
675 ms = uptr->data;
676 target_p = ms->client_p;
677 assert(target_p != NULL);
678
679 if (target_p == user || IsDefunct(target_p) ||
680 target_p->serial == current_serial)
681 continue;
682
683 target_p->serial = current_serial;
684 send_message(target_p, buffer, len);
685 }
686 }
687
688 if (touser && MyConnect(user) && !IsDead(user) &&
689 user->serial != current_serial)
690 send_message(user, buffer, len);
691 }
692
693 /* sendto_channel_local()
694 *
695 * inputs - member status mask, e.g. CHFL_CHANOP | CHFL_VOICE
696 * - whether to ignore +D clients (YES/NO)
697 * - pointer to channel to send to
698 * - var args pattern
699 * output - NONE
700 * side effects - Send a message to all members of a channel that are
701 * locally connected to this server.
702 */
703 void
704 sendto_channel_local(int type, int nodeaf, struct Channel *chptr,
705 const char *pattern, ...)
706 {
707 va_list args;
708 char buffer[IRCD_BUFSIZE];
709 int len;
710 dlink_node *ptr;
711 struct Membership *ms;
712 struct Client *target_p;
713
714 va_start(args, pattern);
715 len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
716 va_end(args);
717
718 DLINK_FOREACH(ptr, chptr->locmembers.head)
719 {
720 ms = ptr->data;
721 target_p = ms->client_p;
722
723 if (type != 0 && (ms->flags & type) == 0)
724 continue;
725
726 if (IsDefunct(target_p) || (nodeaf && IsDeaf(target_p)))
727 continue;
728
729 send_message(target_p, buffer, len);
730 }
731 }
732
733 /* sendto_channel_local_butone()
734 *
735 * inputs - pointer to client to NOT send message to
736 * - member status mask, e.g. CHFL_CHANOP | CHFL_VOICE
737 * - pointer to channel to send to
738 * - var args pattern
739 * output - NONE
740 * side effects - Send a message to all members of a channel that are
741 * locally connected to this server except one.
742 *
743 * WARNING - +D clients are omitted
744 */
745 void
746 sendto_channel_local_butone(struct Client *one, int type,
747 struct Channel *chptr, const char *pattern, ...)
748 {
749 va_list args;
750 char buffer[IRCD_BUFSIZE];
751 int len;
752 struct Client *target_p;
753 struct Membership *ms;
754 dlink_node *ptr;
755
756 va_start(args, pattern);
757 len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
758 va_end(args);
759
760 DLINK_FOREACH(ptr, chptr->locmembers.head)
761 {
762 ms = ptr->data;
763 target_p = ms->client_p;
764
765 if (type != 0 && (ms->flags & type) == 0)
766 continue;
767
768 if (target_p == one || IsDefunct(target_p) || IsDeaf(target_p))
769 continue;
770 send_message(target_p, buffer, len);
771 }
772 }
773
774
775 /* sendto_channel_remote()
776 *
777 * inputs - Client not to send towards
778 * - Client from whom message is from
779 * - member status mask, e.g. CHFL_CHANOP | CHFL_VOICE
780 * - pointer to channel to send to
781 * - var args pattern
782 * output - NONE
783 * side effects - Send a message to all members of a channel that are
784 * remote to this server.
785 */
786 void
787 sendto_channel_remote(struct Client *one, struct Client *from, int type, int caps,
788 int nocaps, struct Channel *chptr, const char *pattern, ...)
789 {
790 va_list args;
791 char buffer[IRCD_BUFSIZE];
792 int len;
793 dlink_node *ptr;
794 struct Client *target_p;
795 struct Membership *ms;
796
797 va_start(args, pattern);
798 len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
799 va_end(args);
800
801 ++current_serial;
802
803 DLINK_FOREACH(ptr, chptr->members.head)
804 {
805 ms = ptr->data;
806 target_p = ms->client_p;
807
808 if (type != 0 && (ms->flags & type) == 0)
809 continue;
810
811 if (MyConnect(target_p))
812 continue;
813 target_p = target_p->from;
814
815 if (target_p == one->from ||
816 ((target_p->from->localClient->caps & caps) != caps) ||
817 ((target_p->from->localClient->caps & nocaps) != 0))
818 continue;
819 if (target_p->from->serial != current_serial)
820 {
821 send_message(target_p, buffer, len);
822 target_p->from->serial = current_serial;
823 }
824 }
825 }
826
827 /*
828 ** match_it() and sendto_match_butone() ARE only used
829 ** to send a msg to all ppl on servers/hosts that match a specified mask
830 ** (used for enhanced PRIVMSGs) for opers
831 **
832 ** addition -- Armin, 8jun90 (gruner@informatik.tu-muenchen.de)
833 **
834 */
835
836 /* match_it()
837 *
838 * inputs - client pointer to match on
839 * - actual mask to match
840 * - what to match on, HOST or SERVER
841 * output - 1 or 0 if match or not
842 * side effects - NONE
843 */
844 static int
845 match_it(const struct Client *one, const char *mask, int what)
846 {
847 if (what == MATCH_HOST)
848 return(match(mask, one->host));
849
850 return(match(mask, one->servptr->name));
851 }
852
853 /* sendto_match_butone()
854 *
855 * Send to all clients which match the mask in a way defined on 'what';
856 * either by user hostname or user servername.
857 *
858 * ugh. ONLY used by m_message.c to send an "oper magic" message. ugh.
859 */
860 void
861 sendto_match_butone(struct Client *one, struct Client *from, char *mask,
862 int what, const char *pattern, ...)
863 {
864 va_list args;
865 struct Client *client_p;
866 dlink_node *ptr, *ptr_next;
867 char local_buf[IRCD_BUFSIZE], remote_buf[IRCD_BUFSIZE];
868 int local_len = ircsprintf(local_buf, ":%s!%s@%s ", from->name,
869 from->username, from->host);
870 int remote_len = ircsprintf(remote_buf, ":%s ", from->name);
871
872 va_start(args, pattern);
873 local_len += send_format(&local_buf[local_len], IRCD_BUFSIZE - local_len,
874 pattern, args);
875 remote_len += send_format(&remote_buf[remote_len], IRCD_BUFSIZE - remote_len,
876 pattern, args);
877 va_end(args);
878
879 /* scan the local clients */
880 DLINK_FOREACH(ptr, local_client_list.head)
881 {
882 client_p = ptr->data;
883
884 if (client_p != one && !IsDefunct(client_p) &&
885 match_it(client_p, mask, what))
886 send_message(client_p, local_buf, local_len);
887 }
888
889 /* Now scan servers */
890 DLINK_FOREACH_SAFE(ptr, ptr_next, serv_list.head)
891 {
892 client_p = ptr->data;
893
894 /*
895 * The old code looped through every client on the
896 * network for each server to check if the
897 * server (client_p) has at least 1 client matching
898 * the mask, using something like:
899 *
900 * for (target_p = GlobalClientList; target_p; target_p = target_p->next)
901 * if (IsRegisteredUser(target_p) &&
902 * match_it(target_p, mask, what) &&
903 * (target_p->from == client_p))
904 * vsendto_prefix_one(client_p, from, pattern, args);
905 *
906 * That way, we wouldn't send the message to
907 * a server who didn't have a matching client.
908 * However, on a network such as EFNet, that
909 * code would have looped through about 50
910 * servers, and in each loop, loop through
911 * about 50k clients as well, calling match()
912 * in each nested loop. That is a very bad
913 * thing cpu wise - just send the message
914 * to every connected server and let that
915 * server deal with it.
916 * -wnder
917 */
918 if (client_p != one && !IsDefunct(client_p))
919 send_message_remote(client_p, from, remote_buf, remote_len);
920 }
921 }
922
923 /* sendto_match_servs()
924 *
925 * inputs - source client
926 * - mask to send to
927 * - capab needed
928 * - data
929 * outputs - none
930 * side effects - data sent to servers matching with capab
931 */
932 void
933 sendto_match_servs(struct Client *source_p, const char *mask, int cap,
934 const char *pattern, ...)
935 {
936 va_list args;
937 struct Client *target_p;
938 dlink_node *ptr;
939 char buffer[IRCD_BUFSIZE];
940 int found = 0;
941
942 va_start(args, pattern);
943 vsnprintf(buffer, sizeof(buffer), pattern, args);
944 va_end(args);
945
946 current_serial++;
947
948 DLINK_FOREACH(ptr, global_serv_list.head)
949 {
950 target_p = ptr->data;
951
952 /* Do not attempt to send to ourselves, or the source */
953 if (IsMe(target_p) || target_p->from == source_p->from)
954 continue;
955
956 if (target_p->from->serial == current_serial)
957 continue;
958
959 if (match(mask, target_p->name))
960 {
961 /*
962 * if we set the serial here, then we'll never do a
963 * match() again, if !IsCapable()
964 */
965 target_p->from->serial = current_serial;
966 found++;
967
968 if (!IsCapable(target_p->from, cap))
969 continue;
970
971 sendto_anywhere(target_p, source_p, "%s", buffer);
972 }
973 }
974 }
975
976 /* sendto_anywhere()
977 *
978 * inputs - pointer to dest client
979 * - pointer to from client
980 * - varags
981 * output - NONE
982 * side effects - less efficient than sendto_remote and sendto_one
983 * but useful when one does not know where target "lives"
984 */
985 void
986 sendto_anywhere(struct Client *to, struct Client *from,
987 const char *pattern, ...)
988 {
989 va_list args;
990 char buffer[IRCD_BUFSIZE];
991 int len;
992 struct Client *send_to = (to->from != NULL ? to->from : to);
993
994 if (IsDead(send_to))
995 return;
996
997 if (MyClient(to))
998 {
999 if (IsServer(from))
1000 {
1001 if (IsCapable(to, CAP_TS6) && HasID(from))
1002 len = ircsprintf(buffer, ":%s ", from->id);
1003 else
1004 len = ircsprintf(buffer, ":%s ", from->name);
1005 }
1006 else
1007 len = ircsprintf(buffer, ":%s!%s@%s ",
1008 from->name, from->username, from->host);
1009 }
1010 else len = ircsprintf(buffer, ":%s ", ID_or_name(from, send_to));
1011
1012 va_start(args, pattern);
1013 len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
1014 va_end(args);
1015
1016 if(MyClient(to))
1017 send_message(send_to, buffer, len);
1018 else
1019 send_message_remote(send_to, from, buffer, len);
1020 }
1021
1022 /* sendto_realops_flags()
1023 *
1024 * inputs - flag types of messages to show to real opers
1025 * - flag indicating opers/admins
1026 * - var args input message
1027 * output - NONE
1028 * side effects - Send to *local* ops only but NOT +s nonopers.
1029 */
1030 void
1031 sendto_realops_flags(unsigned int flags, int level, const char *pattern, ...)
1032 {
1033 struct Client *client_p;
1034 char nbuf[IRCD_BUFSIZE];
1035 dlink_node *ptr;
1036 va_list args;
1037
1038 va_start(args, pattern);
1039 vsnprintf(nbuf, IRCD_BUFSIZE, pattern, args);
1040 va_end(args);
1041
1042 DLINK_FOREACH(ptr, oper_list.head)
1043 {
1044 client_p = ptr->data;
1045 assert(client_p->umodes & UMODE_OPER);
1046
1047 /* If we're sending it to opers and theyre an admin, skip.
1048 * If we're sending it to admins, and theyre not, skip.
1049 */
1050 if (((level == L_ADMIN) && !IsAdmin(client_p)) ||
1051 ((level == L_OPER) && IsAdmin(client_p)))
1052 continue;
1053
1054 if (client_p->umodes & flags)
1055 sendto_one(client_p, ":%s NOTICE %s :*** Notice -- %s",
1056 me.name, client_p->name, nbuf);
1057 }
1058 }
1059
1060 /* sendto_wallops_flags()
1061 *
1062 * inputs - flag types of messages to show to real opers
1063 * - client sending request
1064 * - var args input message
1065 * output - NONE
1066 * side effects - Send a wallops to local opers
1067 */
1068 void
1069 sendto_wallops_flags(unsigned int flags, struct Client *source_p,
1070 const char *pattern, ...)
1071 {
1072 struct Client *client_p;
1073 dlink_node *ptr;
1074 va_list args;
1075 char buffer[IRCD_BUFSIZE];
1076 int len;
1077
1078 if (IsClient(source_p))
1079 len = ircsprintf(buffer, ":%s!%s@%s WALLOPS :",
1080 source_p->name, source_p->username, source_p->host);
1081 else
1082 len = ircsprintf(buffer, ":%s WALLOPS :", source_p->name);
1083
1084 va_start(args, pattern);
1085 len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
1086 va_end(args);
1087
1088 DLINK_FOREACH(ptr, oper_list.head)
1089 {
1090 client_p = ptr->data;
1091 assert(client_p->umodes & UMODE_OPER);
1092
1093 if ((client_p->umodes & flags) && !IsDefunct(client_p))
1094 send_message(client_p, buffer, len);
1095 }
1096 }
1097
1098 /* ts_warn()
1099 *
1100 * inputs - var args message
1101 * output - NONE
1102 * side effects - Call sendto_realops_flags, with some flood checking
1103 * (at most 5 warnings every 5 seconds)
1104 */
1105 void
1106 ts_warn(const char *pattern, ...)
1107 {
1108 va_list args;
1109 char buffer[LOG_BUFSIZE];
1110 static time_t last = 0;
1111 static int warnings = 0;
1112
1113 /*
1114 ** if we're running with TS_WARNINGS enabled and someone does
1115 ** something silly like (remotely) connecting a nonTS server,
1116 ** we'll get a ton of warnings, so we make sure we don't send
1117 ** more than 5 every 5 seconds. -orabidoo
1118 */
1119
1120 if (CurrentTime - last < 5)
1121 {
1122 if (++warnings > 5)
1123 return;
1124 }
1125 else
1126 {
1127 last = CurrentTime;
1128 warnings = 0;
1129 }
1130
1131 va_start(args, pattern);
1132 vsprintf_irc(buffer, pattern, args);
1133 va_end(args);
1134
1135 sendto_realops_flags(UMODE_ALL, L_ALL, "%s", buffer);
1136 ilog(L_CRIT, "%s", buffer);
1137 }
1138
1139 /* kill_client()
1140 *
1141 * inputs - client to send kill towards
1142 * - pointer to client to kill
1143 * - reason for kill
1144 * output - NONE
1145 * side effects - NONE
1146 */
1147 void
1148 kill_client(struct Client *client_p, struct Client *diedie,
1149 const char *pattern, ...)
1150 {
1151 va_list args;
1152 char buffer[IRCD_BUFSIZE];
1153 int len;
1154
1155 if (client_p->from != NULL)
1156 client_p = client_p->from;
1157 if (IsDead(client_p))
1158 return;
1159
1160 len = ircsprintf(buffer, ":%s KILL %s :", ID_or_name(&me, client_p->from),
1161 ID_or_name(diedie, client_p));
1162
1163 va_start(args, pattern);
1164 len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
1165 va_end(args);
1166
1167 send_message(client_p, buffer, len);
1168 }
1169
1170 /* kill_client_ll_serv_butone()
1171 *
1172 * inputs - pointer to client to not send to
1173 * - pointer to client to kill
1174 * output - NONE
1175 * side effects - Send a KILL for the given client
1176 * message to all connected servers
1177 * except the client 'one'. Also deal with
1178 * client being unknown to leaf, as in lazylink...
1179 */
1180 void
1181 kill_client_ll_serv_butone(struct Client *one, struct Client *source_p,
1182 const char *pattern, ...)
1183 {
1184 va_list args;
1185 int have_uid = 0;
1186 struct Client *client_p;
1187 dlink_node *ptr;
1188 char buf_uid[IRCD_BUFSIZE], buf_nick[IRCD_BUFSIZE];
1189 int len_uid = 0, len_nick;
1190
1191 va_start(args, pattern);
1192 if (HasID(source_p) && (me.id[0] != '\0'))
1193 {
1194 have_uid = 1;
1195 len_uid = ircsprintf(buf_uid, ":%s KILL %s :", me.id, ID(source_p));
1196 len_uid += send_format(&buf_uid[len_uid], IRCD_BUFSIZE - len_uid, pattern,
1197 args);
1198 }
1199 len_nick = ircsprintf(buf_nick, ":%s KILL %s :", me.name, source_p->name);
1200 len_nick += send_format(&buf_nick[len_nick], IRCD_BUFSIZE - len_nick, pattern,
1201 args);
1202 va_end(args);
1203
1204 DLINK_FOREACH(ptr, serv_list.head)
1205 {
1206 client_p = ptr->data;
1207
1208 if (one != NULL && (client_p == one->from))
1209 continue;
1210 if (IsDefunct(client_p))
1211 continue;
1212
1213 /* XXX perhaps IsCapable should test for localClient itself ? -db */
1214 if (client_p->localClient == NULL || !IsCapable(client_p, CAP_LL) ||
1215 !ServerInfo.hub ||
1216 (source_p->lazyLinkClientExists & client_p->localClient->serverMask))
1217 {
1218 if (have_uid && IsCapable(client_p, CAP_TS6))
1219 send_message(client_p, buf_uid, len_uid);
1220 else
1221 send_message(client_p, buf_nick, len_nick);
1222 }
1223 }
1224 }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.26