]> jfr.im git - irc/rqf/shadowircd.git/blob - src/channel.c
projects / irc / rqf / shadowircd.git / blob
? search:


88f187011d4a789a88161acc38b1741c879ae21d
[irc/rqf/shadowircd.git] / src / channel.c
1 /*
2 * ircd-ratbox: A slightly useful ircd.
3 * channel.c: Controls channels.
4 *
5 * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
6 * Copyright (C) 1996-2002 Hybrid Development Team
7 * Copyright (C) 2002-2005 ircd-ratbox development team
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
22 * USA
23 *
24 */
25
26 #include "stdinc.h"
27 #include "channel.h"
28 #include "chmode.h"
29 #include "client.h"
30 #include "common.h"
31 #include "hash.h"
32 #include "hook.h"
33 #include "match.h"
34 #include "ircd.h"
35 #include "numeric.h"
36 #include "s_serv.h" /* captab */
37 #include "s_user.h"
38 #include "send.h"
39 #include "whowas.h"
40 #include "s_conf.h" /* ConfigFileEntry, ConfigChannel */
41 #include "s_newconf.h"
42 #include "logger.h"
43 #include "packet.h"
44 #include "irc_dictionary.h"
45
46 struct config_channel_entry ConfigChannel;
47 rb_dlink_list global_channel_list;
48 static rb_bh *channel_heap;
49 static rb_bh *ban_heap;
50 static rb_bh *topic_heap;
51 static rb_bh *member_heap;
52
53 static int channel_capabs[] = { CAP_EX, CAP_IE,
54 CAP_SERVICE,
55 CAP_TS6
56 };
57
58 #define NCHCAPS (sizeof(channel_capabs)/sizeof(int))
59 #define NCHCAP_COMBOS (1 << NCHCAPS)
60
61 static struct ChCapCombo chcap_combos[NCHCAP_COMBOS];
62
63 static void free_topic(struct Channel *chptr);
64
65 static int h_can_join;
66 static int h_can_create_channel;
67 static int h_channel_join;
68
69 /* init_channels()
70 *
71 * input -
72 * output -
73 * side effects - initialises the various blockheaps
74 */
75 void
76 init_channels(void)
77 {
78 channel_heap = rb_bh_create(sizeof(struct Channel), CHANNEL_HEAP_SIZE, "channel_heap");
79 ban_heap = rb_bh_create(sizeof(struct Ban), BAN_HEAP_SIZE, "ban_heap");
80 topic_heap = rb_bh_create(TOPICLEN + 1 + USERHOST_REPLYLEN, TOPIC_HEAP_SIZE, "topic_heap");
81 member_heap = rb_bh_create(sizeof(struct membership), MEMBER_HEAP_SIZE, "member_heap");
82
83 h_can_join = register_hook("can_join");
84 h_channel_join = register_hook("channel_join");
85 h_can_create_channel = register_hook("can_create_channel");
86 }
87
88 /*
89 * allocate_channel - Allocates a channel
90 */
91 struct Channel *
92 allocate_channel(const char *chname)
93 {
94 struct Channel *chptr;
95 struct Dictionary *metadata;
96 chptr = rb_bh_alloc(channel_heap);
97 chptr->chname = rb_strdup(chname);
98
99 metadata = irc_dictionary_create(irccmp);
100 chptr->metadata = metadata;
101 return (chptr);
102 }
103
104 void
105 free_channel(struct Channel *chptr)
106 {
107 channel_metadata_clear(chptr);
108 rb_free(chptr->chname);
109 rb_free(chptr->mode_lock);
110 rb_bh_free(channel_heap, chptr);
111 }
112
113 struct Ban *
114 allocate_ban(const char *banstr, const char *who)
115 {
116 struct Ban *bptr;
117 bptr = rb_bh_alloc(ban_heap);
118 bptr->banstr = rb_strdup(banstr);
119 bptr->who = rb_strdup(who);
120
121 return (bptr);
122 }
123
124 void
125 free_ban(struct Ban *bptr)
126 {
127 rb_free(bptr->banstr);
128 rb_free(bptr->who);
129 rb_bh_free(ban_heap, bptr);
130 }
131
132
133 /* find_channel_membership()
134 *
135 * input - channel to find them in, client to find
136 * output - membership of client in channel, else NULL
137 * side effects -
138 */
139 struct membership *
140 find_channel_membership(struct Channel *chptr, struct Client *client_p)
141 {
142 struct membership *msptr;
143 rb_dlink_node *ptr;
144
145 if(!IsClient(client_p))
146 return NULL;
147
148 /* Pick the most efficient list to use to be nice to things like
149 * CHANSERV which could be in a large number of channels
150 */
151 if(rb_dlink_list_length(&chptr->members) < rb_dlink_list_length(&client_p->user->channel))
152 {
153 RB_DLINK_FOREACH(ptr, chptr->members.head)
154 {
155 msptr = ptr->data;
156
157 if(msptr->client_p == client_p)
158 return msptr;
159 }
160 }
161 else
162 {
163 RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
164 {
165 msptr = ptr->data;
166
167 if(msptr->chptr == chptr)
168 return msptr;
169 }
170 }
171
172 return NULL;
173 }
174
175 /* find_channel_status()
176 *
177 * input - membership to get status for, whether we can combine flags
178 * output - flags of user on channel
179 * side effects -
180 */
181 const char *
182 find_channel_status(struct membership *msptr, int combine)
183 {
184 static char buffer[5];
185 char *p;
186
187 p = buffer;
188
189 if(is_admin(msptr))
190 {
191 if(!combine)
192 return "!";
193 *p++ = '!';
194 }
195
196 if(is_chanop(msptr))
197 {
198 if(!combine)
199 return "@";
200 *p++ = '@';
201 }
202
203 if(is_halfop(msptr))
204 {
205 if(!combine)
206 return "%";
207 *p++ = '%';
208 }
209
210 if(is_voiced(msptr))
211 *p++ = '+';
212
213 *p = '\0';
214 return buffer;
215 }
216
217 /* is_halfop()
218 *
219 * input - membership to check for halfops
220 * output - 1 if the user is halfopped, 0 if the user is not or halfop
221 * is disabled.
222 * side effects -
223 *
224 */
225 int
226 is_halfop(struct membership *msptr)
227 {
228 if(!ConfigChannel.use_halfop)
229 return 0;
230 if(is_chmode_h(msptr))
231 return 1;
232 else
233 return 0;
234 }
235
236 /* is_admin()
237 *
238 * input - membership to check for admin
239 * output - 1 if the user is an admin, 0 if the user is not or admin
240 * is disabled.
241 * side effects -
242 *
243 */
244 int
245 is_admin(struct membership *msptr)
246 {
247 if(!ConfigChannel.use_admin)
248 return 0;
249 if(is_chmode_a(msptr))
250 return 1;
251 else
252 return 0;
253 }
254
255 /* is_any_op()
256 *
257 * input - membership to check for ops
258 * output - 1 if the user is op, halfop, or admin, 0 elsewise
259 * side effects -
260 */
261 int
262 is_any_op(struct membership *msptr)
263 {
264 if(is_chanop(msptr) || is_halfop(msptr) || is_admin(msptr))
265 return 1;
266 else
267 return 0;
268 }
269
270 /* is_chanop_voiced()
271 *
272 * input - memebership to check for status
273 * output - 1 if the user is op, halfop, admin, or voice, 0 elsewise
274 * side effects -
275 */
276 int
277 is_chanop_voiced(struct membership *msptr)
278 {
279 if(is_chanop(msptr) || is_voiced(msptr) || is_halfop(msptr) || is_admin(msptr))
280 return 1;
281 else
282 return 0;
283 }
284
285 /* can_kick_deop()
286 *
287 * input - two memeberships
288 * output - 1 if the first memebership can kick/deop the second, 0 elsewise
289 * side effects -
290 */
291 int
292 can_kick_deop(struct membership *source, struct membership *target)
293 {
294 if(is_chanop(source) && !is_admin(target))
295 return 1;
296 else if(is_halfop(source) && !is_any_op(target))
297 return 1;
298 else if(is_admin(source))
299 return 1;
300
301 return 0;
302 }
303
304 /* add_user_to_channel()
305 *
306 * input - channel to add client to, client to add, channel flags
307 * output -
308 * side effects - user is added to channel
309 */
310 void
311 add_user_to_channel(struct Channel *chptr, struct Client *client_p, int flags)
312 {
313 struct membership *msptr;
314
315 s_assert(client_p->user != NULL);
316 if(client_p->user == NULL)
317 return;
318
319 msptr = rb_bh_alloc(member_heap);
320
321 msptr->chptr = chptr;
322 msptr->client_p = client_p;
323 msptr->flags = flags;
324
325 rb_dlinkAdd(msptr, &msptr->usernode, &client_p->user->channel);
326 rb_dlinkAdd(msptr, &msptr->channode, &chptr->members);
327
328 if(MyClient(client_p))
329 rb_dlinkAdd(msptr, &msptr->locchannode, &chptr->locmembers);
330 }
331
332 /* remove_user_from_channel()
333 *
334 * input - membership pointer to remove from channel
335 * output -
336 * side effects - membership (thus user) is removed from channel
337 */
338 void
339 remove_user_from_channel(struct membership *msptr)
340 {
341 struct Client *client_p;
342 struct Channel *chptr;
343 s_assert(msptr != NULL);
344 if(msptr == NULL)
345 return;
346
347 client_p = msptr->client_p;
348 chptr = msptr->chptr;
349
350 rb_dlinkDelete(&msptr->usernode, &client_p->user->channel);
351 rb_dlinkDelete(&msptr->channode, &chptr->members);
352
353 if(client_p->servptr == &me)
354 rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
355
356 if(!(chptr->mode.mode & MODE_PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
357 destroy_channel(chptr);
358
359 rb_bh_free(member_heap, msptr);
360
361 return;
362 }
363
364 /* remove_user_from_channels()
365 *
366 * input - user to remove from all channels
367 * output -
368 * side effects - user is removed from all channels
369 */
370 void
371 remove_user_from_channels(struct Client *client_p)
372 {
373 struct Channel *chptr;
374 struct membership *msptr;
375 rb_dlink_node *ptr;
376 rb_dlink_node *next_ptr;
377
378 if(client_p == NULL)
379 return;
380
381 RB_DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->user->channel.head)
382 {
383 msptr = ptr->data;
384 chptr = msptr->chptr;
385
386 rb_dlinkDelete(&msptr->channode, &chptr->members);
387
388 if(client_p->servptr == &me)
389 rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
390
391 if(!(chptr->mode.mode & MODE_PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
392 destroy_channel(chptr);
393
394 rb_bh_free(member_heap, msptr);
395 }
396
397 client_p->user->channel.head = client_p->user->channel.tail = NULL;
398 client_p->user->channel.length = 0;
399 }
400
401 /* invalidate_bancache_user()
402 *
403 * input - user to invalidate ban cache for
404 * output -
405 * side effects - ban cache is invalidated for all memberships of that user
406 * to be used after a nick change
407 */
408 void
409 invalidate_bancache_user(struct Client *client_p)
410 {
411 struct membership *msptr;
412 rb_dlink_node *ptr;
413
414 if(client_p == NULL)
415 return;
416
417 RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
418 {
419 msptr = ptr->data;
420 msptr->bants = 0;
421 msptr->flags &= ~CHFL_BANNED;
422 }
423 }
424
425 /* check_channel_name()
426 *
427 * input - channel name
428 * output - 1 if valid channel name, else 0
429 * side effects -
430 */
431 int
432 check_channel_name(const char *name)
433 {
434 s_assert(name != NULL);
435 if(name == NULL)
436 return 0;
437
438 for (; *name; ++name)
439 {
440 if(!IsChanChar(*name))
441 return 0;
442 }
443
444 return 1;
445 }
446
447 /* free_channel_list()
448 *
449 * input - rb_dlink list to free
450 * output -
451 * side effects - list of b/e/I modes is cleared
452 */
453 void
454 free_channel_list(rb_dlink_list * list)
455 {
456 rb_dlink_node *ptr;
457 rb_dlink_node *next_ptr;
458 struct Ban *actualBan;
459
460 RB_DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
461 {
462 actualBan = ptr->data;
463 free_ban(actualBan);
464 }
465
466 list->head = list->tail = NULL;
467 list->length = 0;
468 }
469
470 /* destroy_channel()
471 *
472 * input - channel to destroy
473 * output -
474 * side effects - channel is obliterated
475 */
476 void
477 destroy_channel(struct Channel *chptr)
478 {
479 rb_dlink_node *ptr, *next_ptr;
480
481 RB_DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->invites.head)
482 {
483 del_invite(chptr, ptr->data);
484 }
485
486 /* free all bans/exceptions/denies */
487 free_channel_list(&chptr->banlist);
488 free_channel_list(&chptr->exceptlist);
489 free_channel_list(&chptr->invexlist);
490 free_channel_list(&chptr->quietlist);
491
492 /* Free the topic */
493 free_topic(chptr);
494
495 rb_dlinkDelete(&chptr->node, &global_channel_list);
496 del_from_channel_hash(chptr->chname, chptr);
497 free_channel(chptr);
498 }
499
500 /* channel_pub_or_secret()
501 *
502 * input - channel
503 * output - "=" if public, "@" if secret, else "*"
504 * side effects -
505 */
506 static const char *
507 channel_pub_or_secret(struct Channel *chptr)
508 {
509 if(PubChannel(chptr))
510 return ("=");
511 else if(SecretChannel(chptr))
512 return ("@");
513 return ("*");
514 }
515
516 /* channel_member_names()
517 *
518 * input - channel to list, client to list to, show endofnames
519 * output -
520 * side effects - client is given list of users on channel
521 */
522 void
523 channel_member_names(struct Channel *chptr, struct Client *client_p, int show_eon)
524 {
525 struct membership *msptr;
526 struct Client *target_p;
527 rb_dlink_node *ptr;
528 char lbuf[BUFSIZE];
529 char *t;
530 int mlen;
531 int tlen;
532 int cur_len;
533 int is_member;
534 int stack = IsCapable(client_p, CLICAP_MULTI_PREFIX);
535
536 if(ShowChannel(client_p, chptr))
537 {
538 is_member = IsMember(client_p, chptr);
539
540 cur_len = mlen = rb_sprintf(lbuf, form_str(RPL_NAMREPLY),
541 me.name, client_p->name,
542 channel_pub_or_secret(chptr), chptr->chname);
543
544 t = lbuf + cur_len;
545
546 RB_DLINK_FOREACH(ptr, chptr->members.head)
547 {
548 msptr = ptr->data;
549 target_p = msptr->client_p;
550
551 if(IsInvisible(target_p) && !is_member)
552 continue;
553
554 /* space, possible "@+" prefix */
555 if(cur_len + strlen(target_p->name) + 3 >= BUFSIZE - 3)
556 {
557 *(t - 1) = '\0';
558 sendto_one(client_p, "%s", lbuf);
559 cur_len = mlen;
560 t = lbuf + mlen;
561 }
562
563 tlen = rb_sprintf(t, "%s%s ", find_channel_status(msptr, stack),
564 target_p->name);
565
566 cur_len += tlen;
567 t += tlen;
568 }
569
570 /* The old behaviour here was to always output our buffer,
571 * even if there are no clients we can show. This happens
572 * when a client does "NAMES" with no parameters, and all
573 * the clients on a -sp channel are +i. I dont see a good
574 * reason for keeping that behaviour, as it just wastes
575 * bandwidth. --anfl
576 */
577 if(cur_len != mlen)
578 {
579 *(t - 1) = '\0';
580 sendto_one(client_p, "%s", lbuf);
581 }
582 }
583
584 if(show_eon)
585 sendto_one(client_p, form_str(RPL_ENDOFNAMES),
586 me.name, client_p->name, chptr->chname);
587 }
588
589 /* del_invite()
590 *
591 * input - channel to remove invite from, client to remove
592 * output -
593 * side effects - user is removed from invite list, if exists
594 */
595 void
596 del_invite(struct Channel *chptr, struct Client *who)
597 {
598 rb_dlinkFindDestroy(who, &chptr->invites);
599 rb_dlinkFindDestroy(chptr, &who->user->invited);
600 }
601
602 /* is_banned()
603 *
604 * input - channel to check bans for, user to check bans against
605 * optional prebuilt buffers
606 * output - 1 if banned, else 0
607 * side effects -
608 */
609 int
610 is_banned(struct Channel *chptr, struct Client *who, struct membership *msptr,
611 const char *s, const char *s2)
612 {
613 char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
614 char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
615 char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
616 char *s3 = NULL;
617 rb_dlink_node *ptr;
618 struct Ban *actualBan = NULL;
619 struct Ban *actualExcept = NULL;
620
621 if(!MyClient(who))
622 return 0;
623
624 /* if the buffers havent been built, do it here */
625 if(s == NULL)
626 {
627 rb_sprintf(src_host, "%s!%s@%s", who->name, who->username, who->host);
628 rb_sprintf(src_iphost, "%s!%s@%s", who->name, who->username, who->sockhost);
629
630 s = src_host;
631 s2 = src_iphost;
632 }
633 if(who->localClient->mangledhost != NULL)
634 {
635 /* if host mangling mode enabled, also check their real host */
636 if(!strcmp(who->host, who->localClient->mangledhost))
637 {
638 rb_sprintf(src_althost, "%s!%s@%s", who->name, who->username, who->orighost);
639 s3 = src_althost;
640 }
641 /* if host mangling mode not enabled and no other spoof,
642 * also check the mangled form of their host */
643 else if (!IsDynSpoof(who))
644 {
645 rb_sprintf(src_althost, "%s!%s@%s", who->name, who->username, who->localClient->mangledhost);
646 s3 = src_althost;
647 }
648 }
649
650 RB_DLINK_FOREACH(ptr, chptr->banlist.head)
651 {
652 actualBan = ptr->data;
653 if(match(actualBan->banstr, s) ||
654 match(actualBan->banstr, s2) ||
655 match_cidr(actualBan->banstr, s2) ||
656 match_extban(actualBan->banstr, who, chptr, CHFL_BAN) ||
657 (s3 != NULL && match(actualBan->banstr, s3)))
658 break;
659 else
660 actualBan = NULL;
661 }
662
663 if((actualBan != NULL) && ConfigChannel.use_except)
664 {
665 RB_DLINK_FOREACH(ptr, chptr->exceptlist.head)
666 {
667 actualExcept = ptr->data;
668
669 /* theyre exempted.. */
670 if(match(actualExcept->banstr, s) ||
671 match(actualExcept->banstr, s2) ||
672 match_cidr(actualExcept->banstr, s2) ||
673 match_extban(actualExcept->banstr, who, chptr, CHFL_EXCEPTION) ||
674 (s3 != NULL && match(actualExcept->banstr, s3)))
675 {
676 /* cache the fact theyre not banned */
677 if(msptr != NULL)
678 {
679 msptr->bants = chptr->bants;
680 msptr->flags &= ~CHFL_BANNED;
681 }
682
683 return CHFL_EXCEPTION;
684 }
685 }
686 }
687
688 /* cache the banned/not banned status */
689 if(msptr != NULL)
690 {
691 msptr->bants = chptr->bants;
692
693 if(actualBan != NULL)
694 {
695 msptr->flags |= CHFL_BANNED;
696 return CHFL_BAN;
697 }
698 else
699 {
700 msptr->flags &= ~CHFL_BANNED;
701 return 0;
702 }
703 }
704
705 return ((actualBan ? CHFL_BAN : 0));
706 }
707
708 /* is_quieted()
709 *
710 * input - channel to check bans for, user to check bans against
711 * optional prebuilt buffers
712 * output - 1 if banned, else 0
713 * side effects -
714 */
715 int
716 is_quieted(struct Channel *chptr, struct Client *who, struct membership *msptr,
717 const char *s, const char *s2)
718 {
719 char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
720 char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
721 char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
722 char *s3 = NULL;
723 rb_dlink_node *ptr;
724 struct Ban *actualBan = NULL;
725 struct Ban *actualExcept = NULL;
726
727 if(!MyClient(who))
728 return 0;
729
730 /* if the buffers havent been built, do it here */
731 if(s == NULL)
732 {
733 rb_sprintf(src_host, "%s!%s@%s", who->name, who->username, who->host);
734 rb_sprintf(src_iphost, "%s!%s@%s", who->name, who->username, who->sockhost);
735
736 s = src_host;
737 s2 = src_iphost;
738 }
739 if(who->localClient->mangledhost != NULL)
740 {
741 /* if host mangling mode enabled, also check their real host */
742 if(!strcmp(who->host, who->localClient->mangledhost))
743 {
744 rb_sprintf(src_althost, "%s!%s@%s", who->name, who->username, who->orighost);
745 s3 = src_althost;
746 }
747 /* if host mangling mode not enabled and no other spoof,
748 * also check the mangled form of their host */
749 else if (!IsDynSpoof(who))
750 {
751 rb_sprintf(src_althost, "%s!%s@%s", who->name, who->username, who->localClient->mangledhost);
752 s3 = src_althost;
753 }
754 }
755
756 RB_DLINK_FOREACH(ptr, chptr->quietlist.head)
757 {
758 actualBan = ptr->data;
759 if(match(actualBan->banstr, s) ||
760 match(actualBan->banstr, s2) ||
761 match_cidr(actualBan->banstr, s2) ||
762 match_extban(actualBan->banstr, who, chptr, CHFL_QUIET) ||
763 (s3 != NULL && match(actualBan->banstr, s3)))
764 break;
765 else
766 actualBan = NULL;
767 }
768
769 if((actualBan != NULL) && ConfigChannel.use_except)
770 {
771 RB_DLINK_FOREACH(ptr, chptr->exceptlist.head)
772 {
773 actualExcept = ptr->data;
774
775 /* theyre exempted.. */
776 if(match(actualExcept->banstr, s) ||
777 match(actualExcept->banstr, s2) ||
778 match_cidr(actualExcept->banstr, s2) ||
779 match_extban(actualExcept->banstr, who, chptr, CHFL_EXCEPTION) ||
780 (s3 != NULL && match(actualExcept->banstr, s3)))
781 {
782 /* cache the fact theyre not banned */
783 if(msptr != NULL)
784 {
785 msptr->bants = chptr->bants;
786 msptr->flags &= ~CHFL_BANNED;
787 }
788
789 return CHFL_EXCEPTION;
790 }
791 }
792 }
793
794 /* cache the banned/not banned status */
795 if(msptr != NULL)
796 {
797 msptr->bants = chptr->bants;
798
799 if(actualBan != NULL)
800 {
801 msptr->flags |= CHFL_BANNED;
802 return CHFL_BAN;
803 }
804 else
805 {
806 msptr->flags &= ~CHFL_BANNED;
807 return 0;
808 }
809 }
810
811 return ((actualBan ? CHFL_BAN : 0));
812 }
813
814 /* can_join()
815 *
816 * input - client to check, channel to check for, key
817 * output - reason for not being able to join, else 0
818 * side effects -
819 */
820 int
821 can_join(struct Client *source_p, struct Channel *chptr, char *key)
822 {
823 rb_dlink_node *invite = NULL;
824 rb_dlink_node *ptr;
825 struct Ban *invex = NULL;
826 char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
827 char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
828 char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
829 char text[10];
830 int use_althost = 0;
831 int i = 0;
832 hook_data_channel moduledata;
833 struct Metadata *md;
834 struct DictionaryIter iter;
835
836 s_assert(source_p->localClient != NULL);
837
838 rb_sprintf(src_host, "%s!%s@%s", source_p->name, source_p->username, source_p->host);
839 rb_sprintf(src_iphost, "%s!%s@%s", source_p->name, source_p->username, source_p->sockhost);
840 if(source_p->localClient->mangledhost != NULL)
841 {
842 /* if host mangling mode enabled, also check their real host */
843 if(!strcmp(source_p->host, source_p->localClient->mangledhost))
844 {
845 rb_sprintf(src_althost, "%s!%s@%s", source_p->name, source_p->username, source_p->orighost);
846 use_althost = 1;
847 }
848 /* if host mangling mode not enabled and no other spoof,
849 * also check the mangled form of their host */
850 else if (!IsDynSpoof(source_p))
851 {
852 rb_sprintf(src_althost, "%s!%s@%s", source_p->name, source_p->username, source_p->localClient->mangledhost);
853 use_althost = 1;
854 }
855 }
856
857 if((is_banned(chptr, source_p, NULL, src_host, src_iphost)) == CHFL_BAN)
858 return (ERR_BANNEDFROMCHAN);
859
860 rb_snprintf(text, sizeof(text), "K%s", source_p->id);
861
862 DICTIONARY_FOREACH(md, &iter, chptr->metadata)
863 {
864 if(!strcmp(md->value, "KICKNOREJOIN") && !strcmp(md->name, text) && (md->timevalue + 2 > rb_current_time()))
865 return ERR_KICKNOREJOIN;
866 /* cleanup any stale KICKNOREJOIN metadata we find while we're at it */
867 if(!strcmp(md->value, "KICKNOREJOIN") && !(md->timevalue + 2 > rb_current_time()))
868 channel_metadata_delete(chptr, md->name, 0);
869 }
870
871 if(chptr->mode.mode & MODE_INVITEONLY)
872 {
873 RB_DLINK_FOREACH(invite, source_p->user->invited.head)
874 {
875 if(invite->data == chptr)
876 break;
877 }
878 if(invite == NULL)
879 {
880 if(!ConfigChannel.use_invex)
881 return (ERR_INVITEONLYCHAN);
882 RB_DLINK_FOREACH(ptr, chptr->invexlist.head)
883 {
884 invex = ptr->data;
885 if(match(invex->banstr, src_host)
886 || match(invex->banstr, src_iphost)
887 || match_cidr(invex->banstr, src_iphost)
888 || match_extban(invex->banstr, source_p, chptr, CHFL_INVEX)
889 || (use_althost && match(invex->banstr, src_althost)))
890 break;
891 }
892 if(ptr == NULL)
893 return (ERR_INVITEONLYCHAN);
894 }
895 }
896
897 if(*chptr->mode.key && (EmptyString(key) || irccmp(chptr->mode.key, key)))
898 return (ERR_BADCHANNELKEY);
899
900 if(chptr->mode.limit &&
901 rb_dlink_list_length(&chptr->members) >= (unsigned long) chptr->mode.limit)
902 i = ERR_CHANNELISFULL;
903 if(chptr->mode.mode & MODE_REGONLY && EmptyString(source_p->user->suser))
904 i = ERR_NEEDREGGEDNICK;
905 /* join throttling stuff --nenolod */
906 else if(chptr->mode.join_num > 0 && chptr->mode.join_time > 0)
907 {
908 if ((rb_current_time() - chptr->join_delta <=
909 chptr->mode.join_time) && (chptr->join_count >=
910 chptr->mode.join_num))
911 i = ERR_THROTTLE;
912 }
913
914 /* allow /invite to override +l/+r/+j also -- jilles */
915 if (i != 0 && invite == NULL)
916 {
917 RB_DLINK_FOREACH(invite, source_p->user->invited.head)
918 {
919 if(invite->data == chptr)
920 break;
921 }
922 if (invite == NULL)
923 return i;
924 }
925
926 moduledata.client = source_p;
927 moduledata.chptr = chptr;
928 moduledata.approved = 0;
929
930 call_hook(h_can_join, &moduledata);
931
932 return moduledata.approved;
933 }
934
935 /* can_send()
936 *
937 * input - user to check in channel, membership pointer
938 * output - whether can explicitly send or not, else CAN_SEND_NONOP
939 * side effects -
940 */
941 int
942 can_send(struct Channel *chptr, struct Client *source_p, struct membership *msptr)
943 {
944 if(IsServer(source_p) || IsService(source_p))
945 return CAN_SEND_OPV;
946
947 if(MyClient(source_p) && hash_find_resv(chptr->chname) &&
948 !IsOper(source_p) && !IsExemptResv(source_p))
949 return CAN_SEND_NO;
950
951 if(msptr == NULL)
952 {
953 msptr = find_channel_membership(chptr, source_p);
954
955 if(msptr == NULL)
956 {
957 /* if its +m or +n and theyre not in the channel,
958 * they cant send. we dont check bans here because
959 * theres no possibility of caching them --fl
960 */
961 if(chptr->mode.mode & MODE_NOPRIVMSGS || chptr->mode.mode & MODE_MODERATED)
962 return CAN_SEND_NO;
963 else
964 return CAN_SEND_NONOP;
965 }
966 }
967
968 if(is_chanop_voiced(msptr))
969 return CAN_SEND_OPV;
970
971 if(chptr->mode.mode & MODE_MODERATED)
972 return CAN_SEND_NO;
973
974 if(MyClient(source_p))
975 {
976 /* cached can_send */
977 if(msptr->bants == chptr->bants)
978 {
979 if(can_send_banned(msptr))
980 return CAN_SEND_NO;
981 }
982 else if(is_banned(chptr, source_p, msptr, NULL, NULL) == CHFL_BAN
983 || is_quieted(chptr, source_p, msptr, NULL, NULL) == CHFL_BAN)
984 return CAN_SEND_NO;
985 }
986
987 return CAN_SEND_NONOP;
988 }
989
990 /* find_bannickchange_channel()
991 * Input: client to check
992 * Output: channel preventing nick change
993 */
994 struct Channel *
995 find_bannickchange_channel(struct Client *client_p)
996 {
997 struct Channel *chptr;
998 struct membership *msptr;
999 rb_dlink_node *ptr;
1000 char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
1001 char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
1002
1003 if (!MyClient(client_p) || IsOverride(client_p))
1004 return NULL;
1005
1006 rb_sprintf(src_host, "%s!%s@%s", client_p->name, client_p->username, client_p->host);
1007 rb_sprintf(src_iphost, "%s!%s@%s", client_p->name, client_p->username, client_p->sockhost);
1008
1009 RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
1010 {
1011 msptr = ptr->data;
1012 chptr = msptr->chptr;
1013 if (is_chanop_voiced(msptr))
1014 continue;
1015 /* cached can_send */
1016 if (msptr->bants == chptr->bants)
1017 {
1018 if (can_send_banned(msptr))
1019 return chptr;
1020 }
1021 else if (is_banned(chptr, client_p, msptr, src_host, src_iphost) == CHFL_BAN
1022 || is_quieted(chptr, client_p, msptr, src_host, src_iphost) == CHFL_BAN)
1023 return chptr;
1024 }
1025 return NULL;
1026 }
1027
1028 /* find_nonickchange_channel()
1029 * Input: client to check
1030 * Output: channel preventing nick change
1031 */
1032 struct Channel *
1033 find_nonickchange_channel(struct Client *client_p)
1034 {
1035 struct Channel *chptr;
1036 struct membership *msptr;
1037 rb_dlink_node *ptr;
1038
1039 if (!MyClient(client_p))
1040 return NULL;
1041
1042 RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
1043 {
1044 msptr = ptr->data;
1045 chptr = msptr->chptr;
1046 if (chptr->mode.mode & MODE_NONICK && (!ConfigChannel.exempt_cmode_N || !is_any_op(msptr)))
1047 return chptr;
1048 }
1049 return NULL;
1050 }
1051
1052 /* void check_spambot_warning(struct Client *source_p)
1053 * Input: Client to check, channel name or NULL if this is a part.
1054 * Output: none
1055 * Side-effects: Updates the client's oper_warn_count_down, warns the
1056 * IRC operators if necessary, and updates join_leave_countdown as
1057 * needed.
1058 */
1059 void
1060 check_spambot_warning(struct Client *source_p, const char *name)
1061 {
1062 int t_delta;
1063 int decrement_count;
1064 if((GlobalSetOptions.spam_num &&
1065 (source_p->localClient->join_leave_count >= GlobalSetOptions.spam_num)))
1066 {
1067 if(source_p->localClient->oper_warn_count_down > 0)
1068 source_p->localClient->oper_warn_count_down--;
1069 else
1070 source_p->localClient->oper_warn_count_down = 0;
1071 if(source_p->localClient->oper_warn_count_down == 0 &&
1072 name != NULL)
1073 {
1074 /* Its already known as a possible spambot */
1075 sendto_realops_snomask(SNO_BOTS, L_NETWIDE,
1076 "User %s (%s@%s) trying to join %s is a possible spambot",
1077 source_p->name,
1078 source_p->username, source_p->orighost, name);
1079 source_p->localClient->oper_warn_count_down = OPER_SPAM_COUNTDOWN;
1080 }
1081 }
1082 else
1083 {
1084 if((t_delta =
1085 (rb_current_time() - source_p->localClient->last_leave_time)) >
1086 JOIN_LEAVE_COUNT_EXPIRE_TIME)
1087 {
1088 decrement_count = (t_delta / JOIN_LEAVE_COUNT_EXPIRE_TIME);
1089 if(name != NULL)
1090 ;
1091 else if(decrement_count > source_p->localClient->join_leave_count)
1092 source_p->localClient->join_leave_count = 0;
1093 else
1094 source_p->localClient->join_leave_count -= decrement_count;
1095 }
1096 else
1097 {
1098 if((rb_current_time() -
1099 (source_p->localClient->last_join_time)) < GlobalSetOptions.spam_time)
1100 {
1101 /* oh, its a possible spambot */
1102 source_p->localClient->join_leave_count++;
1103 }
1104 }
1105 if(name != NULL)
1106 source_p->localClient->last_join_time = rb_current_time();
1107 else
1108 source_p->localClient->last_leave_time = rb_current_time();
1109 }
1110 }
1111
1112 /* check_splitmode()
1113 *
1114 * input -
1115 * output -
1116 * side effects - compares usercount and servercount against their split
1117 * values and adjusts splitmode accordingly
1118 */
1119 void
1120 check_splitmode(void *unused)
1121 {
1122 if(splitchecking && (ConfigChannel.no_join_on_split || ConfigChannel.no_create_on_split))
1123 {
1124 /* not split, we're being asked to check now because someone
1125 * has left
1126 */
1127 if(!splitmode)
1128 {
1129 if(eob_count < split_servers || Count.total < split_users)
1130 {
1131 splitmode = 1;
1132 sendto_realops_snomask(SNO_GENERAL, L_ALL,
1133 "Network split, activating splitmode");
1134 check_splitmode_ev = rb_event_addish("check_splitmode", check_splitmode, NULL, 2);
1135 }
1136 }
1137 /* in splitmode, check whether its finished */
1138 else if(eob_count >= split_servers && Count.total >= split_users)
1139 {
1140 splitmode = 0;
1141
1142 sendto_realops_snomask(SNO_GENERAL, L_ALL,
1143 "Network rejoined, deactivating splitmode");
1144
1145 rb_event_delete(check_splitmode_ev);
1146 check_splitmode_ev = NULL;
1147 }
1148 }
1149 }
1150
1151
1152 /* allocate_topic()
1153 *
1154 * input - channel to allocate topic for
1155 * output - 1 on success, else 0
1156 * side effects - channel gets a topic allocated
1157 */
1158 static void
1159 allocate_topic(struct Channel *chptr)
1160 {
1161 void *ptr;
1162
1163 if(chptr == NULL)
1164 return;
1165
1166 ptr = rb_bh_alloc(topic_heap);
1167
1168 /* Basically we allocate one large block for the topic and
1169 * the topic info. We then split it up into two and shove it
1170 * in the chptr
1171 */
1172 chptr->topic = ptr;
1173 chptr->topic_info = (char *) ptr + TOPICLEN + 1;
1174 *chptr->topic = '\0';
1175 *chptr->topic_info = '\0';
1176 }
1177
1178 /* free_topic()
1179 *
1180 * input - channel which has topic to free
1181 * output -
1182 * side effects - channels topic is free'd
1183 */
1184 static void
1185 free_topic(struct Channel *chptr)
1186 {
1187 void *ptr;
1188
1189 if(chptr == NULL || chptr->topic == NULL)
1190 return;
1191
1192 /* This is safe for now - If you change allocate_topic you
1193 * MUST change this as well
1194 */
1195 ptr = chptr->topic;
1196 rb_bh_free(topic_heap, ptr);
1197 chptr->topic = NULL;
1198 chptr->topic_info = NULL;
1199 }
1200
1201 /* set_channel_topic()
1202 *
1203 * input - channel, topic to set, topic info and topic ts
1204 * output -
1205 * side effects - channels topic, topic info and TS are set.
1206 */
1207 void
1208 set_channel_topic(struct Channel *chptr, const char *topic, const char *topic_info, time_t topicts)
1209 {
1210 if(strlen(topic) > 0)
1211 {
1212 if(chptr->topic == NULL)
1213 allocate_topic(chptr);
1214 rb_strlcpy(chptr->topic, topic, TOPICLEN + 1);
1215 rb_strlcpy(chptr->topic_info, topic_info, USERHOST_REPLYLEN);
1216 chptr->topic_time = topicts;
1217 }
1218 else
1219 {
1220 if(chptr->topic != NULL)
1221 free_topic(chptr);
1222 chptr->topic_time = 0;
1223 }
1224 }
1225
1226 /* has_common_channel()
1227 *
1228 * input - pointer to client
1229 * - pointer to another client
1230 * output - 1 if the two have a channel in common, 0 elsewise
1231 * side effects - none
1232 */
1233 int
1234 has_common_channel(struct Client *client1, struct Client *client2)
1235 {
1236 rb_dlink_node *ptr;
1237
1238 RB_DLINK_FOREACH(ptr, client1->user->channel.head)
1239 {
1240 if(IsMember(client2, ((struct membership *)ptr->data)->chptr))
1241 return 1;
1242 }
1243 return 0;
1244 }
1245
1246 /* channel_modes()
1247 *
1248 * inputs - pointer to channel
1249 * - pointer to client
1250 * output - string with simple modes
1251 * side effects - result from previous calls overwritten
1252 *
1253 * Stolen from ShadowIRCd 4 --nenolod
1254 */
1255 const char *
1256 channel_modes(struct Channel *chptr, struct Client *client_p)
1257 {
1258 int i;
1259 char buf1[BUFSIZE];
1260 char buf2[BUFSIZE];
1261 static char final[BUFSIZE];
1262 char *mbuf = buf1;
1263 char *pbuf = buf2;
1264
1265 *mbuf++ = '+';
1266 *pbuf = '\0';
1267
1268 for (i = 0; i < 256; i++)
1269 {
1270 if(chmode_table[i].set_func == chm_hidden && !IsOper(client_p) && IsClient(client_p))
1271 continue;
1272 if(chptr->mode.mode & chmode_flags[i])
1273 *mbuf++ = i;
1274 }
1275
1276 if(chptr->mode.limit)
1277 {
1278 *mbuf++ = 'l';
1279
1280 if(!IsClient(client_p) || IsMember(client_p, chptr))
1281 pbuf += rb_sprintf(pbuf, " %d", chptr->mode.limit);
1282 }
1283
1284 if(*chptr->mode.key)
1285 {
1286 *mbuf++ = 'k';
1287
1288 if(pbuf > buf2 || !IsClient(client_p) || IsMember(client_p, chptr))
1289 pbuf += rb_sprintf(pbuf, " %s", chptr->mode.key);
1290 }
1291
1292 if(chptr->mode.join_num)
1293 {
1294 *mbuf++ = 'j';
1295
1296 if(pbuf > buf2 || !IsClient(client_p) || IsMember(client_p, chptr))
1297 pbuf += rb_sprintf(pbuf, " %d:%d", chptr->mode.join_num,
1298 chptr->mode.join_time);
1299 }
1300
1301 if(*chptr->mode.forward && (ConfigChannel.use_forward || !IsClient(client_p)))
1302 {
1303 *mbuf++ = 'f';
1304
1305 if(pbuf > buf2 || !IsClient(client_p) || IsMember(client_p, chptr))
1306 pbuf += rb_sprintf(pbuf, " %s", chptr->mode.forward);
1307 }
1308
1309 *mbuf = '\0';
1310
1311 rb_strlcpy(final, buf1, sizeof final);
1312 rb_strlcat(final, buf2, sizeof final);
1313 return final;
1314 }
1315
1316 /* Now lets do some stuff to keep track of what combinations of
1317 * servers exist...
1318 * Note that the number of combinations doubles each time you add
1319 * something to this list. Each one is only quick if no servers use that
1320 * combination, but if the numbers get too high here MODE will get too
1321 * slow. I suggest if you get more than 7 here, you consider getting rid
1322 * of some and merging or something. If it wasn't for irc+cs we would
1323 * probably not even need to bother about most of these, but unfortunately
1324 * we do. -A1kmm
1325 */
1326
1327 /* void init_chcap_usage_counts(void)
1328 *
1329 * Inputs - none
1330 * Output - none
1331 * Side-effects - Initialises the usage counts to zero. Fills in the
1332 * chcap_yes and chcap_no combination tables.
1333 */
1334 void
1335 init_chcap_usage_counts(void)
1336 {
1337 unsigned long m, c, y, n;
1338
1339 memset(chcap_combos, 0, sizeof(chcap_combos));
1340
1341 /* For every possible combination */
1342 for (m = 0; m < NCHCAP_COMBOS; m++)
1343 {
1344 /* Check each capab */
1345 for (c = y = n = 0; c < NCHCAPS; c++)
1346 {
1347 if((m & (1 << c)) == 0)
1348 n |= channel_capabs[c];
1349 else
1350 y |= channel_capabs[c];
1351 }
1352 chcap_combos[m].cap_yes = y;
1353 chcap_combos[m].cap_no = n;
1354 }
1355 }
1356
1357 /* void set_chcap_usage_counts(struct Client *serv_p)
1358 * Input: serv_p; The client whose capabs to register.
1359 * Output: none
1360 * Side-effects: Increments the usage counts for the correct capab
1361 * combination.
1362 */
1363 void
1364 set_chcap_usage_counts(struct Client *serv_p)
1365 {
1366 int n;
1367
1368 for (n = 0; n < NCHCAP_COMBOS; n++)
1369 {
1370 if(IsCapable(serv_p, chcap_combos[n].cap_yes) &&
1371 NotCapable(serv_p, chcap_combos[n].cap_no))
1372 {
1373 chcap_combos[n].count++;
1374 return;
1375 }
1376 }
1377
1378 /* This should be impossible -A1kmm. */
1379 s_assert(0);
1380 }
1381
1382 /* void set_chcap_usage_counts(struct Client *serv_p)
1383 *
1384 * Inputs - serv_p; The client whose capabs to register.
1385 * Output - none
1386 * Side-effects - Decrements the usage counts for the correct capab
1387 * combination.
1388 */
1389 void
1390 unset_chcap_usage_counts(struct Client *serv_p)
1391 {
1392 int n;
1393
1394 for (n = 0; n < NCHCAP_COMBOS; n++)
1395 {
1396 if(IsCapable(serv_p, chcap_combos[n].cap_yes) &&
1397 NotCapable(serv_p, chcap_combos[n].cap_no))
1398 {
1399 /* Hopefully capabs can't change dynamically or anything... */
1400 s_assert(chcap_combos[n].count > 0);
1401
1402 if(chcap_combos[n].count > 0)
1403 chcap_combos[n].count--;
1404 return;
1405 }
1406 }
1407
1408 /* This should be impossible -A1kmm. */
1409 s_assert(0);
1410 }
1411
1412 /* void send_cap_mode_changes(struct Client *client_p,
1413 * struct Client *source_p,
1414 * struct Channel *chptr, int cap, int nocap)
1415 * Input: The client sending(client_p), the source client(source_p),
1416 * the channel to send mode changes for(chptr)
1417 * Output: None.
1418 * Side-effects: Sends the appropriate mode changes to capable servers.
1419 *
1420 * Reverted back to my original design, except that we now keep a count
1421 * of the number of servers which each combination as an optimisation, so
1422 * the capabs combinations which are not needed are not worked out. -A1kmm
1423 */
1424 void
1425 send_cap_mode_changes(struct Client *client_p, struct Client *source_p,
1426 struct Channel *chptr, struct ChModeChange mode_changes[], int mode_count)
1427 {
1428 static char modebuf[BUFSIZE];
1429 static char parabuf[BUFSIZE];
1430 int i, mbl, pbl, nc, mc, preflen, len;
1431 char *pbuf;
1432 const char *arg;
1433 int dir;
1434 int j;
1435 int cap;
1436 int nocap;
1437 int arglen;
1438
1439 /* Now send to servers... */
1440 for (j = 0; j < NCHCAP_COMBOS; j++)
1441 {
1442 if(chcap_combos[j].count == 0)
1443 continue;
1444
1445 mc = 0;
1446 nc = 0;
1447 pbl = 0;
1448 parabuf[0] = 0;
1449 pbuf = parabuf;
1450 dir = MODE_QUERY;
1451
1452 cap = chcap_combos[j].cap_yes;
1453 nocap = chcap_combos[j].cap_no;
1454
1455 mbl = preflen = rb_sprintf(modebuf, ":%s TMODE %ld %s ",
1456 use_id(source_p), (long) chptr->channelts,
1457 chptr->chname);
1458
1459 /* loop the list of - modes we have */
1460 for (i = 0; i < mode_count; i++)
1461 {
1462 /* if they dont support the cap we need, or they do support a cap they
1463 * cant have, then dont add it to the modebuf.. that way they wont see
1464 * the mode
1465 */
1466 if((mode_changes[i].letter == 0) ||
1467 ((cap & mode_changes[i].caps) != mode_changes[i].caps)
1468 || ((nocap & mode_changes[i].nocaps) != mode_changes[i].nocaps))
1469 continue;
1470
1471 if(!EmptyString(mode_changes[i].id))
1472 arg = mode_changes[i].id;
1473 else
1474 arg = mode_changes[i].arg;
1475
1476 if(arg)
1477 {
1478 arglen = strlen(arg);
1479
1480 /* dont even think about it! --fl */
1481 if(arglen > MODEBUFLEN - 5)
1482 continue;
1483 }
1484
1485 /* if we're creeping past the buf size, we need to send it and make
1486 * another line for the other modes
1487 * XXX - this could give away server topology with uids being
1488 * different lengths, but not much we can do, except possibly break
1489 * them as if they were the longest of the nick or uid at all times,
1490 * which even then won't work as we don't always know the uid -A1kmm.
1491 */
1492 if(arg && ((mc == MAXMODEPARAMSSERV) ||
1493 ((mbl + pbl + arglen + 4) > (BUFSIZE - 3))))
1494 {
1495 if(nc != 0)
1496 sendto_server(client_p, chptr, cap, nocap,
1497 "%s %s", modebuf, parabuf);
1498 nc = 0;
1499 mc = 0;
1500
1501 mbl = preflen;
1502 pbl = 0;
1503 pbuf = parabuf;
1504 parabuf[0] = 0;
1505 dir = MODE_QUERY;
1506 }
1507
1508 if(dir != mode_changes[i].dir)
1509 {
1510 modebuf[mbl++] = (mode_changes[i].dir == MODE_ADD) ? '+' : '-';
1511 dir = mode_changes[i].dir;
1512 }
1513
1514 modebuf[mbl++] = mode_changes[i].letter;
1515 modebuf[mbl] = 0;
1516 nc++;
1517
1518 if(arg != NULL)
1519 {
1520 len = rb_sprintf(pbuf, "%s ", arg);
1521 pbuf += len;
1522 pbl += len;
1523 mc++;
1524 }
1525 }
1526
1527 if(pbl && parabuf[pbl - 1] == ' ')
1528 parabuf[pbl - 1] = 0;
1529
1530 if(nc != 0)
1531 sendto_server(client_p, chptr, cap, nocap, "%s %s", modebuf, parabuf);
1532 }
1533 }
1534
1535 void
1536 resv_chan_forcepart(const char *name, const char *reason, int temp_time)
1537 {
1538 rb_dlink_node *ptr;
1539 rb_dlink_node *next_ptr;
1540 struct Channel *chptr;
1541 struct membership *msptr;
1542 struct Client *target_p;
1543
1544 if(!ConfigChannel.resv_forcepart)
1545 return;
1546
1547 /* for each user on our server in the channel list
1548 * send them a PART, and notify opers.
1549 */
1550 chptr = find_channel(name);
1551 if(chptr != NULL)
1552 {
1553 RB_DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->locmembers.head)
1554 {
1555 msptr = ptr->data;
1556 target_p = msptr->client_p;
1557
1558 if(IsExemptResv(target_p))
1559 continue;
1560
1561 sendto_server(target_p, chptr, CAP_TS6, NOCAPS,
1562 ":%s PART %s", target_p->id, chptr->chname);
1563
1564 sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s :%s",
1565 target_p->name, target_p->username,
1566 target_p->host, chptr->chname, target_p->name);
1567
1568 remove_user_from_channel(msptr);
1569
1570 /* notify opers & user they were removed from the channel */
1571 sendto_realops_snomask(SNO_GENERAL, L_ALL,
1572 "Forced PART for %s!%s@%s from %s (%s)",
1573 target_p->name, target_p->username,
1574 target_p->host, name, reason);
1575
1576 if(temp_time > 0)
1577 sendto_one_notice(target_p, ":*** Channel %s is temporarily unavailable on this server.",
1578 name);
1579 else
1580 sendto_one_notice(target_p, ":*** Channel %s is no longer available on this server.",
1581 name);
1582 }
1583 }
1584 }
1585
1586 /* Check what we will forward to, without sending any notices to the user
1587 * -- jilles
1588 */
1589 struct Channel *
1590 check_forward(struct Client *source_p, struct Channel *chptr,
1591 char *key)
1592 {
1593 int depth = 0, i;
1594
1595 /* User is +Q */
1596 if (IsNoForward(source_p))
1597 return NULL;
1598
1599 while (depth < 16)
1600 {
1601 chptr = find_channel(chptr->mode.forward);
1602 /* Can only forward to existing channels */
1603 if (chptr == NULL)
1604 return NULL;
1605 /* Already on there, show original error message */
1606 if (IsMember(source_p, chptr))
1607 return NULL;
1608 /* Juped. Sending a warning notice would be unfair */
1609 if (hash_find_resv(chptr->chname))
1610 return NULL;
1611 /* Don't forward to +Q channel */
1612 if (chptr->mode.mode & MODE_DISFORWARD)
1613 return NULL;
1614 i = can_join(source_p, chptr, key);
1615 if (i == 0)
1616 return chptr;
1617 if (i != ERR_INVITEONLYCHAN && i != ERR_NEEDREGGEDNICK && i != ERR_THROTTLE && i != ERR_CHANNELISFULL)
1618 return NULL;
1619 depth++;
1620 }
1621
1622 return NULL;
1623 }
1624
1625 /*
1626 * do_join_0
1627 *
1628 * inputs - pointer to client doing join 0
1629 * output - NONE
1630 * side effects - Use has decided to join 0. This is legacy
1631 * from the days when channels were numbers not names. *sigh*
1632 */
1633 void
1634 do_join_0(struct Client *client_p, struct Client *source_p)
1635 {
1636 struct membership *msptr;
1637 struct Channel *chptr = NULL;
1638 rb_dlink_node *ptr;
1639
1640 /* Finish the flood grace period... */
1641 if(MyClient(source_p) && !IsFloodDone(source_p))
1642 flood_endgrace(source_p);
1643
1644 sendto_server(client_p, NULL, CAP_TS6, NOCAPS, ":%s JOIN 0", use_id(source_p));
1645
1646 while((ptr = source_p->user->channel.head))
1647 {
1648 if(source_p->user->channel.head && MyConnect(source_p) &&
1649 !IsOper(source_p) && !IsExemptSpambot(source_p))
1650 check_spambot_warning(source_p, NULL);
1651
1652 msptr = ptr->data;
1653 chptr = msptr->chptr;
1654 sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s",
1655 source_p->name,
1656 source_p->username, source_p->host, chptr->chname);
1657 remove_user_from_channel(msptr);
1658 }
1659 }
1660
1661 int
1662 check_channel_name_loc(struct Client *source_p, const char *name)
1663 {
1664 const char *p;
1665
1666 s_assert(name != NULL);
1667 if(EmptyString(name))
1668 return 0;
1669
1670 if(ConfigFileEntry.disable_fake_channels && !IsOper(source_p))
1671 {
1672 for(p = name; *p; ++p)
1673 {
1674 if(!IsChanChar(*p) || IsFakeChanChar(*p))
1675 return 0;
1676 }
1677 }
1678 else
1679 {
1680 for(p = name; *p; ++p)
1681 {
1682 if(!IsChanChar(*p))
1683 return 0;
1684 }
1685 }
1686
1687 if(ConfigChannel.only_ascii_channels)
1688 {
1689 for(p = name; *p; ++p)
1690 if(*p < 33 || *p > 126)
1691 return 0;
1692 }
1693
1694
1695 return 1;
1696 }
1697
1698 void user_join(struct Client * client_p, struct Client * source_p, const char * channels, const char * keys)
1699 {
1700 static char jbuf[BUFSIZE];
1701 struct Channel *chptr = NULL;
1702 struct ConfItem *aconf;
1703 char *name;
1704 char *key = NULL;
1705 const char *modes;
1706 int i, flags = 0;
1707 char *p = NULL, *p2 = NULL;
1708 char *chanlist;
1709 char *mykey;
1710
1711 jbuf[0] = '\0';
1712
1713 if(channels == NULL)
1714 return;
1715
1716 /* rebuild the list of channels theyre supposed to be joining.
1717 * this code has a side effect of losing keys, but..
1718 */
1719 chanlist = LOCAL_COPY(channels);
1720 for(name = rb_strtok_r(chanlist, ",", &p); name; name = rb_strtok_r(NULL, ",", &p))
1721 {
1722 /* check the length and name of channel is ok */
1723 if(!check_channel_name_loc(source_p, name) || (strlen(name) > LOC_CHANNELLEN))
1724 {
1725 sendto_one_numeric(source_p, ERR_BADCHANNAME,
1726 form_str(ERR_BADCHANNAME), (unsigned char *) name);
1727 continue;
1728 }
1729
1730 /* join 0 parts all channels */
1731 if(*name == '0' && (name[1] == ',' || name[1] == '\0') && name == chanlist)
1732 {
1733 (void) strcpy(jbuf, "0");
1734 continue;
1735 }
1736
1737 /* check it begins with # or &, and local chans are disabled */
1738 else if(!IsChannelName(name) ||
1739 ( !ConfigChannel.use_local_channels && name[0] == '&'))
1740 {
1741 sendto_one_numeric(source_p, ERR_NOSUCHCHANNEL,
1742 form_str(ERR_NOSUCHCHANNEL), name);
1743 continue;
1744 }
1745
1746 /* see if its resv'd */
1747 if(!IsExemptResv(source_p) && (aconf = hash_find_resv(name)))
1748 {
1749 sendto_one_numeric(source_p, ERR_BADCHANNAME,
1750 form_str(ERR_BADCHANNAME), name);
1751
1752 /* dont warn for opers */
1753 if(!IsExemptJupe(source_p) && !IsOper(source_p))
1754 sendto_realops_snomask(SNO_SPY, L_NETWIDE,
1755 "User %s (%s@%s) is attempting to join locally juped channel %s (%s)",
1756 source_p->name, source_p->username,
1757 source_p->orighost, name, aconf->passwd);
1758 /* dont update tracking for jupe exempt users, these
1759 * are likely to be spamtrap leaves
1760 */
1761 else if(IsExemptJupe(source_p))
1762 aconf->port--;
1763
1764 continue;
1765 }
1766
1767 if(splitmode && !IsOper(source_p) && (*name != '&') &&
1768 ConfigChannel.no_join_on_split)
1769 {
1770 sendto_one(source_p, form_str(ERR_UNAVAILRESOURCE),
1771 me.name, source_p->name, name);
1772 continue;
1773 }
1774
1775 if(*jbuf)
1776 (void) strcat(jbuf, ",");
1777 (void) rb_strlcat(jbuf, name, sizeof(jbuf));
1778 }
1779
1780 if(keys != NULL)
1781 {
1782 mykey = LOCAL_COPY(keys);
1783 key = rb_strtok_r(mykey, ",", &p2);
1784 }
1785
1786 for(name = rb_strtok_r(jbuf, ",", &p); name;
1787 key = (key) ? rb_strtok_r(NULL, ",", &p2) : NULL, name = rb_strtok_r(NULL, ",", &p))
1788 {
1789 hook_data_channel_activity hook_info;
1790
1791 /* JOIN 0 simply parts all channels the user is in */
1792 if(*name == '0' && !atoi(name))
1793 {
1794 if(source_p->user->channel.head == NULL)
1795 continue;
1796
1797 do_join_0(&me, source_p);
1798 continue;
1799 }
1800
1801 /* look for the channel */
1802 if((chptr = find_channel(name)) != NULL)
1803 {
1804 if(IsMember(source_p, chptr))
1805 continue;
1806
1807 flags = 0;
1808 }
1809 else
1810 {
1811 hook_data_client_approval moduledata;
1812
1813 moduledata.client = source_p;
1814 moduledata.approved = 0;
1815
1816 call_hook(h_can_create_channel, &moduledata);
1817
1818 if(moduledata.approved != 0)
1819 {
1820 sendto_one(source_p, form_str(moduledata.approved),
1821 me.name, source_p->name, name);
1822 continue;
1823 }
1824
1825 if(splitmode && !IsOper(source_p) && (*name != '&') &&
1826 ConfigChannel.no_create_on_split)
1827 {
1828 sendto_one(source_p, form_str(ERR_UNAVAILRESOURCE),
1829 me.name, source_p->name, name);
1830 continue;
1831 }
1832
1833 if(ConfigChannel.admin_on_channel_create && ConfigChannel.use_admin)
1834 flags = CHFL_ADMIN | CHFL_CHANOP;
1835 else
1836 flags = CHFL_CHANOP;
1837 }
1838
1839 if((rb_dlink_list_length(&source_p->user->channel) >=
1840 (unsigned long) ConfigChannel.max_chans_per_user) &&
1841 (!IsOper(source_p) ||
1842 (rb_dlink_list_length(&source_p->user->channel) >=
1843 (unsigned long) ConfigChannel.max_chans_per_user * 3)))
1844 {
1845 sendto_one(source_p, form_str(ERR_TOOMANYCHANNELS),
1846 me.name, source_p->name, name);
1847 return;
1848 }
1849
1850 if(chptr == NULL) /* If I already have a chptr, no point doing this */
1851 {
1852 chptr = get_or_create_channel(source_p, name, NULL);
1853
1854 if(chptr == NULL)
1855 {
1856 sendto_one(source_p, form_str(ERR_UNAVAILRESOURCE),
1857 me.name, source_p->name, name);
1858 continue;
1859 }
1860 }
1861
1862 /* can_join checks for +i key, bans etc */
1863 if((i = can_join(source_p, chptr, key)))
1864 {
1865 if(IsOverride(source_p))
1866 {
1867 sendto_wallops_flags(UMODE_WALLOP, &me,
1868 "%s is overriding JOIN to [%s]",
1869 get_oper_name(source_p), chptr->chname);
1870 sendto_server(NULL, chptr, NOCAPS, NOCAPS,
1871 ":%s WALLOPS :%s is overriding JOIN to [%s]",
1872 me.name, get_oper_name(source_p), chptr->chname);
1873 }
1874 else if ((i != ERR_NEEDREGGEDNICK && i != ERR_THROTTLE && i != ERR_INVITEONLYCHAN && i != ERR_CHANNELISFULL) ||
1875 (!ConfigChannel.use_forward || (chptr = check_forward(source_p, chptr, key)) == NULL))
1876 {
1877 /* might be wrong, but is there any other better location for such?
1878 * see extensions/chm_operonly.c for other comments on this
1879 * -- dwr
1880 */
1881 if(i != ERR_CUSTOM)
1882 sendto_one(source_p, form_str(i), me.name, source_p->name, name);
1883
1884 continue;
1885 }
1886 else
1887 sendto_one_numeric(source_p, ERR_LINKCHANNEL, form_str(ERR_LINKCHANNEL), name, chptr->chname);
1888 }
1889
1890 if(flags == 0 &&
1891 !IsOper(source_p) && !IsExemptSpambot(source_p))
1892 check_spambot_warning(source_p, name);
1893
1894 /* add the user to the channel */
1895 add_user_to_channel(chptr, source_p, flags);
1896 if (chptr->mode.join_num &&
1897 rb_current_time() - chptr->join_delta >= chptr->mode.join_time)
1898 {
1899 chptr->join_count = 0;
1900 chptr->join_delta = rb_current_time();
1901 }
1902 chptr->join_count++;
1903
1904 /* we send the user their join here, because we could have to
1905 * send a mode out next.
1906 */
1907 sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s JOIN :%s",
1908 source_p->name,
1909 source_p->username, source_p->host, chptr->chname);
1910
1911 /* its a new channel, set +nt and burst. */
1912 if(flags & CHFL_CHANOP)
1913 {
1914 chptr->channelts = rb_current_time();
1915
1916 /* autochanmodes stuff */
1917 if(ConfigChannel.autochanmodes)
1918 {
1919 char * ch;
1920 for(ch = ConfigChannel.autochanmodes; *ch; *ch++)
1921 {
1922 chptr->mode.mode |= chmode_table[*ch].mode_type;
1923 }
1924 }
1925 else
1926 {
1927 chptr->mode.mode |= MODE_TOPICLIMIT;
1928 chptr->mode.mode |= MODE_NOPRIVMSGS;
1929 }
1930
1931 modes = channel_modes(chptr, &me);
1932
1933 sendto_channel_local(ONLY_CHANOPS, chptr, ":%s MODE %s %s",
1934 me.name, chptr->chname, modes);
1935
1936 sendto_server(client_p, chptr, CAP_TS6, NOCAPS,
1937 ":%s SJOIN %ld %s %s :@%s",
1938 me.id, (long) chptr->channelts,
1939 chptr->chname, modes, source_p->id);
1940 }
1941 else
1942 {
1943 sendto_server(client_p, chptr, CAP_TS6, NOCAPS,
1944 ":%s JOIN %ld %s +",
1945 use_id(source_p), (long) chptr->channelts,
1946 chptr->chname);
1947 }
1948
1949 del_invite(chptr, source_p);
1950
1951 if(chptr->topic != NULL)
1952 {
1953 sendto_one(source_p, form_str(RPL_TOPIC), me.name,
1954 source_p->name, chptr->chname, chptr->topic);
1955
1956 sendto_one(source_p, form_str(RPL_TOPICWHOTIME),
1957 me.name, source_p->name, chptr->chname,
1958 chptr->topic_info, chptr->topic_time);
1959 }
1960
1961 channel_member_names(chptr, source_p, 1);
1962
1963 hook_info.client = source_p;
1964 hook_info.chptr = chptr;
1965 hook_info.key = key;
1966 call_hook(h_channel_join, &hook_info);
1967 }
1968
1969 return;
1970 }
1971
1972 /*
1973 * channel_metadata_add
1974 *
1975 * inputs - pointer to channel struct
1976 * - name of metadata item you wish to add
1977 * - value of metadata item
1978 * - 1 if metadata should be propegated, 0 if not
1979 * output - none
1980 * side effects - metadata is added to the channel in question
1981 * - metadata is propegated if propegate is set.
1982 */
1983 struct Metadata *
1984 channel_metadata_add(struct Channel *target, const char *name, const char *value, int propegate)
1985 {
1986 struct Metadata *md;
1987
1988 md = rb_malloc(sizeof(struct Metadata));
1989 md->name = rb_strdup(name);
1990 md->value = rb_strdup(value);
1991
1992 irc_dictionary_add(target->metadata, md->name, md);
1993
1994 if(propegate)
1995 sendto_match_servs(&me, "*", CAP_ENCAP, NOCAPS, "ENCAP * METADATA ADD %s %s :%s",
1996 target->chname, name, value);
1997
1998 return md;
1999 }
2000
2001 /*
2002 * channel_metadata_time_add
2003 *
2004 * inputs - pointer to channel struct
2005 * - name of metadata item you wish to add
2006 * - time_t you wish to add
2007 * - value you wish to add
2008 * output - none
2009 * side effects - metadata is added to the channel in question
2010 */
2011 struct Metadata *
2012 channel_metadata_time_add(struct Channel *target, const char *name, time_t timevalue, const char *value)
2013 {
2014 struct Metadata *md;
2015
2016 md = rb_malloc(sizeof(struct Metadata));
2017 md->name = rb_strdup(name);
2018 md->value = rb_strdup(value);
2019 md->timevalue = timevalue;
2020
2021 irc_dictionary_add(target->metadata, md->name, md);
2022
2023 return md;
2024 }
2025
2026 /*
2027 * channel_metadata_delete
2028 *
2029 * inputs - pointer to channel struct
2030 * - name of metadata item you wish to delete
2031 * output - none
2032 * side effects - metadata is deleted from the channel in question
2033 * - deletion is propegated if propegate is set
2034 */
2035 void
2036 channel_metadata_delete(struct Channel *target, const char *name, int propegate)
2037 {
2038 struct Metadata *md = channel_metadata_find(target, name);
2039
2040 if(!md)
2041 return;
2042
2043 irc_dictionary_delete(target->metadata, md->name);
2044
2045 rb_free(md);
2046
2047 if(propegate)
2048 sendto_match_servs(&me, "*", CAP_ENCAP, NOCAPS, "ENCAP * METADATA DELETE %s %s",
2049 target->chname, name);
2050 }
2051
2052 /*
2053 * channel_metadata_find
2054 *
2055 * inputs - pointer to channel struct
2056 * - name of metadata item you wish to read
2057 * output - the requested metadata, if it exists, elsewise null.
2058 * side effects -
2059 */
2060 struct Metadata *
2061 channel_metadata_find(struct Channel *target, const char *name)
2062 {
2063 if(!target)
2064 return NULL;
2065
2066 if(!target->metadata)
2067 return NULL;
2068
2069 return irc_dictionary_retrieve(target->metadata, name);
2070 }
2071
2072 /*
2073 * channel_metadata_clear
2074 *
2075 * inputs - pointer to channel struct
2076 * output - none
2077 * side effects - metadata is cleared from the channel in question
2078 */
2079 void
2080 channel_metadata_clear(struct Channel *chptr)
2081 {
2082 struct Metadata *md;
2083 struct DictionaryIter iter;
2084
2085 DICTIONARY_FOREACH(md, &iter, chptr->metadata)
2086 {
2087 channel_metadata_delete(chptr, md->name, 0);
2088 }
2089 }
Unnamed repository; edit this file 'description' to name the repository.