ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/channel.c
Revision: 7667
Committed: Wed Jul 20 17:09:36 2016 UTC (7 years, 8 months ago) by michael
Content type: text/x-csrc
File size: 33932 byte(s)
Log Message:
- Fixed svn properties

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 *
4 * Copyright (c) 1997-2016 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 channel.c
23 * \brief Responsible for managing channels, members, bans and topics
24 * \version $Id$
25 */
26
27 #include "stdinc.h"
28 #include "list.h"
29 #include "channel.h"
30 #include "channel_mode.h"
31 #include "client.h"
32 #include "hash.h"
33 #include "conf.h"
34 #include "conf_resv.h"
35 #include "hostmask.h"
36 #include "irc_string.h"
37 #include "ircd.h"
38 #include "numeric.h"
39 #include "server.h"
40 #include "send.h"
41 #include "event.h"
42 #include "memory.h"
43 #include "mempool.h"
44 #include "misc.h"
45
46
47 dlink_list channel_list;
48 mp_pool_t *ban_pool; /*! \todo ban_pool shouldn't be a global var */
49
50 static mp_pool_t *member_pool, *channel_pool, *invite_pool;
51
52
53 /*! \brief Initializes the channel blockheap, adds known channel CAPAB
54 */
55 void
56 channel_init(void)
57 {
58 add_capability("EX", CAPAB_EX);
59 add_capability("IE", CAPAB_IE);
60
61 invite_pool = mp_pool_new(sizeof(struct Invite), MP_CHUNK_SIZE_INVITE);
62 channel_pool = mp_pool_new(sizeof(struct Channel), MP_CHUNK_SIZE_CHANNEL);
63 ban_pool = mp_pool_new(sizeof(struct Ban), MP_CHUNK_SIZE_BAN);
64 member_pool = mp_pool_new(sizeof(struct Membership), MP_CHUNK_SIZE_MEMBER);
65 }
66
67 /*! \brief Adds a user to a channel by adding another link to the
68 * channels member chain.
69 * \param chptr Pointer to channel to add client to
70 * \param client_p Pointer to client (who) to add
71 * \param flags Flags for chanops etc
72 * \param flood_ctrl Whether to count this join in flood calculations
73 */
74 void
75 add_user_to_channel(struct Channel *chptr, struct Client *client_p,
76 unsigned int flags, int flood_ctrl)
77 {
78 assert(IsClient(client_p));
79
80 if (GlobalSetOptions.joinfloodtime > 0)
81 {
82 if (flood_ctrl)
83 ++chptr->number_joined;
84
85 chptr->number_joined -= (CurrentTime - chptr->last_join_time) *
86 (((float)GlobalSetOptions.joinfloodcount) /
87 (float)GlobalSetOptions.joinfloodtime);
88
89 if (chptr->number_joined <= 0)
90 {
91 chptr->number_joined = 0;
92 ClearJoinFloodNoticed(chptr);
93 }
94 else if (chptr->number_joined >= GlobalSetOptions.joinfloodcount)
95 {
96 chptr->number_joined = GlobalSetOptions.joinfloodcount;
97
98 if (!IsSetJoinFloodNoticed(chptr))
99 {
100 SetJoinFloodNoticed(chptr);
101 sendto_realops_flags(UMODE_BOTS, L_ALL, SEND_NOTICE,
102 "Possible Join Flooder %s on %s target: %s",
103 get_client_name(client_p, HIDE_IP),
104 client_p->servptr->name, chptr->name);
105 }
106 }
107
108 chptr->last_join_time = CurrentTime;
109 }
110
111 struct Membership *member = mp_pool_get(member_pool);
112 member->client_p = client_p;
113 member->chptr = chptr;
114 member->flags = flags;
115
116 dlinkAdd(member, &member->channode, &chptr->members);
117
118 if (MyConnect(client_p))
119 dlinkAdd(member, &member->locchannode, &chptr->locmembers);
120
121 dlinkAdd(member, &member->usernode, &client_p->channel);
122 }
123
124 /*! \brief Deletes an user from a channel by removing a link in the
125 * channels member chain.
126 * \param member Pointer to Membership struct
127 */
128 void
129 remove_user_from_channel(struct Membership *member)
130 {
131 struct Client *const client_p = member->client_p;
132 struct Channel *const chptr = member->chptr;
133
134 dlinkDelete(&member->channode, &chptr->members);
135
136 if (MyConnect(client_p))
137 dlinkDelete(&member->locchannode, &chptr->locmembers);
138
139 dlinkDelete(&member->usernode, &client_p->channel);
140
141 mp_pool_release(member);
142
143 if (chptr->members.head == NULL)
144 channel_free(chptr);
145 }
146
147 /* channel_send_members()
148 *
149 * inputs -
150 * output - NONE
151 * side effects -
152 */
153 static void
154 channel_send_members(struct Client *client_p, const struct Channel *chptr,
155 char *modebuf, char *parabuf)
156 {
157 char buf[IRCD_BUFSIZE] = "";
158 const dlink_node *node = NULL;
159 int tlen; /* length of text to append */
160 char *t, *start; /* temp char pointer */
161
162 start = t = buf + snprintf(buf, sizeof(buf), ":%s SJOIN %ju %s %s %s:",
163 me.id, chptr->creationtime,
164 chptr->name, modebuf, parabuf);
165
166 DLINK_FOREACH(node, chptr->members.head)
167 {
168 const struct Membership *member = node->data;
169
170 tlen = strlen(member->client_p->id) + 1; /* +1 for space */
171
172 if (member->flags & CHFL_CHANOP)
173 ++tlen;
174 if (member->flags & CHFL_HALFOP)
175 ++tlen;
176 if (member->flags & CHFL_VOICE)
177 ++tlen;
178
179 /*
180 * Space will be converted into CR, but we also need space for LF..
181 * That's why we use '- 1' here -adx
182 */
183 if (t + tlen - buf > IRCD_BUFSIZE - 1)
184 {
185 *(t - 1) = '\0'; /* Kill the space and terminate the string */
186 sendto_one(client_p, "%s", buf);
187 t = start;
188 }
189
190 if (member->flags & CHFL_CHANOP)
191 *t++ = '@';
192 if (member->flags & CHFL_HALFOP)
193 *t++ = '%';
194 if (member->flags & CHFL_VOICE)
195 *t++ = '+';
196
197 strcpy(t, member->client_p->id);
198
199 t += strlen(t);
200 *t++ = ' ';
201 }
202
203 /* Should always be non-NULL unless we have a kind of persistent channels */
204 if (chptr->members.head)
205 t--; /* Take the space out */
206 *t = '\0';
207 sendto_one(client_p, "%s", buf);
208 }
209
210 /*! \brief Sends +b/+e/+I
211 * \param client_p Client pointer to server
212 * \param chptr Pointer to channel
213 * \param list Pointer to list of modes to send
214 * \param flag Char flag flagging type of mode. Currently this can be 'b', e' or 'I'
215 */
216 static void
217 channel_send_mask_list(struct Client *client_p, const struct Channel *chptr,
218 const dlink_list *list, const char flag)
219 {
220 const dlink_node *node = NULL;
221 char mbuf[IRCD_BUFSIZE] = "";
222 char pbuf[IRCD_BUFSIZE] = "";
223 int tlen, mlen, cur_len;
224 char *pp = pbuf;
225
226 if (!dlink_list_length(list))
227 return;
228
229 mlen = snprintf(mbuf, sizeof(mbuf), ":%s BMASK %ju %s %c :", me.id,
230 chptr->creationtime, chptr->name, flag);
231 cur_len = mlen;
232
233 DLINK_FOREACH(node, list->head)
234 {
235 const struct Ban *ban = node->data;
236
237 tlen = ban->len + 3; /* +3 for ! + @ + space */
238
239 /*
240 * Send buffer and start over if we cannot fit another ban
241 */
242 if (cur_len + (tlen - 1) > IRCD_BUFSIZE - 2)
243 {
244 *(pp - 1) = '\0'; /* Get rid of trailing space on buffer */
245 sendto_one(client_p, "%s%s", mbuf, pbuf);
246
247 cur_len = mlen;
248 pp = pbuf;
249 }
250
251 pp += sprintf(pp, "%s!%s@%s ", ban->name, ban->user, ban->host);
252 cur_len += tlen;
253 }
254
255 *(pp - 1) = '\0'; /* Get rid of trailing space on buffer */
256 sendto_one(client_p, "%s%s", mbuf, pbuf);
257 }
258
259 /*! \brief Send "client_p" a full list of the modes for channel chptr
260 * \param client_p Pointer to client client_p
261 * \param chptr Pointer to channel pointer
262 */
263 void
264 channel_send_modes(struct Client *client_p, struct Channel *chptr)
265 {
266 char modebuf[MODEBUFLEN] = "";
267 char parabuf[MODEBUFLEN] = "";
268
269 channel_modes(chptr, client_p, modebuf, parabuf);
270 channel_send_members(client_p, chptr, modebuf, parabuf);
271
272 channel_send_mask_list(client_p, chptr, &chptr->banlist, 'b');
273 channel_send_mask_list(client_p, chptr, &chptr->exceptlist, 'e');
274 channel_send_mask_list(client_p, chptr, &chptr->invexlist, 'I');
275 }
276
277 /*! \brief Check channel name for invalid characters
278 * \param name Pointer to channel name string
279 * \param local Indicates whether it's a local or remote creation
280 * \return 0 if invalid, 1 otherwise
281 */
282 int
283 channel_check_name(const char *name, const int local)
284 {
285 const char *p = name;
286
287 assert(!EmptyString(p));
288
289 if (!IsChanPrefix(*p))
290 return 0;
291
292 if (!local || !ConfigChannel.disable_fake_channels)
293 {
294 while (*++p)
295 if (!IsChanChar(*p))
296 return 0;
297 }
298 else
299 {
300 while (*++p)
301 if (!IsVisibleChanChar(*p))
302 return 0;
303 }
304
305 return p - name <= CHANNELLEN;
306 }
307
308 void
309 remove_ban(struct Ban *ban, dlink_list *list)
310 {
311 dlinkDelete(&ban->node, list);
312 mp_pool_release(ban);
313 }
314
315 /* channel_free_mask_list()
316 *
317 * inputs - pointer to dlink_list
318 * output - NONE
319 * side effects -
320 */
321 static void
322 channel_free_mask_list(dlink_list *list)
323 {
324 while (list->head)
325 {
326 struct Ban *ban = list->head->data;
327 remove_ban(ban, list);
328 }
329 }
330
331 /*! \brief Get Channel block for name (and allocate a new channel
332 * block, if it didn't exist before)
333 * \param name Channel name
334 * \return Channel block
335 */
336 struct Channel *
337 channel_make(const char *name)
338 {
339 struct Channel *chptr = NULL;
340
341 assert(!EmptyString(name));
342
343 chptr = mp_pool_get(channel_pool);
344
345 /* Doesn't hurt to set it here */
346 chptr->creationtime = CurrentTime;
347 chptr->last_join_time = CurrentTime;
348
349 chptr->name_len = strlcpy(chptr->name, name, sizeof(chptr->name));
350 if (chptr->name_len >= sizeof(chptr->name))
351 chptr->name_len = sizeof(chptr->name) - 1;
352
353 dlinkAdd(chptr, &chptr->node, &channel_list);
354 hash_add_channel(chptr);
355
356 return chptr;
357 }
358
359 /*! \brief Walk through this channel, and destroy it.
360 * \param chptr Channel pointer
361 */
362 void
363 channel_free(struct Channel *chptr)
364 {
365 clear_invites_channel(chptr);
366
367 /* Free ban/exception/invex lists */
368 channel_free_mask_list(&chptr->banlist);
369 channel_free_mask_list(&chptr->exceptlist);
370 channel_free_mask_list(&chptr->invexlist);
371
372 dlinkDelete(&chptr->node, &channel_list);
373 hash_del_channel(chptr);
374
375 mp_pool_release(chptr);
376 }
377
378 /*!
379 * \param chptr Pointer to channel
380 * \return String pointer "=" if public, "@" if secret else "*"
381 */
382 static const char *
383 channel_pub_or_secret(const struct Channel *chptr)
384 {
385 if (SecretChannel(chptr))
386 return "@";
387 if (PrivateChannel(chptr))
388 return "*";
389 return "=";
390 }
391
392 /*! \brief lists all names on given channel
393 * \param client_p Pointer to client struct requesting names
394 * \param chptr Pointer to channel block
395 * \param show_eon Show RPL_ENDOFNAMES numeric or not
396 * (don't want it with /names with no params)
397 */
398 void
399 channel_member_names(struct Client *client_p, struct Channel *chptr,
400 int show_eon)
401 {
402 const dlink_node *node = NULL;
403 char buf[IRCD_BUFSIZE + 1] = "";
404 char *t = NULL, *start = NULL;
405 int tlen = 0;
406 const int is_member = IsMember(client_p, chptr);
407 const int multi_prefix = HasCap(client_p, CAP_MULTI_PREFIX) != 0;
408 const int uhnames = HasCap(client_p, CAP_UHNAMES) != 0;
409
410 assert(IsClient(client_p));
411
412 if (PubChannel(chptr) || is_member)
413 {
414 t = buf + snprintf(buf, sizeof(buf), numeric_form(RPL_NAMREPLY),
415 me.name, client_p->name,
416 channel_pub_or_secret(chptr), chptr->name);
417 start = t;
418
419 DLINK_FOREACH(node, chptr->members.head)
420 {
421 const struct Membership *member = node->data;
422
423 if (HasUMode(member->client_p, UMODE_INVISIBLE) && !is_member)
424 continue;
425
426 if (!uhnames)
427 tlen = strlen(member->client_p->name) + 1; /* +1 for space */
428 else
429 tlen = strlen(member->client_p->name) + strlen(member->client_p->username) +
430 strlen(member->client_p->host) + 3; /* +3 for ! + @ + space */
431
432 if (!multi_prefix)
433 {
434 if (member->flags & (CHFL_CHANOP | CHFL_HALFOP | CHFL_VOICE))
435 ++tlen;
436 }
437 else
438 {
439 if (member->flags & CHFL_CHANOP)
440 ++tlen;
441 if (member->flags & CHFL_HALFOP)
442 ++tlen;
443 if (member->flags & CHFL_VOICE)
444 ++tlen;
445 }
446
447 if (t + tlen - buf > IRCD_BUFSIZE - 2)
448 {
449 *(t - 1) = '\0';
450 sendto_one(client_p, "%s", buf);
451 t = start;
452 }
453
454 if (!uhnames)
455 t += sprintf(t, "%s%s ", get_member_status(member, multi_prefix),
456 member->client_p->name);
457 else
458 t += sprintf(t, "%s%s!%s@%s ", get_member_status(member, multi_prefix),
459 member->client_p->name, member->client_p->username,
460 member->client_p->host);
461 }
462
463 if (tlen)
464 {
465 *(t - 1) = '\0';
466 sendto_one(client_p, "%s", buf);
467 }
468 }
469
470 if (show_eon)
471 sendto_one_numeric(client_p, &me, RPL_ENDOFNAMES, chptr->name);
472 }
473
474 static struct Invite *
475 find_invite(struct Channel *chptr, struct Client *client_p)
476 {
477 dlink_node *node, *node_next;
478 dlink_list *list;
479
480 if (dlink_list_length(&client_p->connection->invited) < dlink_list_length(&chptr->invites))
481 list = &client_p->connection->invited;
482 else
483 list = &chptr->invites;
484
485 DLINK_FOREACH_SAFE(node, node_next, list->head)
486 {
487 struct Invite *invite = node->data;
488
489 if (invite->chptr == chptr && invite->client_p == client_p)
490 return invite;
491 }
492
493 return NULL;
494 }
495
496 /*! \brief Adds client to invite list
497 * \param chptr Pointer to channel block
498 * \param client_p Pointer to client to add invite to
499 */
500 void
501 add_invite(struct Channel *chptr, struct Client *client_p)
502 {
503 struct Invite *invite;
504
505 if ((invite = find_invite(chptr, client_p)))
506 del_invite(invite);
507
508 invite = mp_pool_get(invite_pool);
509 invite->client_p = client_p;
510 invite->chptr = chptr;
511 invite->when = CurrentTime;
512
513 /* Delete last link in chain if the list is max length */
514 while (dlink_list_length(&client_p->connection->invited) &&
515 dlink_list_length(&client_p->connection->invited) >= ConfigChannel.max_channels)
516 del_invite(client_p->connection->invited.tail->data);
517
518 /* Add client to channel invite list */
519 dlinkAdd(invite, &invite->chan_node, &chptr->invites);
520
521 /* Add channel to the end of the client invite list */
522 dlinkAdd(invite, &invite->user_node, &client_p->connection->invited);
523 }
524
525 /*! \brief Delete Invite block from channel invite list
526 * and client invite list
527 * \param invite Pointer to Invite struct
528 */
529 void
530 del_invite(struct Invite *invite)
531 {
532 dlinkDelete(&invite->user_node, &invite->client_p->connection->invited);
533 dlinkDelete(&invite->chan_node, &invite->chptr->invites);
534
535 /* Release memory pointed to by 'invite' */
536 mp_pool_release(invite);
537 }
538
539 /*! \brief Removes all invites of a specific channel
540 * \param chptr Pointer to Channel struct
541 */
542 void
543 clear_invites_channel(struct Channel *chptr)
544 {
545 while (chptr->invites.head)
546 del_invite(chptr->invites.head->data);
547 }
548
549 /*! \brief Removes all invites of a specific client
550 * \param client_p Pointer to Client struct
551 */
552 void
553 clear_invites_client(struct Client *client_p)
554 {
555 while (client_p->connection->invited.head)
556 del_invite(client_p->connection->invited.head->data);
557 }
558
559 /* get_member_status()
560 *
561 * inputs - pointer to struct Membership
562 * - YES if we can combine different flags
563 * output - string either @, +, % or "" depending on whether
564 * chanop, voiced or user
565 * side effects -
566 *
567 * NOTE: Returned string is usually a static buffer
568 * (like in get_client_name)
569 */
570 const char *
571 get_member_status(const struct Membership *member, const int combine)
572 {
573 static char buffer[CMEMBER_STATUS_FLAGS_LEN + 1]; /* +1 for \0 */
574 char *p = buffer;
575
576 if (member->flags & CHFL_CHANOP)
577 {
578 if (!combine)
579 return "@";
580 *p++ = '@';
581 }
582
583 if (member->flags & CHFL_HALFOP)
584 {
585 if (!combine)
586 return "%";
587 *p++ = '%';
588 }
589
590 if (member->flags & CHFL_VOICE)
591 *p++ = '+';
592 *p = '\0';
593
594 return buffer;
595 }
596
597 /*!
598 * \param client_p Pointer to Client to check
599 * \param list Pointer to ban list to search
600 * \return 1 if ban found for given n!u\@h mask, 0 otherwise
601 */
602 static int
603 find_bmask(const struct Client *client_p, const dlink_list *list)
604 {
605 const dlink_node *node = NULL;
606
607 DLINK_FOREACH(node, list->head)
608 {
609 const struct Ban *ban = node->data;
610
611 if (!match(ban->name, client_p->name) && !match(ban->user, client_p->username))
612 {
613 switch (ban->type)
614 {
615 case HM_HOST:
616 if (!match(ban->host, client_p->host) || !match(ban->host, client_p->sockhost))
617 return 1;
618 break;
619 case HM_IPV4:
620 if (client_p->connection->aftype == AF_INET)
621 if (match_ipv4(&client_p->connection->ip, &ban->addr, ban->bits))
622 return 1;
623 break;
624 case HM_IPV6:
625 if (client_p->connection->aftype == AF_INET6)
626 if (match_ipv6(&client_p->connection->ip, &ban->addr, ban->bits))
627 return 1;
628 break;
629 default:
630 assert(0);
631 }
632 }
633 }
634
635 return 0;
636 }
637
638 /*!
639 * \param chptr Pointer to channel block
640 * \param client_p Pointer to client to check access fo
641 * \return 0 if not banned, 1 otherwise
642 */
643 int
644 is_banned(const struct Channel *chptr, const struct Client *client_p)
645 {
646 if (find_bmask(client_p, &chptr->banlist))
647 if (!find_bmask(client_p, &chptr->exceptlist))
648 return 1;
649
650 return 0;
651 }
652
653 /*! Tests if a client can join a certain channel
654 * \param client_p Pointer to client attempting to join
655 * \param chptr Pointer to channel
656 * \param key Key sent by client attempting to join if present
657 * \return ERR_BANNEDFROMCHAN, ERR_INVITEONLYCHAN, ERR_CHANNELISFULL
658 * or 0 if allowed to join.
659 */
660 static int
661 can_join(struct Client *client_p, struct Channel *chptr, const char *key)
662 {
663 if ((chptr->mode.mode & MODE_SSLONLY) && !HasUMode(client_p, UMODE_SSL))
664 return ERR_SSLONLYCHAN;
665
666 if ((chptr->mode.mode & MODE_REGONLY) && !HasUMode(client_p, UMODE_REGISTERED))
667 return ERR_NEEDREGGEDNICK;
668
669 if ((chptr->mode.mode & MODE_OPERONLY) && !HasUMode(client_p, UMODE_OPER))
670 return ERR_OPERONLYCHAN;
671
672 if (chptr->mode.mode & MODE_INVITEONLY)
673 if (!find_invite(chptr, client_p))
674 if (!find_bmask(client_p, &chptr->invexlist))
675 return ERR_INVITEONLYCHAN;
676
677 if (chptr->mode.key[0] && (!key || strcmp(chptr->mode.key, key)))
678 return ERR_BADCHANNELKEY;
679
680 if (chptr->mode.limit && dlink_list_length(&chptr->members) >=
681 chptr->mode.limit)
682 return ERR_CHANNELISFULL;
683
684 if (is_banned(chptr, client_p))
685 return ERR_BANNEDFROMCHAN;
686
687 return 0;
688 }
689
690 int
691 has_member_flags(const struct Membership *member, const unsigned int flags)
692 {
693 return member && (member->flags & flags);
694 }
695
696 struct Membership *
697 find_channel_link(struct Client *client_p, struct Channel *chptr)
698 {
699 dlink_node *node = NULL;
700
701 if (!IsClient(client_p))
702 return NULL;
703
704 if (dlink_list_length(&chptr->members) < dlink_list_length(&client_p->channel))
705 {
706 DLINK_FOREACH(node, chptr->members.head)
707 if (((struct Membership *)node->data)->client_p == client_p)
708 return node->data;
709 }
710 else
711 {
712 DLINK_FOREACH(node, client_p->channel.head)
713 if (((struct Membership *)node->data)->chptr == chptr)
714 return node->data;
715 }
716
717 return NULL;
718 }
719
720 /*! Checks if a message contains control codes
721 * \param message The actual message string the client wants to send
722 * \return 1 if the message does contain any control codes, 0 otherwise
723 */
724 static int
725 msg_has_ctrls(const char *message)
726 {
727 const unsigned char *p = (const unsigned char *)message;
728
729 for (; *p; ++p)
730 {
731 if (*p > 31 || *p == 1)
732 continue; /* No control code or CTCP */
733
734 if (*p == 27) /* Escape */
735 {
736 /* ISO 2022 charset shift sequence */
737 if (*(p + 1) == '$' ||
738 *(p + 1) == '(')
739 {
740 ++p;
741 continue;
742 }
743 }
744
745 return 1; /* Control code */
746 }
747
748 return 0; /* No control code found */
749 }
750
751 /*! Tests if a client can send to a channel
752 * \param chptr Pointer to Channel struct
753 * \param client_p Pointer to Client struct
754 * \param member Pointer to Membership struct (can be NULL)
755 * \param message The actual message string the client wants to send
756 * \return CAN_SEND_OPV if op or voiced on channel\n
757 * CAN_SEND_NONOP if can send to channel but is not an op\n
758 * ERR_CANNOTSENDTOCHAN or ERR_NEEDREGGEDNICK if they cannot send to channel\n
759 */
760 int
761 can_send(struct Channel *chptr, struct Client *client_p,
762 struct Membership *member, const char *message, int notice)
763 {
764 const struct ResvItem *resv = NULL;
765
766 if (IsServer(client_p) || HasFlag(client_p, FLAGS_SERVICE))
767 return CAN_SEND_OPV;
768
769 if (MyConnect(client_p) && !HasFlag(client_p, FLAGS_EXEMPTRESV))
770 if (!(HasUMode(client_p, UMODE_OPER) && HasOFlag(client_p, OPER_FLAG_JOIN_RESV)))
771 if ((resv = resv_find(chptr->name, match)) && !resv_exempt_find(client_p, resv))
772 return ERR_CANNOTSENDTOCHAN;
773
774 if ((chptr->mode.mode & MODE_NOCTRL) && msg_has_ctrls(message))
775 return ERR_NOCTRLSONCHAN;
776
777 if (chptr->mode.mode & MODE_NOCTCP)
778 if (*message == '\001' && strncmp(message + 1, "ACTION ", 7))
779 return ERR_NOCTCP;
780
781 if (member || (member = find_channel_link(client_p, chptr)))
782 if (member->flags & (CHFL_CHANOP | CHFL_HALFOP | CHFL_VOICE))
783 return CAN_SEND_OPV;
784
785 if (!member && (chptr->mode.mode & MODE_NOPRIVMSGS))
786 return ERR_CANNOTSENDTOCHAN;
787
788 if (chptr->mode.mode & MODE_MODERATED)
789 return ERR_CANNOTSENDTOCHAN;
790
791 if ((chptr->mode.mode & MODE_MODREG) && !HasUMode(client_p, UMODE_REGISTERED))
792 return ERR_NEEDREGGEDNICK;
793
794 if ((chptr->mode.mode & MODE_NONOTICE) && notice)
795 return ERR_CANNOTSENDTOCHAN;
796
797 /* Cache can send if banned */
798 if (MyConnect(client_p))
799 {
800 if (member)
801 {
802 if (member->flags & CHFL_BAN_SILENCED)
803 return ERR_CANNOTSENDTOCHAN;
804
805 if (!(member->flags & CHFL_BAN_CHECKED))
806 {
807 if (is_banned(chptr, client_p))
808 {
809 member->flags |= (CHFL_BAN_CHECKED | CHFL_BAN_SILENCED);
810 return ERR_CANNOTSENDTOCHAN;
811 }
812
813 member->flags |= CHFL_BAN_CHECKED;
814 }
815 }
816 else if (is_banned(chptr, client_p))
817 return ERR_CANNOTSENDTOCHAN;
818 }
819
820 return CAN_SEND_NONOP;
821 }
822
823 /*! \brief Updates the client's oper_warn_count_down, warns the
824 * IRC operators if necessary, and updates
825 * join_leave_countdown as needed.
826 * \param client_p Pointer to struct Client to check
827 * \param name Channel name or NULL if this is a part.
828 */
829 void
830 check_spambot_warning(struct Client *client_p, const char *name)
831 {
832 int t_delta = 0;
833 int decrement_count = 0;
834
835 if ((GlobalSetOptions.spam_num &&
836 (client_p->connection->join_leave_count >=
837 GlobalSetOptions.spam_num)))
838 {
839 if (client_p->connection->oper_warn_count_down > 0)
840 client_p->connection->oper_warn_count_down--;
841 else
842 client_p->connection->oper_warn_count_down = 0;
843
844 if (client_p->connection->oper_warn_count_down == 0)
845 {
846 /* It's already known as a possible spambot */
847 if (name)
848 sendto_realops_flags(UMODE_BOTS, L_ALL, SEND_NOTICE,
849 "User %s (%s@%s) trying to join %s is a possible spambot",
850 client_p->name, client_p->username,
851 client_p->host, name);
852 else
853 sendto_realops_flags(UMODE_BOTS, L_ALL, SEND_NOTICE,
854 "User %s (%s@%s) is a possible spambot",
855 client_p->name, client_p->username,
856 client_p->host);
857 client_p->connection->oper_warn_count_down = OPER_SPAM_COUNTDOWN;
858 }
859 }
860 else
861 {
862 if ((t_delta = (CurrentTime - client_p->connection->last_leave_time)) >
863 JOIN_LEAVE_COUNT_EXPIRE_TIME)
864 {
865 decrement_count = (t_delta / JOIN_LEAVE_COUNT_EXPIRE_TIME);
866
867 if (decrement_count > client_p->connection->join_leave_count)
868 client_p->connection->join_leave_count = 0;
869 else
870 client_p->connection->join_leave_count -= decrement_count;
871 }
872 else
873 {
874 if ((CurrentTime - (client_p->connection->last_join_time)) <
875 GlobalSetOptions.spam_time)
876 client_p->connection->join_leave_count++; /* It's a possible spambot */
877 }
878
879 if (name)
880 client_p->connection->last_join_time = CurrentTime;
881 else
882 client_p->connection->last_leave_time = CurrentTime;
883 }
884 }
885
886 /*! \brief Sets the channel topic for a certain channel
887 * \param chptr Pointer to struct Channel
888 * \param topic The topic string
889 * \param topic_info n!u\@h formatted string of the topic setter
890 * \param topicts Timestamp on the topic
891 * \param local Whether the topic is set by a local client
892 */
893 void
894 channel_set_topic(struct Channel *chptr, const char *topic,
895 const char *topic_info, uintmax_t topicts, int local)
896 {
897 if (local)
898 strlcpy(chptr->topic, topic, IRCD_MIN(sizeof(chptr->topic), ConfigServerInfo.max_topic_length + 1));
899 else
900 strlcpy(chptr->topic, topic, sizeof(chptr->topic));
901
902 strlcpy(chptr->topic_info, topic_info, sizeof(chptr->topic_info));
903 chptr->topic_time = topicts;
904 }
905
906 /* do_join_0()
907 *
908 * inputs - pointer to client doing join 0
909 * output - NONE
910 * side effects - Use has decided to join 0. This is legacy
911 * from the days when channels were numbers not names. *sigh*
912 * There is a bunch of evilness necessary here due to
913 * anti spambot code.
914 */
915 void
916 channel_do_join_0(struct Client *client_p)
917 {
918 if (client_p->channel.head)
919 if (MyConnect(client_p) && !HasUMode(client_p, UMODE_OPER))
920 check_spambot_warning(client_p, NULL);
921
922 while (client_p->channel.head)
923 {
924 struct Membership *member = client_p->channel.head->data;
925
926 sendto_server(client_p, 0, 0, ":%s PART %s",
927 client_p->id, member->chptr->name);
928 sendto_channel_local(NULL, member->chptr, 0, 0, 0, ":%s!%s@%s PART %s",
929 client_p->name, client_p->username,
930 client_p->host, member->chptr->name);
931
932 remove_user_from_channel(member);
933 }
934 }
935
936 static char *
937 channel_find_last0(struct Client *client_p, char *chanlist)
938 {
939 int join0 = 0;
940
941 for (char *p = chanlist; *p; ++p) /* Find last "JOIN 0" */
942 {
943 if (*p == '0' && (*(p + 1) == ',' || *(p + 1) == '\0'))
944 {
945 if (*(p + 1) == ',')
946 ++p;
947
948 chanlist = p + 1;
949 join0 = 1;
950 }
951 else
952 {
953 while (*p != ',' && *p != '\0') /* Skip past channel name */
954 ++p;
955
956 if (*p == '\0') /* Hit the end */
957 break;
958 }
959 }
960
961 if (join0)
962 channel_do_join_0(client_p);
963
964 return chanlist;
965 }
966
967 void
968 channel_do_join(struct Client *client_p, char *channel, char *key_list)
969 {
970 char *p = NULL;
971 char *chan_list = NULL;
972 struct Channel *chptr = NULL;
973 const struct ResvItem *resv = NULL;
974 const struct ClassItem *const class = get_class_ptr(&client_p->connection->confs);
975 unsigned int flags = 0;
976
977 assert(IsClient(client_p));
978
979 chan_list = channel_find_last0(client_p, channel);
980
981 for (const char *chan = strtok_r(chan_list, ",", &p); chan;
982 chan = strtok_r(NULL, ",", &p))
983 {
984 const char *key = NULL;
985
986 /* If we have any more keys, take the first for this channel. */
987 if (!EmptyString(key_list) && (key_list = strchr(key = key_list, ',')))
988 *key_list++ = '\0';
989
990 /* Empty keys are the same as no keys. */
991 if (key && *key == '\0')
992 key = NULL;
993
994 if (!channel_check_name(chan, 1))
995 {
996 sendto_one_numeric(client_p, &me, ERR_BADCHANNAME, chan);
997 continue;
998 }
999
1000 if (!HasFlag(client_p, FLAGS_EXEMPTRESV) &&
1001 !(HasUMode(client_p, UMODE_OPER) && HasOFlag(client_p, OPER_FLAG_JOIN_RESV)) &&
1002 ((resv = resv_find(chan, match)) && !resv_exempt_find(client_p, resv)))
1003 {
1004 sendto_one_numeric(client_p, &me, ERR_CHANBANREASON, chan, resv->reason);
1005 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
1006 "Forbidding reserved channel %s from user %s",
1007 chan, get_client_name(client_p, HIDE_IP));
1008 continue;
1009 }
1010
1011 if (dlink_list_length(&client_p->channel) >=
1012 ((class->max_channels) ? class->max_channels : ConfigChannel.max_channels))
1013 {
1014 sendto_one_numeric(client_p, &me, ERR_TOOMANYCHANNELS, chan);
1015 break;
1016 }
1017
1018 if ((chptr = hash_find_channel(chan)))
1019 {
1020 if (IsMember(client_p, chptr))
1021 continue;
1022
1023 /* can_join() checks for +i, +l, key, bans, etc. */
1024 int ret = can_join(client_p, chptr, key);
1025 if (ret)
1026 {
1027 sendto_one_numeric(client_p, &me, ret, chptr->name);
1028 continue;
1029 }
1030
1031 /*
1032 * This should never be the case unless there is some sort of
1033 * persistant channels.
1034 */
1035 if (!dlink_list_length(&chptr->members))
1036 flags = CHFL_CHANOP;
1037 else
1038 flags = 0;
1039 }
1040 else
1041 {
1042 flags = CHFL_CHANOP;
1043 chptr = channel_make(chan);
1044 }
1045
1046 if (!HasUMode(client_p, UMODE_OPER))
1047 check_spambot_warning(client_p, chptr->name);
1048
1049 add_user_to_channel(chptr, client_p, flags, 1);
1050
1051 /*
1052 * Set timestamp if appropriate, and propagate
1053 */
1054 if (flags == CHFL_CHANOP)
1055 {
1056 chptr->creationtime = CurrentTime;
1057 chptr->mode.mode |= MODE_TOPICLIMIT;
1058 chptr->mode.mode |= MODE_NOPRIVMSGS;
1059
1060 sendto_server(client_p, 0, 0, ":%s SJOIN %ju %s +nt :@%s",
1061 me.id, chptr->creationtime,
1062 chptr->name, client_p->id);
1063
1064 /*
1065 * Notify all other users on the new channel
1066 */
1067 sendto_channel_local(NULL, chptr, 0, CAP_EXTENDED_JOIN, 0, ":%s!%s@%s JOIN %s %s :%s",
1068 client_p->name, client_p->username,
1069 client_p->host, chptr->name, client_p->account, client_p->info);
1070 sendto_channel_local(NULL, chptr, 0, 0, CAP_EXTENDED_JOIN, ":%s!%s@%s JOIN :%s",
1071 client_p->name, client_p->username,
1072 client_p->host, chptr->name);
1073 sendto_channel_local(NULL, chptr, 0, 0, 0, ":%s MODE %s +nt",
1074 me.name, chptr->name);
1075
1076 if (client_p->away[0])
1077 sendto_channel_local(client_p, chptr, 0, CAP_AWAY_NOTIFY, 0,
1078 ":%s!%s@%s AWAY :%s",
1079 client_p->name, client_p->username,
1080 client_p->host, client_p->away);
1081 }
1082 else
1083 {
1084 sendto_server(client_p, 0, 0, ":%s JOIN %ju %s +",
1085 client_p->id, chptr->creationtime,
1086 chptr->name);
1087
1088 sendto_channel_local(NULL, chptr, 0, CAP_EXTENDED_JOIN, 0, ":%s!%s@%s JOIN %s %s :%s",
1089 client_p->name, client_p->username,
1090 client_p->host, chptr->name, client_p->account, client_p->info);
1091 sendto_channel_local(NULL, chptr, 0, 0, CAP_EXTENDED_JOIN, ":%s!%s@%s JOIN :%s",
1092 client_p->name, client_p->username,
1093 client_p->host, chptr->name);
1094
1095 if (client_p->away[0])
1096 sendto_channel_local(client_p, chptr, 0, CAP_AWAY_NOTIFY, 0,
1097 ":%s!%s@%s AWAY :%s",
1098 client_p->name, client_p->username,
1099 client_p->host, client_p->away);
1100 }
1101
1102 struct Invite *invite = find_invite(chptr, client_p);
1103 if (invite)
1104 del_invite(invite);
1105
1106 if (chptr->topic[0])
1107 {
1108 sendto_one_numeric(client_p, &me, RPL_TOPIC, chptr->name, chptr->topic);
1109 sendto_one_numeric(client_p, &me, RPL_TOPICWHOTIME, chptr->name,
1110 chptr->topic_info, chptr->topic_time);
1111 }
1112
1113 channel_member_names(client_p, chptr, 1);
1114
1115 client_p->connection->last_join_time = CurrentTime;
1116 }
1117 }
1118
1119 /*! \brief Removes a client from a specific channel
1120 * \param client_p Pointer to client to remove
1121 * \param name Name of channel to remove from
1122 * \param reason Part reason to show
1123 */
1124 static void
1125 channel_part_one_client(struct Client *client_p, const char *name, const char *reason)
1126 {
1127 struct Channel *chptr = NULL;
1128 struct Membership *member = NULL;
1129
1130 if ((chptr = hash_find_channel(name)) == NULL)
1131 {
1132 sendto_one_numeric(client_p, &me, ERR_NOSUCHCHANNEL, name);
1133 return;
1134 }
1135
1136 if ((member = find_channel_link(client_p, chptr)) == NULL)
1137 {
1138 sendto_one_numeric(client_p, &me, ERR_NOTONCHANNEL, chptr->name);
1139 return;
1140 }
1141
1142 if (MyConnect(client_p) && !HasUMode(client_p, UMODE_OPER))
1143 check_spambot_warning(client_p, NULL);
1144
1145 /*
1146 * Remove user from the old channel (if any)
1147 * only allow /part reasons in -m chans
1148 */
1149 if (*reason && (!MyConnect(client_p) ||
1150 ((client_p->connection->firsttime +
1151 ConfigGeneral.anti_spam_exit_message_time) < CurrentTime &&
1152 can_send(chptr, client_p, member, reason, 0) < 0)))
1153 {
1154 sendto_server(client_p, 0, 0, ":%s PART %s :%s",
1155 client_p->id, chptr->name, reason);
1156 sendto_channel_local(NULL, chptr, 0, 0, 0, ":%s!%s@%s PART %s :%s",
1157 client_p->name, client_p->username,
1158 client_p->host, chptr->name, reason);
1159 }
1160 else
1161 {
1162 sendto_server(client_p, 0, 0, ":%s PART %s",
1163 client_p->id, chptr->name);
1164 sendto_channel_local(NULL, chptr, 0, 0, 0, ":%s!%s@%s PART %s",
1165 client_p->name, client_p->username,
1166 client_p->host, chptr->name);
1167 }
1168
1169 remove_user_from_channel(member);
1170 }
1171
1172 void
1173 channel_do_part(struct Client *client_p, char *channel, const char *reason)
1174 {
1175 char *p = NULL, *name = NULL;
1176 char buf[KICKLEN + 1] = "";
1177
1178 assert(IsClient(client_p));
1179
1180 if (!EmptyString(reason))
1181 strlcpy(buf, reason, sizeof(buf));
1182
1183 for (name = strtok_r(channel, ",", &p); name;
1184 name = strtok_r(NULL, ",", &p))
1185 channel_part_one_client(client_p, name, buf);
1186 }

Properties

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