ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-7.2/src/send.c
Revision: 163
Committed: Thu Oct 20 21:09:02 2005 UTC (18 years, 5 months ago) by adx
Content type: text/x-csrc
File size: 33961 byte(s)
Log Message:
- MFC iorecv/iosend changes to allow charset recoding

File Contents

# Content
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 DLINK_FOREACH(ptr, chptr->members.head)
802 {
803 ms = ptr->data;
804 target_p = ms->client_p;
805
806 if (type != 0 && (ms->flags & type) == 0)
807 continue;
808
809 if (MyConnect(target_p))
810 continue;
811 target_p = target_p->from;
812
813 if (target_p == one->from ||
814 ((target_p->from->localClient->caps & caps) != caps) ||
815 ((target_p->from->localClient->caps & nocaps) != 0))
816 continue;
817
818 send_message(target_p, buffer, len);
819 }
820 }
821
822 /*
823 ** match_it() and sendto_match_butone() ARE only used
824 ** to send a msg to all ppl on servers/hosts that match a specified mask
825 ** (used for enhanced PRIVMSGs) for opers
826 **
827 ** addition -- Armin, 8jun90 (gruner@informatik.tu-muenchen.de)
828 **
829 */
830
831 /* match_it()
832 *
833 * inputs - client pointer to match on
834 * - actual mask to match
835 * - what to match on, HOST or SERVER
836 * output - 1 or 0 if match or not
837 * side effects - NONE
838 */
839 static int
840 match_it(const struct Client *one, const char *mask, int what)
841 {
842 if (what == MATCH_HOST)
843 return(match(mask, one->host));
844
845 return(match(mask, one->servptr->name));
846 }
847
848 /* sendto_match_butone()
849 *
850 * Send to all clients which match the mask in a way defined on 'what';
851 * either by user hostname or user servername.
852 *
853 * ugh. ONLY used by m_message.c to send an "oper magic" message. ugh.
854 */
855 void
856 sendto_match_butone(struct Client *one, struct Client *from, char *mask,
857 int what, const char *pattern, ...)
858 {
859 va_list args;
860 struct Client *client_p;
861 dlink_node *ptr, *ptr_next;
862 char local_buf[IRCD_BUFSIZE], remote_buf[IRCD_BUFSIZE];
863 int local_len = ircsprintf(local_buf, ":%s!%s@%s ", from->name,
864 from->username, from->host);
865 int remote_len = ircsprintf(remote_buf, ":%s ", from->name);
866
867 va_start(args, pattern);
868 local_len += send_format(&local_buf[local_len], IRCD_BUFSIZE - local_len,
869 pattern, args);
870 remote_len += send_format(&remote_buf[remote_len], IRCD_BUFSIZE - remote_len,
871 pattern, args);
872 va_end(args);
873
874 /* scan the local clients */
875 DLINK_FOREACH(ptr, local_client_list.head)
876 {
877 client_p = ptr->data;
878
879 if (client_p != one && !IsDefunct(client_p) &&
880 match_it(client_p, mask, what))
881 send_message(client_p, local_buf, local_len);
882 }
883
884 /* Now scan servers */
885 DLINK_FOREACH_SAFE(ptr, ptr_next, serv_list.head)
886 {
887 client_p = ptr->data;
888
889 /*
890 * The old code looped through every client on the
891 * network for each server to check if the
892 * server (client_p) has at least 1 client matching
893 * the mask, using something like:
894 *
895 * for (target_p = GlobalClientList; target_p; target_p = target_p->next)
896 * if (IsRegisteredUser(target_p) &&
897 * match_it(target_p, mask, what) &&
898 * (target_p->from == client_p))
899 * vsendto_prefix_one(client_p, from, pattern, args);
900 *
901 * That way, we wouldn't send the message to
902 * a server who didn't have a matching client.
903 * However, on a network such as EFNet, that
904 * code would have looped through about 50
905 * servers, and in each loop, loop through
906 * about 50k clients as well, calling match()
907 * in each nested loop. That is a very bad
908 * thing cpu wise - just send the message
909 * to every connected server and let that
910 * server deal with it.
911 * -wnder
912 */
913 if (client_p != one && !IsDefunct(client_p))
914 send_message_remote(client_p, from, remote_buf, remote_len);
915 }
916 }
917
918 /* sendto_match_servs()
919 *
920 * inputs - source client
921 * - mask to send to
922 * - capab needed
923 * - data
924 * outputs - none
925 * side effects - data sent to servers matching with capab
926 */
927 void
928 sendto_match_servs(struct Client *source_p, const char *mask, int cap,
929 const char *pattern, ...)
930 {
931 va_list args;
932 struct Client *target_p;
933 dlink_node *ptr;
934 char buffer[IRCD_BUFSIZE];
935 int found = 0;
936
937 va_start(args, pattern);
938 vsnprintf(buffer, sizeof(buffer), pattern, args);
939 va_end(args);
940
941 current_serial++;
942
943 DLINK_FOREACH(ptr, global_serv_list.head)
944 {
945 target_p = ptr->data;
946
947 /* Do not attempt to send to ourselves, or the source */
948 if (IsMe(target_p) || target_p->from == source_p->from)
949 continue;
950
951 if (target_p->from->serial == current_serial)
952 continue;
953
954 if (match(mask, target_p->name))
955 {
956 /*
957 * if we set the serial here, then we'll never do a
958 * match() again, if !IsCapable()
959 */
960 target_p->from->serial = current_serial;
961 found++;
962
963 if (!IsCapable(target_p->from, cap))
964 continue;
965
966 sendto_anywhere(target_p, source_p, "%s", buffer);
967 }
968 }
969 }
970
971 /* sendto_anywhere()
972 *
973 * inputs - pointer to dest client
974 * - pointer to from client
975 * - varags
976 * output - NONE
977 * side effects - less efficient than sendto_remote and sendto_one
978 * but useful when one does not know where target "lives"
979 */
980 void
981 sendto_anywhere(struct Client *to, struct Client *from,
982 const char *pattern, ...)
983 {
984 va_list args;
985 char buffer[IRCD_BUFSIZE];
986 int len;
987 struct Client *send_to = (to->from != NULL ? to->from : to);
988
989 if (IsDead(send_to))
990 return;
991
992 if (MyClient(to))
993 {
994 if (IsServer(from))
995 {
996 if (IsCapable(to, CAP_TS6) && HasID(from))
997 len = ircsprintf(buffer, ":%s ", from->id);
998 else
999 len = ircsprintf(buffer, ":%s ", from->name);
1000 }
1001 else
1002 len = ircsprintf(buffer, ":%s!%s@%s ",
1003 from->name, from->username, from->host);
1004 }
1005 else len = ircsprintf(buffer, ":%s ", ID_or_name(from, send_to));
1006
1007 va_start(args, pattern);
1008 len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
1009 va_end(args);
1010
1011 if(MyClient(to))
1012 send_message(send_to, buffer, len);
1013 else
1014 send_message_remote(send_to, from, buffer, len);
1015 }
1016
1017 /* sendto_realops_flags()
1018 *
1019 * inputs - flag types of messages to show to real opers
1020 * - flag indicating opers/admins
1021 * - var args input message
1022 * output - NONE
1023 * side effects - Send to *local* ops only but NOT +s nonopers.
1024 */
1025 void
1026 sendto_realops_flags(unsigned int flags, int level, const char *pattern, ...)
1027 {
1028 struct Client *client_p;
1029 char nbuf[IRCD_BUFSIZE];
1030 dlink_node *ptr;
1031 va_list args;
1032
1033 va_start(args, pattern);
1034 vsnprintf(nbuf, IRCD_BUFSIZE, pattern, args);
1035 va_end(args);
1036
1037 DLINK_FOREACH(ptr, oper_list.head)
1038 {
1039 client_p = ptr->data;
1040 assert(client_p->umodes & UMODE_OPER);
1041
1042 /* If we're sending it to opers and theyre an admin, skip.
1043 * If we're sending it to admins, and theyre not, skip.
1044 */
1045 if (((level == L_ADMIN) && !IsAdmin(client_p)) ||
1046 ((level == L_OPER) && IsAdmin(client_p)))
1047 continue;
1048
1049 if (client_p->umodes & flags)
1050 sendto_one(client_p, ":%s NOTICE %s :*** Notice -- %s",
1051 me.name, client_p->name, nbuf);
1052 }
1053 }
1054
1055 /* sendto_wallops_flags()
1056 *
1057 * inputs - flag types of messages to show to real opers
1058 * - client sending request
1059 * - var args input message
1060 * output - NONE
1061 * side effects - Send a wallops to local opers
1062 */
1063 void
1064 sendto_wallops_flags(unsigned int flags, struct Client *source_p,
1065 const char *pattern, ...)
1066 {
1067 struct Client *client_p;
1068 dlink_node *ptr;
1069 va_list args;
1070 char buffer[IRCD_BUFSIZE];
1071 int len;
1072
1073 if (IsClient(source_p))
1074 len = ircsprintf(buffer, ":%s!%s@%s WALLOPS :",
1075 source_p->name, source_p->username, source_p->host);
1076 else
1077 len = ircsprintf(buffer, ":%s WALLOPS :", source_p->name);
1078
1079 va_start(args, pattern);
1080 len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
1081 va_end(args);
1082
1083 DLINK_FOREACH(ptr, oper_list.head)
1084 {
1085 client_p = ptr->data;
1086 assert(client_p->umodes & UMODE_OPER);
1087
1088 if ((client_p->umodes & flags) && !IsDefunct(client_p))
1089 send_message(client_p, buffer, len);
1090 }
1091 }
1092
1093 /* ts_warn()
1094 *
1095 * inputs - var args message
1096 * output - NONE
1097 * side effects - Call sendto_realops_flags, with some flood checking
1098 * (at most 5 warnings every 5 seconds)
1099 */
1100 void
1101 ts_warn(const char *pattern, ...)
1102 {
1103 va_list args;
1104 char buffer[LOG_BUFSIZE];
1105 static time_t last = 0;
1106 static int warnings = 0;
1107
1108 /*
1109 ** if we're running with TS_WARNINGS enabled and someone does
1110 ** something silly like (remotely) connecting a nonTS server,
1111 ** we'll get a ton of warnings, so we make sure we don't send
1112 ** more than 5 every 5 seconds. -orabidoo
1113 */
1114
1115 if (CurrentTime - last < 5)
1116 {
1117 if (++warnings > 5)
1118 return;
1119 }
1120 else
1121 {
1122 last = CurrentTime;
1123 warnings = 0;
1124 }
1125
1126 va_start(args, pattern);
1127 vsprintf_irc(buffer, pattern, args);
1128 va_end(args);
1129
1130 sendto_realops_flags(UMODE_ALL, L_ALL, "%s", buffer);
1131 ilog(L_CRIT, "%s", buffer);
1132 }
1133
1134 /* kill_client()
1135 *
1136 * inputs - client to send kill towards
1137 * - pointer to client to kill
1138 * - reason for kill
1139 * output - NONE
1140 * side effects - NONE
1141 */
1142 void
1143 kill_client(struct Client *client_p, struct Client *diedie,
1144 const char *pattern, ...)
1145 {
1146 va_list args;
1147 char buffer[IRCD_BUFSIZE];
1148 int len;
1149
1150 if (client_p->from != NULL)
1151 client_p = client_p->from;
1152 if (IsDead(client_p))
1153 return;
1154
1155 len = ircsprintf(buffer, ":%s KILL %s :", ID_or_name(&me, client_p->from),
1156 ID_or_name(diedie, client_p));
1157
1158 va_start(args, pattern);
1159 len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
1160 va_end(args);
1161
1162 send_message(client_p, buffer, len);
1163 }
1164
1165 /* kill_client_ll_serv_butone()
1166 *
1167 * inputs - pointer to client to not send to
1168 * - pointer to client to kill
1169 * output - NONE
1170 * side effects - Send a KILL for the given client
1171 * message to all connected servers
1172 * except the client 'one'. Also deal with
1173 * client being unknown to leaf, as in lazylink...
1174 */
1175 void
1176 kill_client_ll_serv_butone(struct Client *one, struct Client *source_p,
1177 const char *pattern, ...)
1178 {
1179 va_list args;
1180 int have_uid = 0;
1181 struct Client *client_p;
1182 dlink_node *ptr;
1183 char buf_uid[IRCD_BUFSIZE], buf_nick[IRCD_BUFSIZE];
1184 int len_uid = 0, len_nick;
1185
1186 va_start(args, pattern);
1187 if (HasID(source_p) && (me.id[0] != '\0'))
1188 {
1189 have_uid = 1;
1190 len_uid = ircsprintf(buf_uid, ":%s KILL %s :", me.id, ID(source_p));
1191 len_uid += send_format(&buf_uid[len_uid], IRCD_BUFSIZE - len_uid, pattern,
1192 args);
1193 }
1194 len_nick = ircsprintf(buf_nick, ":%s KILL %s :", me.name, source_p->name);
1195 len_nick += send_format(&buf_nick[len_nick], IRCD_BUFSIZE - len_nick, pattern,
1196 args);
1197 va_end(args);
1198
1199 DLINK_FOREACH(ptr, serv_list.head)
1200 {
1201 client_p = ptr->data;
1202
1203 if (one != NULL && (client_p == one->from))
1204 continue;
1205 if (IsDefunct(client_p))
1206 continue;
1207
1208 /* XXX perhaps IsCapable should test for localClient itself ? -db */
1209 if (client_p->localClient == NULL || !IsCapable(client_p, CAP_LL) ||
1210 !ServerInfo.hub ||
1211 (source_p->lazyLinkClientExists & client_p->localClient->serverMask))
1212 {
1213 if (have_uid && IsCapable(client_p, CAP_TS6))
1214 send_message(client_p, buf_uid, len_uid);
1215 else
1216 send_message(client_p, buf_nick, len_nick);
1217 }
1218 }
1219 }

Properties

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