ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/send.c
Revision: 4589
Committed: Tue Aug 26 15:59:21 2014 UTC (9 years, 7 months ago) by michael
Content type: text/x-csrc
File size: 25854 byte(s)
Log Message:
- Renamed 'localClient' Client structure member to just 'connection'

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 *
4 * Copyright (c) 1997-2014 ircd-hybrid development team
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19 * USA
20 */
21
22 /*! \file send.c
23 * \brief Functions for sending messages.
24 * \version $Id$
25 */
26
27 #include "stdinc.h"
28 #include "list.h"
29 #include "send.h"
30 #include "channel.h"
31 #include "client.h"
32 #include "dbuf.h"
33 #include "irc_string.h"
34 #include "ircd.h"
35 #include "numeric.h"
36 #include "fdlist.h"
37 #include "s_bsd.h"
38 #include "server.h"
39 #include "conf.h"
40 #include "log.h"
41 #include "memory.h"
42 #include "packet.h"
43
44
45 static unsigned int current_serial = 0;
46
47
48 /* send_format()
49 *
50 * inputs
51 * - buffer
52 * - format pattern to use
53 * - var args
54 * output - number of bytes formatted output
55 * side effects - modifies sendbuf
56 */
57 static void
58 send_format(struct dbuf_block *buffer, const char *pattern, va_list args)
59 {
60 /*
61 * from rfc1459
62 *
63 * IRC messages are always lines of characters terminated with a CR-LF
64 * (Carriage Return - Line Feed) pair, and these messages shall not
65 * exceed 512 characters in length, counting all characters
66 * including the trailing CR-LF.
67 * Thus, there are 510 characters maximum allowed
68 * for the command and its parameters. There is no provision for
69 * continuation message lines. See section 7 for more details about
70 * current implementations.
71 */
72 dbuf_put_args(buffer, pattern, args);
73
74 if (buffer->size > sizeof(buffer->data) - 2)
75 buffer->size = sizeof(buffer->data) - 2;
76
77 buffer->data[buffer->size++] = '\r';
78 buffer->data[buffer->size++] = '\n';
79 }
80
81 /*
82 ** send_message
83 ** Internal utility which appends given buffer to the sockets
84 ** sendq.
85 */
86 static void
87 send_message(struct Client *to, struct dbuf_block *buf)
88 {
89 assert(!IsMe(to));
90 assert(to != &me);
91
92 if (dbuf_length(&to->connection->buf_sendq) + buf->size > get_sendq(&to->connection->confs))
93 {
94 if (IsServer(to))
95 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
96 "Max SendQ limit exceeded for %s: %lu > %u",
97 get_client_name(to, HIDE_IP),
98 (unsigned long)(dbuf_length(&to->connection->buf_sendq) + buf->size),
99 get_sendq(&to->connection->confs));
100 if (IsClient(to))
101 SetSendQExceeded(to);
102
103 dead_link_on_write(to, 0);
104 return;
105 }
106
107 dbuf_add(&to->connection->buf_sendq, buf);
108
109 /*
110 * Update statistics. The following is slightly incorrect because
111 * it counts messages even if queued, but bytes only really sent.
112 * Queued bytes get updated in send_queued_write().
113 */
114 ++to->connection->send.messages;
115 ++me.connection->send.messages;
116
117 send_queued_write(to);
118 }
119
120 /* send_message_remote()
121 *
122 * inputs - pointer to client from message is being sent
123 * - pointer to client to send to
124 * - pointer to buffer
125 * output - none
126 * side effects - Despite the function name, this only sends to directly
127 * connected clients.
128 *
129 */
130 static void
131 send_message_remote(struct Client *to, struct Client *from, struct dbuf_block *buf)
132 {
133 to = to->from;
134
135 if (!MyConnect(to))
136 {
137 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
138 "Server send message to %s [%s] dropped from %s(Not local server)",
139 to->name, to->from->name, from->name);
140 return;
141 }
142
143 /* Optimize by checking if (from && to) before everything */
144 /* we set to->from up there.. */
145
146 if (!MyClient(from) && IsClient(to) && (to == from->from))
147 {
148 if (IsServer(from))
149 {
150 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
151 "Send message to %s [%s] dropped from %s(Fake Dir)",
152 to->name, to->from->name, from->name);
153 return;
154 }
155
156 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
157 "Ghosted: %s[%s@%s] from %s[%s@%s] (%s)",
158 to->name, to->username, to->host,
159 from->name, from->username, from->host,
160 to->from->name);
161
162 sendto_server(NULL, NOCAPS, NOCAPS,
163 ":%s KILL %s :%s (%s[%s@%s] Ghosted %s)",
164 me.id, to->id, me.name, to->name,
165 to->username, to->host, to->from->name);
166
167 AddFlag(to, FLAGS_KILLED);
168
169 if (IsClient(from))
170 sendto_one_numeric(from, &me, ERR_GHOSTEDCLIENT, to->name,
171 to->username, to->host, to->from);
172
173 exit_client(to, "Ghosted client");
174 return;
175 }
176
177 send_message(to, buf);
178 }
179
180 /*
181 ** sendq_unblocked
182 ** Called when a socket is ready for writing.
183 */
184 void
185 sendq_unblocked(fde_t *fd, void *data)
186 {
187 struct Client *client_p = data;
188 assert(fd == &client_p->connection->fd);
189
190 DelFlag(client_p, FLAGS_BLOCKED);
191 send_queued_write(client_p);
192 }
193
194 /*
195 ** send_queued_write
196 ** This is called when there is a chance that some output would
197 ** be possible. This attempts to empty the send queue as far as
198 ** possible, and then if any data is left, a write is rescheduled.
199 */
200 void
201 send_queued_write(struct Client *to)
202 {
203 int retlen = 0;
204
205 /*
206 ** Once socket is marked dead, we cannot start writing to it,
207 ** even if the error is removed...
208 */
209 if (IsDead(to) || HasFlag(to, FLAGS_BLOCKED))
210 return; /* no use calling send() now */
211
212 /* Next, lets try to write some data */
213 if (dbuf_length(&to->connection->buf_sendq))
214 {
215 do
216 {
217 struct dbuf_block *first = to->connection->buf_sendq.blocks.head->data;
218
219 #ifdef HAVE_LIBCRYPTO
220 if (to->connection->fd.ssl)
221 {
222 retlen = SSL_write(to->connection->fd.ssl, first->data + to->connection->buf_sendq.pos, first->size - to->connection->buf_sendq.pos);
223
224 /* translate openssl error codes, sigh */
225 if (retlen < 0)
226 {
227 switch (SSL_get_error(to->connection->fd.ssl, retlen))
228 {
229 case SSL_ERROR_WANT_READ:
230 return; /* retry later, don't register for write events */
231 case SSL_ERROR_WANT_WRITE:
232 errno = EWOULDBLOCK;
233 case SSL_ERROR_SYSCALL:
234 break;
235 case SSL_ERROR_SSL:
236 if (errno == EAGAIN)
237 break;
238 default:
239 retlen = errno = 0; /* either an SSL-specific error or EOF */
240 }
241 }
242 }
243 else
244 #endif
245 retlen = send(to->connection->fd.fd, first->data + to->connection->buf_sendq.pos, first->size - to->connection->buf_sendq.pos, 0);
246
247 if (retlen <= 0)
248 break;
249
250 dbuf_delete(&to->connection->buf_sendq, retlen);
251
252 /* We have some data written .. update counters */
253 to->connection->send.bytes += retlen;
254 me.connection->send.bytes += retlen;
255 } while (dbuf_length(&to->connection->buf_sendq));
256
257 if (retlen < 0 && ignoreErrno(errno))
258 {
259 AddFlag(to, FLAGS_BLOCKED);
260
261 /* we have a non-fatal error, reschedule a write */
262 comm_setselect(&to->connection->fd, COMM_SELECT_WRITE,
263 sendq_unblocked, to, 0);
264 }
265 else if (retlen <= 0)
266 {
267 dead_link_on_write(to, errno);
268 return;
269 }
270 }
271 }
272
273 /* send_queued_all()
274 *
275 * input - NONE
276 * output - NONE
277 * side effects - try to flush sendq of each client
278 */
279 void
280 send_queued_all(void)
281 {
282 dlink_node *ptr;
283
284 /* Servers are processed first, mainly because this can generate
285 * a notice to opers, which is to be delivered by this function.
286 */
287 DLINK_FOREACH(ptr, local_server_list.head)
288 send_queued_write(ptr->data);
289
290 DLINK_FOREACH(ptr, unknown_list.head)
291 send_queued_write(ptr->data);
292
293 DLINK_FOREACH(ptr, local_client_list.head)
294 send_queued_write(ptr->data);
295
296 /* NOTE: This can still put clients on aborted_list; unfortunately,
297 * exit_aborted_clients takes precedence over send_queued_all,
298 * because exiting clients can generate server/oper traffic.
299 * The easiest approach is dealing with aborted clients in the next I/O lap.
300 * -adx
301 */
302 }
303
304 /* sendto_one()
305 *
306 * inputs - pointer to destination client
307 * - var args message
308 * output - NONE
309 * side effects - send message to single client
310 */
311 void
312 sendto_one(struct Client *to, const char *pattern, ...)
313 {
314 va_list args;
315 struct dbuf_block *buffer = NULL;
316
317 if (IsDead(to->from))
318 return; /* This socket has already been marked as dead */
319
320 buffer = dbuf_alloc();
321
322 va_start(args, pattern);
323 send_format(buffer, pattern, args);
324 va_end(args);
325
326 send_message(to->from, buffer);
327
328 dbuf_ref_free(buffer);
329 }
330
331 void
332 sendto_one_numeric(struct Client *to, struct Client *from, enum irc_numerics numeric, ...)
333 {
334 struct dbuf_block *buffer = NULL;
335 const char *dest = NULL, *numstr = NULL;
336 va_list args;
337
338 if (IsDead(to->from))
339 return;
340
341 dest = ID_or_name(to, to);
342
343 if (EmptyString(dest))
344 dest = "*";
345
346 buffer = dbuf_alloc();
347
348 dbuf_put_fmt(buffer, ":%s %03d %s ", ID_or_name(from, to), numeric & ~SND_EXPLICIT, dest);
349
350 va_start(args, numeric);
351
352 if (numeric & SND_EXPLICIT)
353 numstr = va_arg(args, const char *);
354 else
355 numstr = numeric_form(numeric);
356 send_format(buffer, numstr, args);
357 va_end(args);
358
359 send_message(to->from, buffer);
360
361 dbuf_ref_free(buffer);
362 }
363
364 void
365 sendto_one_notice(struct Client *to, struct Client *from, const char *pattern, ...)
366 {
367 struct dbuf_block *buffer = NULL;
368 const char *dest = NULL;
369 va_list args;
370
371 if (IsDead(to->from))
372 return;
373
374 dest = ID_or_name(to, to);
375
376 if (EmptyString(dest))
377 dest = "*";
378
379 buffer = dbuf_alloc();
380
381 dbuf_put_fmt(buffer, ":%s NOTICE %s ", ID_or_name(from, to), dest);
382
383 va_start(args, pattern);
384 send_format(buffer, pattern, args);
385 va_end(args);
386
387 send_message(to->from, buffer);
388
389 dbuf_ref_free(buffer);
390 }
391
392 /* sendto_channel_butone()
393 *
394 * inputs - pointer to client(server) to NOT send message to
395 * - pointer to client that is sending this message
396 * - pointer to channel being sent to
397 * - vargs message
398 * output - NONE
399 * side effects - message as given is sent to given channel members.
400 *
401 * WARNING - +D clients are ignored
402 */
403 void
404 sendto_channel_butone(struct Client *one, struct Client *from,
405 struct Channel *chptr, unsigned int type,
406 const char *pattern, ...)
407 {
408 va_list alocal, aremote;
409 struct dbuf_block *local_buf, *remote_buf;
410 dlink_node *ptr = NULL, *ptr_next = NULL;
411
412 local_buf = dbuf_alloc(), remote_buf = dbuf_alloc();
413
414 if (IsClient(from))
415 dbuf_put_fmt(local_buf, ":%s!%s@%s ", from->name, from->username, from->host);
416 else
417 dbuf_put_fmt(local_buf, ":%s ", from->name);
418
419 dbuf_put_fmt(remote_buf, ":%s ", from->id);
420
421 va_start(alocal, pattern);
422 va_start(aremote, pattern);
423 send_format(local_buf, pattern, alocal);
424 send_format(remote_buf, pattern, aremote);
425
426 va_end(aremote);
427 va_end(alocal);
428
429 ++current_serial;
430
431 DLINK_FOREACH_SAFE(ptr, ptr_next, chptr->members.head)
432 {
433 struct Membership *ms = ptr->data;
434 struct Client *target_p = ms->client_p;
435
436 assert(IsClient(target_p));
437
438 if (IsDefunct(target_p) || HasUMode(target_p, UMODE_DEAF) ||
439 (one && target_p->from == one->from))
440 continue;
441
442 if (type && (ms->flags & type) == 0)
443 continue;
444
445 if (MyConnect(target_p))
446 send_message(target_p, local_buf);
447 else if (target_p->from->connection->serial != current_serial)
448 send_message_remote(target_p->from, from, remote_buf);
449 target_p->from->connection->serial = current_serial;
450 }
451
452 dbuf_ref_free(local_buf);
453 dbuf_ref_free(remote_buf);
454 }
455
456 /* sendto_server()
457 *
458 * inputs - pointer to client to NOT send to
459 * - pointer to channel
460 * - caps or'd together which must ALL be present
461 * - caps or'd together which must ALL NOT be present
462 * - printf style format string
463 * - args to format string
464 * output - NONE
465 * side effects - Send a message to all connected servers, except the
466 * client 'one' (if non-NULL), as long as the servers
467 * support ALL capabs in 'caps', and NO capabs in 'nocaps'.
468 *
469 * This function was written in an attempt to merge together the other
470 * billion sendto_*serv*() functions, which sprung up with capabs,
471 * lazylinks, uids, etc.
472 * -davidt
473 */
474 void
475 sendto_server(struct Client *one,
476 const unsigned int caps,
477 const unsigned int nocaps,
478 const char *format, ...)
479 {
480 va_list args;
481 dlink_node *ptr = NULL;
482 struct dbuf_block *buffer;
483
484 buffer = dbuf_alloc();
485
486 va_start(args, format);
487 send_format(buffer, format, args);
488 va_end(args);
489
490 DLINK_FOREACH(ptr, local_server_list.head)
491 {
492 struct Client *client_p = ptr->data;
493
494 /* If dead already skip */
495 if (IsDead(client_p))
496 continue;
497 /* check against 'one' */
498 if (one && (client_p == one->from))
499 continue;
500 /* check we have required capabs */
501 if ((client_p->connection->caps & caps) != caps)
502 continue;
503 /* check we don't have any forbidden capabs */
504 if ((client_p->connection->caps & nocaps))
505 continue;
506
507 send_message(client_p, buffer);
508 }
509
510 dbuf_ref_free(buffer);
511 }
512
513 /* sendto_common_channels_local()
514 *
515 * inputs - pointer to client
516 * - pattern to send
517 * output - NONE
518 * side effects - Sends a message to all people on local server who are
519 * in same channel with user.
520 * used by m_nick.c and exit_one_client.
521 */
522 void
523 sendto_common_channels_local(struct Client *user, int touser, unsigned int cap,
524 const char *pattern, ...)
525 {
526 va_list args;
527 dlink_node *uptr;
528 dlink_node *cptr;
529 struct Channel *chptr;
530 struct Membership *ms;
531 struct Client *target_p;
532 struct dbuf_block *buffer;
533
534 buffer = dbuf_alloc();
535
536 va_start(args, pattern);
537 send_format(buffer, pattern, args);
538 va_end(args);
539
540 ++current_serial;
541
542 DLINK_FOREACH(cptr, user->channel.head)
543 {
544 chptr = ((struct Membership *)cptr->data)->chptr;
545
546 DLINK_FOREACH(uptr, chptr->locmembers.head)
547 {
548 ms = uptr->data;
549 target_p = ms->client_p;
550
551 if (target_p == user || IsDefunct(target_p) ||
552 target_p->connection->serial == current_serial)
553 continue;
554
555 if (HasCap(target_p, cap) != cap)
556 continue;
557
558 target_p->connection->serial = current_serial;
559 send_message(target_p, buffer);
560 }
561 }
562
563 if (touser && MyConnect(user) && !IsDead(user) &&
564 user->connection->serial != current_serial)
565 if (HasCap(user, cap) == cap)
566 send_message(user, buffer);
567
568 dbuf_ref_free(buffer);
569 }
570
571 /* sendto_channel_local()
572 *
573 * inputs - member status mask, e.g. CHFL_CHANOP | CHFL_VOICE
574 * - whether to ignore +D clients (YES/NO)
575 * - pointer to channel to send to
576 * - var args pattern
577 * output - NONE
578 * side effects - Send a message to all members of a channel that are
579 * locally connected to this server.
580 */
581 void
582 sendto_channel_local(unsigned int type, int nodeaf, struct Channel *chptr,
583 const char *pattern, ...)
584 {
585 va_list args;
586 dlink_node *ptr = NULL;
587 struct dbuf_block *buffer;
588
589 buffer = dbuf_alloc();
590
591 va_start(args, pattern);
592 send_format(buffer, pattern, args);
593 va_end(args);
594
595 DLINK_FOREACH(ptr, chptr->locmembers.head)
596 {
597 struct Membership *ms = ptr->data;
598 struct Client *target_p = ms->client_p;
599
600 if (type && (ms->flags & type) == 0)
601 continue;
602
603 if (IsDefunct(target_p) ||
604 (nodeaf && HasUMode(target_p, UMODE_DEAF)))
605 continue;
606
607 send_message(target_p, buffer);
608 }
609
610 dbuf_ref_free(buffer);
611 }
612
613 /* sendto_channel_local_butone()
614 *
615 * inputs - pointer to client to NOT send message to
616 * - member status mask, e.g. CHFL_CHANOP | CHFL_VOICE
617 * - pointer to channel to send to
618 * - var args pattern
619 * output - NONE
620 * side effects - Send a message to all members of a channel that are
621 * locally connected to this server except one.
622 *
623 * WARNING - +D clients are omitted
624 */
625 void
626 sendto_channel_local_butone(struct Client *one, unsigned int type, unsigned int cap,
627 struct Channel *chptr, const char *pattern, ...)
628 {
629 va_list args;
630 dlink_node *ptr = NULL;
631 struct dbuf_block *buffer;
632
633 buffer = dbuf_alloc();
634
635 va_start(args, pattern);
636 send_format(buffer, pattern, args);
637 va_end(args);
638
639 DLINK_FOREACH(ptr, chptr->locmembers.head)
640 {
641 struct Membership *ms = ptr->data;
642 struct Client *target_p = ms->client_p;
643
644 if (type && (ms->flags & type) == 0)
645 continue;
646
647 if (one && target_p == one->from)
648 continue;
649
650 if (IsDefunct(target_p) || HasUMode(target_p, UMODE_DEAF))
651 continue;
652
653 if (HasCap(target_p, cap) != cap)
654 continue;
655
656 send_message(target_p, buffer);
657 }
658
659 dbuf_ref_free(buffer);
660 }
661
662 /*
663 ** match_it() and sendto_match_butone() ARE only used
664 ** to send a msg to all ppl on servers/hosts that match a specified mask
665 ** (used for enhanced PRIVMSGs) for opers
666 **
667 ** addition -- Armin, 8jun90 (gruner@informatik.tu-muenchen.de)
668 **
669 */
670
671 /* match_it()
672 *
673 * inputs - client pointer to match on
674 * - actual mask to match
675 * - what to match on, HOST or SERVER
676 * output - 1 or 0 if match or not
677 * side effects - NONE
678 */
679 static int
680 match_it(const struct Client *one, const char *mask, unsigned int what)
681 {
682 if (what == MATCH_HOST)
683 return !match(mask, one->host);
684
685 return !match(mask, one->servptr->name);
686 }
687
688 /* sendto_match_butone()
689 *
690 * Send to all clients which match the mask in a way defined on 'what';
691 * either by user hostname or user servername.
692 *
693 * ugh. ONLY used by m_message.c to send an "oper magic" message. ugh.
694 */
695 void
696 sendto_match_butone(struct Client *one, struct Client *from, const char *mask,
697 int what, const char *pattern, ...)
698 {
699 va_list alocal, aremote;
700 dlink_node *ptr = NULL, *ptr_next = NULL;
701 struct dbuf_block *local_buf, *remote_buf;
702
703 local_buf = dbuf_alloc(), remote_buf = dbuf_alloc();
704
705 dbuf_put_fmt(local_buf, ":%s!%s@%s ", from->name, from->username, from->host);
706 dbuf_put_fmt(remote_buf, ":%s ", from->id);
707
708 va_start(alocal, pattern);
709 va_start(aremote, pattern);
710 send_format(local_buf, pattern, alocal);
711 send_format(remote_buf, pattern, aremote);
712 va_end(aremote);
713 va_end(alocal);
714
715 /* scan the local clients */
716 DLINK_FOREACH(ptr, local_client_list.head)
717 {
718 struct Client *client_p = ptr->data;
719
720 if ((!one || client_p != one->from) && !IsDefunct(client_p) &&
721 match_it(client_p, mask, what))
722 send_message(client_p, local_buf);
723 }
724
725 /* Now scan servers */
726 DLINK_FOREACH_SAFE(ptr, ptr_next, local_server_list.head)
727 {
728 struct Client *client_p = ptr->data;
729
730 /*
731 * The old code looped through every client on the
732 * network for each server to check if the
733 * server (client_p) has at least 1 client matching
734 * the mask, using something like:
735 *
736 * for (target_p = GlobalClientList; target_p; target_p = target_p->next)
737 * if (IsRegisteredUser(target_p) &&
738 * match_it(target_p, mask, what) &&
739 * (target_p->from == client_p))
740 * vsendto_prefix_one(client_p, from, pattern, args);
741 *
742 * That way, we wouldn't send the message to
743 * a server who didn't have a matching client.
744 * However, on a network such as EFNet, that
745 * code would have looped through about 50
746 * servers, and in each loop, loop through
747 * about 50k clients as well, calling match()
748 * in each nested loop. That is a very bad
749 * thing cpu wise - just send the message
750 * to every connected server and let that
751 * server deal with it.
752 * -wnder
753 */
754 if ((!one || client_p != one->from) && !IsDefunct(client_p))
755 send_message_remote(client_p, from, remote_buf);
756 }
757
758 dbuf_ref_free(local_buf);
759 dbuf_ref_free(remote_buf);
760 }
761
762 /* sendto_match_servs()
763 *
764 * inputs - source client
765 * - mask to send to
766 * - capab needed
767 * - data
768 * outputs - none
769 * side effects - data sent to servers matching with capab
770 */
771 void
772 sendto_match_servs(struct Client *source_p, const char *mask, unsigned int cap,
773 const char *pattern, ...)
774 {
775 va_list args;
776 dlink_node *ptr = NULL, *ptr_next = NULL;
777 struct dbuf_block *buffer;
778
779 buffer = dbuf_alloc();
780
781 dbuf_put_fmt(buffer, ":%s ", source_p->id);
782 va_start(args, pattern);
783 send_format(buffer, pattern, args);
784 va_end(args);
785
786 ++current_serial;
787
788 DLINK_FOREACH_SAFE(ptr, ptr_next, global_server_list.head)
789 {
790 struct Client *target_p = ptr->data;
791
792 /* Do not attempt to send to ourselves, or the source */
793 if (IsMe(target_p) || target_p->from == source_p->from)
794 continue;
795
796 if (target_p->from->connection->serial == current_serial)
797 continue;
798
799 if (!match(mask, target_p->name))
800 {
801 /*
802 * if we set the serial here, then we'll never do a
803 * match() again, if !IsCapable()
804 */
805 target_p->from->connection->serial = current_serial;
806
807 if (!IsCapable(target_p->from, cap))
808 continue;
809
810 send_message_remote(target_p->from, source_p, buffer);
811 }
812 }
813
814 dbuf_ref_free(buffer);
815 }
816
817 /* sendto_anywhere()
818 *
819 * inputs - pointer to dest client
820 * - pointer to from client
821 * - varags
822 * output - NONE
823 * side effects - less efficient than sendto_remote and sendto_one
824 * but useful when one does not know where target "lives"
825 */
826 void
827 sendto_anywhere(struct Client *to, struct Client *from,
828 const char *command,
829 const char *pattern, ...)
830 {
831 va_list args;
832 struct dbuf_block *buffer = NULL;
833
834 if (IsDead(to->from))
835 return;
836
837 buffer = dbuf_alloc();
838
839 if (MyClient(to) && IsClient(from))
840 dbuf_put_fmt(buffer, ":%s!%s@%s %s %s ", from->name, from->username,
841 from->host, command, to->name);
842 else
843 dbuf_put_fmt(buffer, ":%s %s %s ", ID_or_name(from, to),
844 command, ID_or_name(to, to));
845
846 va_start(args, pattern);
847 send_format(buffer, pattern, args);
848 va_end(args);
849
850 if (MyClient(to))
851 send_message(to, buffer);
852 else
853 send_message_remote(to, from, buffer);
854
855 dbuf_ref_free(buffer);
856 }
857
858 /* sendto_realops_flags()
859 *
860 * inputs - flag types of messages to show to real opers
861 * - flag indicating opers/admins
862 * - var args input message
863 * output - NONE
864 * side effects - Send to *local* ops only but NOT +s nonopers.
865 */
866 void
867 sendto_realops_flags(unsigned int flags, int level, int type, const char *pattern, ...)
868 {
869 const char *ntype = NULL;
870 dlink_node *ptr = NULL;
871 char nbuf[IRCD_BUFSIZE] = "";
872 va_list args;
873
874 va_start(args, pattern);
875 vsnprintf(nbuf, sizeof(nbuf), pattern, args);
876 va_end(args);
877
878 switch (type)
879 {
880 case SEND_NOTICE:
881 ntype = "Notice";
882 break;
883 case SEND_GLOBAL:
884 ntype = "Global";
885 break;
886 case SEND_LOCOPS:
887 ntype = "LocOps";
888 break;
889 default:
890 assert(0);
891 }
892
893 DLINK_FOREACH(ptr, oper_list.head)
894 {
895 struct Client *client_p = ptr->data;
896 assert(HasUMode(client_p, UMODE_OPER));
897
898 /*
899 * If we're sending it to opers and they're an admin, skip.
900 * If we're sending it to admins, and they're not, skip.
901 */
902 if (((level == L_ADMIN) && !HasUMode(client_p, UMODE_ADMIN)) ||
903 ((level == L_OPER) && HasUMode(client_p, UMODE_ADMIN)))
904 continue;
905
906 if (HasUMode(client_p, flags))
907 sendto_one(client_p, ":%s NOTICE %s :*** %s -- %s",
908 me.name, client_p->name, ntype, nbuf);
909 }
910 }
911
912 /* ts_warn()
913 *
914 * inputs - var args message
915 * output - NONE
916 * side effects - Call sendto_realops_flags, with some flood checking
917 * (at most 5 warnings every 5 seconds)
918 */
919 void
920 sendto_realops_flags_ratelimited(time_t *rate, const char *pattern, ...)
921 {
922 va_list args;
923 char buffer[IRCD_BUFSIZE] = "";
924
925 if ((CurrentTime - *rate) < 20)
926 return;
927 *rate = CurrentTime;
928
929 va_start(args, pattern);
930 vsnprintf(buffer, sizeof(buffer), pattern, args);
931 va_end(args);
932
933 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, "%s", buffer);
934 ilog(LOG_TYPE_IRCD, "%s", buffer);
935 }
936
937 /* sendto_wallops_flags()
938 *
939 * inputs - flag types of messages to show to real opers
940 * - client sending request
941 * - var args input message
942 * output - NONE
943 * side effects - Send a wallops to local opers
944 */
945 void
946 sendto_wallops_flags(unsigned int flags, struct Client *source_p,
947 const char *pattern, ...)
948 {
949 dlink_node *ptr = NULL;
950 va_list args;
951 struct dbuf_block *buffer;
952
953 buffer = dbuf_alloc();
954
955 if (IsClient(source_p))
956 dbuf_put_fmt(buffer, ":%s!%s@%s WALLOPS :", source_p->name, source_p->username, source_p->host);
957 else
958 dbuf_put_fmt(buffer, ":%s WALLOPS :", source_p->name);
959
960 va_start(args, pattern);
961 send_format(buffer, pattern, args);
962 va_end(args);
963
964 DLINK_FOREACH(ptr, oper_list.head)
965 {
966 struct Client *client_p = ptr->data;
967 assert(client_p->umodes & UMODE_OPER);
968
969 if (HasUMode(client_p, flags) && !IsDefunct(client_p))
970 send_message(client_p, buffer);
971 }
972
973 dbuf_ref_free(buffer);
974 }

Properties

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