00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include "stdinc.h"
00028 #include "tools.h"
00029 #include "handlers.h"
00030 #include "channel.h"
00031 #include "channel_mode.h"
00032 #include "client.h"
00033 #include "hash.h"
00034 #include "irc_string.h"
00035 #include "sprintf_irc.h"
00036 #include "ircd.h"
00037 #include "list.h"
00038 #include "numeric.h"
00039 #include "send.h"
00040 #include "common.h"
00041 #include "msg.h"
00042 #include "parse.h"
00043 #include "modules.h"
00044 #include "s_serv.h"
00045 #include "s_conf.h"
00046
00047 static void ms_sjoin(struct Client *, struct Client *, int, char *[]);
00048
00049 struct Message sjoin_msgtab = {
00050 "SJOIN", 0, 0, 0, 0, MFLG_SLOW, 0,
00051 {m_unregistered, m_ignore, ms_sjoin, m_ignore, m_ignore, m_ignore}
00052 };
00053
00054 #ifndef STATIC_MODULES
00055 void
00056 _modinit(void)
00057 {
00058 mod_add_cmd(&sjoin_msgtab);
00059 }
00060
00061 void
00062 _moddeinit(void)
00063 {
00064 mod_del_cmd(&sjoin_msgtab);
00065 }
00066
00067 const char *_version = "$Revision: 632 $";
00068 #endif
00069
00070 static char modebuf[MODEBUFLEN];
00071 static char parabuf[MODEBUFLEN];
00072 static char sendbuf[MODEBUFLEN];
00073 static const char *para[MAXMODEPARAMS];
00074 static char *mbuf;
00075 static int pargs;
00076
00077 static void set_final_mode(struct Mode *, struct Mode *);
00078 static void remove_our_modes(struct Channel *, struct Client *);
00079 static void remove_a_mode(struct Channel *, struct Client *, int, char);
00080 static void remove_ban_list(struct Channel *, struct Client *, dlink_list *, char, int);
00081 static void introduce_lazy_link_clients(struct Client *,struct Client *,
00082 struct Channel *);
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096 static void
00097 ms_sjoin(struct Client *client_p, struct Client *source_p,
00098 int parc, char *parv[])
00099 {
00100 struct Channel *chptr = NULL;
00101 struct Client *target_p = NULL;
00102 time_t newts;
00103 time_t oldts;
00104 time_t tstosend;
00105 struct Mode mode, *oldmode;
00106 int args = 0;
00107 char keep_our_modes = YES;
00108 char keep_new_modes = YES;
00109 char have_many_nicks = NO;
00110 int lcount;
00111 char nick_prefix[4];
00112 char uid_prefix[4];
00113 char *np, *up;
00114 int len_nick = 0;
00115 int len_uid = 0;
00116 int isnew = 0;
00117 int buflen = 0;
00118 int slen;
00119 unsigned int fl;
00120 char *s;
00121 char *sptr;
00122 char nick_buf[IRCD_BUFSIZE];
00123 char uid_buf[IRCD_BUFSIZE];
00124 char *nick_ptr, *uid_ptr;
00125 char *p;
00126 dlink_node *m;
00127 const char *servername = (ConfigServerHide.hide_servers || IsHidden(source_p)) ?
00128 me.name : source_p->name;
00129
00130 if (IsClient(source_p) || parc < 5)
00131 return;
00132
00133
00134 if (*parv[2] != '#')
00135 return;
00136
00137 if (!check_channel_name(parv[2], 0))
00138 {
00139 sendto_realops_flags(UMODE_DEBUG, L_ALL,
00140 "*** Too long or invalid channel name from %s: %s",
00141 client_p->name, parv[2]);
00142 return;
00143 }
00144
00145 modebuf[0] = '\0';
00146 mbuf = modebuf;
00147 pargs = 0;
00148 newts = atol(parv[1]);
00149
00150 mode.mode = 0;
00151 mode.limit = 0;
00152 mode.key[0] = '\0';
00153
00154 for (s = parv[3]; *s; ++s)
00155 {
00156 switch (*s)
00157 {
00158 case 'c':
00159 mode.mode |= MODE_COLORLESS;
00160 break;
00161 case 'C':
00162 mode.mode |= MODE_ASCIIONLY;
00163 break;
00164 case 'O':
00165 mode.mode |= MODE_OPERONLY;
00166 break;
00167 case 't':
00168 mode.mode |= MODE_TOPICLIMIT;
00169 break;
00170 case 'n':
00171 mode.mode |= MODE_NOPRIVMSGS;
00172 break;
00173 case 's':
00174 mode.mode |= MODE_SECRET;
00175 break;
00176 case 'm':
00177 mode.mode |= MODE_MODERATED;
00178 break;
00179 case 'i':
00180 mode.mode |= MODE_INVITEONLY;
00181 break;
00182 case 'p':
00183 mode.mode |= MODE_PRIVATE;
00184 break;
00185 case 'k':
00186 strlcpy(mode.key, parv[4 + args], sizeof(mode.key));
00187 args++;
00188
00189 if (parc < 5 + args)
00190 return;
00191 break;
00192 case 'l':
00193 mode.limit = atoi(parv[4 + args]);
00194 args++;
00195
00196 if (parc < 5 + args)
00197 return;
00198 break;
00199 }
00200 }
00201
00202 if ((chptr = hash_find_channel(parv[2])) == NULL)
00203 {
00204 isnew = 1;
00205 chptr = make_channel(parv[2]);
00206 }
00207
00208 parabuf[0] = '\0';
00209 oldts = chptr->channelts;
00210 oldmode = &chptr->mode;
00211
00212 if (ConfigFileEntry.ignore_bogus_ts)
00213 {
00214 if (newts < 800000000)
00215 {
00216 sendto_realops_flags(UMODE_DEBUG, L_ALL,
00217 "*** Bogus TS %lu on %s ignored from %s",
00218 (unsigned long)newts, chptr->chname,
00219 client_p->name);
00220
00221 newts = (oldts == 0) ? 0 : 800000000;
00222 }
00223 }
00224 else
00225 {
00226 if (!newts && !isnew && oldts)
00227 {
00228 sendto_channel_local(ALL_MEMBERS, NO, chptr,
00229 ":%s NOTICE %s :*** Notice -- TS for %s changed from %lu to 0",
00230 me.name, chptr->chname, chptr->chname, (unsigned long)oldts);
00231 sendto_realops_flags(UMODE_ALL, L_ALL,
00232 "Server %s changing TS on %s from %lu to 0",
00233 source_p->name, chptr->chname, (unsigned long)oldts);
00234 }
00235 }
00236
00237 if (isnew)
00238 chptr->channelts = tstosend = newts;
00239 else if (newts == 0 || oldts == 0)
00240 chptr->channelts = tstosend = 0;
00241 else if (newts == oldts)
00242 tstosend = oldts;
00243 else if (newts < oldts)
00244 {
00245 keep_our_modes = NO;
00246 chptr->channelts = tstosend = newts;
00247 }
00248 else
00249 {
00250 keep_new_modes = NO;
00251 tstosend = oldts;
00252 }
00253
00254 if (!keep_new_modes)
00255 mode = *oldmode;
00256 else if (keep_our_modes)
00257 {
00258 mode.mode |= oldmode->mode;
00259 if (oldmode->limit > mode.limit)
00260 mode.limit = oldmode->limit;
00261 if (strcmp(mode.key, oldmode->key) < 0)
00262 strcpy(mode.key, oldmode->key);
00263 }
00264 set_final_mode(&mode, oldmode);
00265 chptr->mode = mode;
00266
00267
00268 if (!keep_our_modes)
00269 {
00270 remove_our_modes(chptr, source_p);
00271 sendto_channel_local(ALL_MEMBERS, NO, chptr,
00272 ":%s NOTICE %s :*** Notice -- TS for %s changed from %lu to %lu",
00273 me.name, chptr->chname, chptr->chname,
00274 (unsigned long)oldts, (unsigned long)newts);
00275 }
00276
00277 if (*modebuf != '\0')
00278 {
00279
00280
00281 sendto_channel_local(ALL_MEMBERS, NO, chptr, ":%s MODE %s %s %s",
00282 servername, chptr->chname, modebuf, parabuf);
00283 }
00284
00285 if (parv[3][0] != '0' && keep_new_modes)
00286 {
00287 channel_modes(chptr, source_p, modebuf, parabuf);
00288 }
00289 else
00290 {
00291 modebuf[0] = '0';
00292 modebuf[1] = '\0';
00293 }
00294
00295 buflen = ircsprintf(nick_buf, ":%s SJOIN %lu %s %s %s:",
00296 source_p->name, (unsigned long)tstosend,
00297 chptr->chname, modebuf, parabuf);
00298 nick_ptr = nick_buf + buflen;
00299
00300 buflen = ircsprintf(uid_buf, ":%s SJOIN %lu %s %s %s:",
00301 ID(source_p), (unsigned long)tstosend,
00302 chptr->chname, modebuf, parabuf);
00303 uid_ptr = uid_buf + buflen;
00304
00305
00306
00307
00308 if (buflen >= (IRCD_BUFSIZE - IRCD_MAX(NICKLEN, IDLEN) - 2 - 3 - 1))
00309 {
00310 sendto_realops_flags(UMODE_ALL, L_ALL,
00311 "Long SJOIN from server: %s(via %s) (ignored)",
00312 source_p->name, client_p->name);
00313 return;
00314 }
00315
00316 mbuf = modebuf;
00317 sendbuf[0] = '\0';
00318 pargs = 0;
00319
00320 *mbuf++ = '+';
00321
00322 s = parv[args + 4];
00323 while (*s == ' ')
00324 s++;
00325 if ((p = strchr(s, ' ')) != NULL)
00326 {
00327 *p++ = '\0';
00328 while (*p == ' ')
00329 p++;
00330 have_many_nicks = *p;
00331 }
00332
00333 while (*s)
00334 {
00335 int valid_mode = YES;
00336 fl = 0;
00337
00338 do
00339 {
00340 switch (*s)
00341 {
00342 case '@':
00343 fl |= CHFL_CHANOP;
00344 s++;
00345 break;
00346 #ifdef HALFOPS
00347 case '%':
00348 fl |= CHFL_HALFOP;
00349 s++;
00350 break;
00351 #endif
00352 case '+':
00353 fl |= CHFL_VOICE;
00354 s++;
00355 break;
00356 default:
00357 valid_mode = NO;
00358 break;
00359 }
00360 } while (valid_mode);
00361
00362 target_p = find_chasing(client_p, source_p, s, NULL);
00363
00364
00365
00366
00367
00368
00369
00370 if (target_p == NULL ||
00371 target_p->from != client_p ||
00372 !IsClient(target_p))
00373 {
00374 goto nextnick;
00375 }
00376
00377 len_nick = strlen(target_p->name);
00378 len_uid = strlen(ID(target_p));
00379
00380 np = nick_prefix;
00381 up = uid_prefix;
00382
00383 if (keep_new_modes)
00384 {
00385 if (fl & CHFL_CHANOP)
00386 {
00387 *np++ = '@';
00388 *up++ = '@';
00389 len_nick++;
00390 len_uid++;
00391 }
00392 #ifdef HALFOPS
00393 if (fl & CHFL_HALFOP)
00394 {
00395 *np++ = '%';
00396 *up++ = '%';
00397 len_nick++;
00398 len_uid++;
00399 }
00400 #endif
00401 if (fl & CHFL_VOICE)
00402 {
00403 *np++ = '+';
00404 *up++ = '+';
00405 len_nick++;
00406 len_uid++;
00407 }
00408 }
00409 else
00410 {
00411 if (fl & (CHFL_CHANOP|CHFL_HALFOP))
00412 fl = CHFL_DEOPPED;
00413 else
00414 fl = 0;
00415 }
00416 *np = *up = '\0';
00417
00418 if ((nick_ptr - nick_buf + len_nick) > (IRCD_BUFSIZE - 2))
00419 {
00420 sendto_server(client_p, NULL, chptr, 0, CAP_TS6, 0, "%s", nick_buf);
00421
00422 buflen = ircsprintf(nick_buf, ":%s SJOIN %lu %s %s %s:",
00423 source_p->name, (unsigned long)tstosend,
00424 chptr->chname, modebuf, parabuf);
00425 nick_ptr = nick_buf + buflen;
00426 }
00427 nick_ptr += ircsprintf(nick_ptr, "%s%s ", nick_prefix, target_p->name);
00428
00429 if ((uid_ptr - uid_buf + len_uid) > (IRCD_BUFSIZE - 2))
00430 {
00431 sendto_server(client_p, NULL, chptr, CAP_TS6, 0, 0, "%s", uid_buf);
00432
00433 buflen = ircsprintf(uid_buf, ":%s SJOIN %lu %s %s %s:",
00434 ID(source_p), (unsigned long)tstosend,
00435 chptr->chname, modebuf, parabuf);
00436 uid_ptr = uid_buf + buflen;
00437 }
00438
00439 uid_ptr += ircsprintf(uid_ptr, "%s%s ", uid_prefix, ID(target_p));
00440
00441
00442 if (ServerInfo.hub)
00443 introduce_lazy_link_clients(client_p, target_p, chptr);
00444
00445 if (!IsMember(target_p, chptr))
00446 {
00447 add_user_to_channel(chptr, target_p, fl, !have_many_nicks);
00448 sendto_channel_local(ALL_MEMBERS, NO, chptr, ":%s!%s@%s JOIN :%s",
00449 target_p->name, target_p->username,
00450 target_p->host, chptr->chname);
00451 }
00452
00453 if (fl & CHFL_CHANOP)
00454 {
00455 *mbuf++ = 'o';
00456 para[pargs++] = target_p->name;
00457
00458 if (pargs >= MAXMODEPARAMS)
00459 {
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469 sptr = sendbuf;
00470 *mbuf = '\0';
00471 for(lcount = 0; lcount < MAXMODEPARAMS; lcount++)
00472 {
00473 slen = ircsprintf(sptr, " %s", para[lcount]);
00474 sptr += slen;
00475 }
00476 sendto_channel_local(ALL_MEMBERS, NO, chptr, ":%s MODE %s %s%s",
00477 servername, chptr->chname, modebuf, sendbuf);
00478 mbuf = modebuf;
00479 *mbuf++ = '+';
00480
00481 sendbuf[0] = '\0';
00482 pargs = 0;
00483 }
00484 }
00485 #ifdef HALFOPS
00486 if (fl & CHFL_HALFOP)
00487 {
00488 *mbuf++ = 'h';
00489 para[pargs++] = target_p->name;
00490
00491 if (pargs >= MAXMODEPARAMS)
00492 {
00493 sptr = sendbuf;
00494 *mbuf = '\0';
00495 for(lcount = 0; lcount < MAXMODEPARAMS; lcount++)
00496 {
00497 slen = ircsprintf(sptr, " %s", para[lcount]);
00498 sptr += slen;
00499 }
00500 sendto_channel_local(ALL_MEMBERS, NO, chptr, ":%s MODE %s %s%s",
00501 servername, chptr->chname, modebuf, sendbuf);
00502
00503 mbuf = modebuf;
00504 *mbuf++ = '+';
00505
00506 sendbuf[0] = '\0';
00507 pargs = 0;
00508 }
00509 }
00510 #endif
00511 if (fl & CHFL_VOICE)
00512 {
00513 *mbuf++ = 'v';
00514 para[pargs++] = target_p->name;
00515
00516 if (pargs >= MAXMODEPARAMS)
00517 {
00518 sptr = sendbuf;
00519 *mbuf = '\0';
00520 for (lcount = 0; lcount < MAXMODEPARAMS; lcount++)
00521 {
00522 slen = ircsprintf(sptr, " %s", para[lcount]);
00523 sptr += slen;
00524 }
00525 sendto_channel_local(ALL_MEMBERS, NO, chptr, ":%s MODE %s %s%s",
00526 servername, chptr->chname, modebuf, sendbuf);
00527
00528 mbuf = modebuf;
00529 *mbuf++ = '+';
00530
00531 sendbuf[0] = '\0';
00532 pargs = 0;
00533 }
00534 }
00535
00536 nextnick:
00537 if ((s = p) == NULL)
00538 break;
00539 while (*s == ' ')
00540 s++;
00541 if ((p = strchr(s, ' ')) != NULL)
00542 {
00543 *p++ = 0;
00544 while (*p == ' ')
00545 p++;
00546 }
00547 }
00548
00549 *mbuf = '\0';
00550 *(nick_ptr - 1) = '\0';
00551 *(uid_ptr - 1) = '\0';
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561 if (pargs != 0)
00562 {
00563 sptr = sendbuf;
00564
00565 for (lcount = 0; lcount < pargs; lcount++)
00566 {
00567 slen = ircsprintf(sptr, " %s", para[lcount]);
00568 sptr += slen;
00569 }
00570
00571 sendto_channel_local(ALL_MEMBERS, NO, chptr, ":%s MODE %s %s%s",
00572 servername, chptr->chname, modebuf, sendbuf);
00573 }
00574
00575
00576
00577
00578
00579
00580
00581
00582 if ((dlink_list_length(&chptr->members) == 0) && isnew)
00583 {
00584 destroy_channel(chptr);
00585 return;
00586 }
00587
00588 if (parv[4 + args][0] == '\0')
00589 return;
00590
00591
00592 DLINK_FOREACH(m, serv_list.head)
00593 {
00594 target_p = m->data;
00595
00596 if (target_p == client_p)
00597 continue;
00598
00599 if (IsCapable(target_p, CAP_TS6))
00600 sendto_one(target_p, "%s", uid_buf);
00601 else
00602 sendto_one(target_p, "%s", nick_buf);
00603 }
00604
00605 if (HasID(source_p) && !keep_our_modes)
00606 {
00607 if (dlink_list_length(&chptr->banlist) > 0)
00608 remove_ban_list(chptr, client_p, &chptr->banlist,
00609 'b', NOCAPS);
00610
00611 if (dlink_list_length(&chptr->exceptlist) > 0)
00612 remove_ban_list(chptr, client_p, &chptr->exceptlist,
00613 'e', CAP_EX);
00614
00615 if (dlink_list_length(&chptr->invexlist) > 0)
00616 remove_ban_list(chptr, client_p, &chptr->invexlist,
00617 'I', CAP_IE);
00618 clear_ban_cache(chptr);
00619 }
00620 }
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633 static const struct mode_letter
00634 {
00635 unsigned int mode;
00636 unsigned char letter;
00637 } flags[] = {
00638 { MODE_NOPRIVMSGS, 'n' },
00639 { MODE_TOPICLIMIT, 't' },
00640 { MODE_SECRET, 's' },
00641 { MODE_MODERATED, 'm' },
00642 { MODE_INVITEONLY, 'i' },
00643 { MODE_PRIVATE, 'p' },
00644 { MODE_COLORLESS, 'c' },
00645 { MODE_ASCIIONLY, 'C' },
00646 { MODE_OPERONLY, 'O' },
00647 { 0, '\0' }
00648 };
00649
00650 static void
00651 set_final_mode(struct Mode *mode, struct Mode *oldmode)
00652 {
00653 char *pbuf = parabuf;
00654 int len;
00655 int i;
00656
00657 *mbuf++ = '-';
00658
00659 for (i = 0; flags[i].letter; i++)
00660 {
00661 if ((flags[i].mode & oldmode->mode) &&
00662 !(flags[i].mode & mode->mode))
00663 *mbuf++ = flags[i].letter;
00664 }
00665
00666 if (oldmode->limit != 0 && mode->limit == 0)
00667 *mbuf++ = 'l';
00668
00669 if (oldmode->key[0] && !mode->key[0])
00670 {
00671 *mbuf++ = 'k';
00672 len = ircsprintf(pbuf, "%s ", oldmode->key);
00673 pbuf += len;
00674 pargs++;
00675 }
00676
00677 if (*(mbuf-1) == '-')
00678 *(mbuf-1) = '+';
00679 else
00680 *mbuf++ = '+';
00681
00682 for (i = 0; flags[i].letter; i++)
00683 {
00684 if ((flags[i].mode & mode->mode) &&
00685 !(flags[i].mode & oldmode->mode))
00686 *mbuf++ = flags[i].letter;
00687 }
00688
00689 if (mode->limit != 0 && oldmode->limit != mode->limit)
00690 {
00691 *mbuf++ = 'l';
00692 len = ircsprintf(pbuf, "%d ", mode->limit);
00693 pbuf += len;
00694 pargs++;
00695 }
00696
00697 if (mode->key[0] && strcmp(oldmode->key, mode->key))
00698 {
00699 *mbuf++ = 'k';
00700 len = ircsprintf(pbuf, "%s ", mode->key);
00701 pbuf += len;
00702 pargs++;
00703 }
00704 if (*(mbuf-1) == '+')
00705 *(mbuf-1) = '\0';
00706 else
00707 *mbuf = '\0';
00708 }
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718 static void
00719 remove_our_modes(struct Channel *chptr, struct Client *source_p)
00720 {
00721 remove_a_mode(chptr, source_p, CHFL_CHANOP, 'o');
00722 #ifdef HALFOPS
00723 remove_a_mode(chptr, source_p, CHFL_HALFOP, 'h');
00724 #endif
00725 remove_a_mode(chptr, source_p, CHFL_VOICE, 'v');
00726 }
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737 static void
00738 remove_a_mode(struct Channel *chptr, struct Client *source_p,
00739 int mask, char flag)
00740 {
00741 dlink_node *ptr;
00742 struct Membership *ms;
00743 char lmodebuf[MODEBUFLEN];
00744 char *sp=sendbuf;
00745 const char *lpara[MAXMODEPARAMS];
00746 int count = 0;
00747 int i;
00748 int l;
00749
00750 mbuf = lmodebuf;
00751 *mbuf++ = '-';
00752 *sp = '\0';
00753
00754 DLINK_FOREACH(ptr, chptr->members.head)
00755 {
00756 ms = ptr->data;
00757
00758 if ((ms->flags & mask) == 0)
00759 continue;
00760
00761 ms->flags &= ~mask;
00762
00763 lpara[count++] = ms->client_p->name;
00764
00765 *mbuf++ = flag;
00766
00767 if (count >= MAXMODEPARAMS)
00768 {
00769 for(i = 0; i < MAXMODEPARAMS; i++)
00770 {
00771 l = ircsprintf(sp, " %s", lpara[i]);
00772 sp += l;
00773 }
00774
00775 *mbuf = '\0';
00776 sendto_channel_local(ALL_MEMBERS, NO, chptr,
00777 ":%s MODE %s %s%s",
00778 (IsHidden(source_p) ||
00779 ConfigServerHide.hide_servers) ?
00780 me.name : source_p->name,
00781 chptr->chname, lmodebuf, sendbuf);
00782 mbuf = lmodebuf;
00783 *mbuf++ = '-';
00784 count = 0;
00785 sp = sendbuf;
00786 *sp = '\0';
00787 }
00788 }
00789
00790 if (count != 0)
00791 {
00792 *mbuf = '\0';
00793 for(i = 0; i < count; i++)
00794 {
00795 l = ircsprintf(sp, " %s", lpara[i]);
00796 sp += l;
00797 }
00798 sendto_channel_local(ALL_MEMBERS, NO, chptr,
00799 ":%s MODE %s %s%s",
00800 (IsHidden(source_p) || ConfigServerHide.hide_servers) ?
00801 me.name : source_p->name,
00802 chptr->chname, lmodebuf, sendbuf);
00803 }
00804 }
00805
00806
00807
00808
00809
00810
00811
00812
00813 static void
00814 remove_ban_list(struct Channel *chptr, struct Client *source_p,
00815 dlink_list *list, char c, int cap)
00816 {
00817 char lmodebuf[MODEBUFLEN];
00818 char lparabuf[IRCD_BUFSIZE];
00819 struct Ban *banptr = NULL;
00820 dlink_node *ptr = NULL;
00821 dlink_node *next_ptr = NULL;
00822 char *pbuf = NULL;
00823 int count = 0;
00824 int cur_len, mlen, plen;
00825
00826 pbuf = lparabuf;
00827
00828 cur_len = mlen = ircsprintf(lmodebuf, ":%s MODE %s -",
00829 source_p->name, chptr->chname);
00830 mbuf = lmodebuf + mlen;
00831
00832 DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
00833 {
00834 banptr = ptr->data;
00835
00836 plen = banptr->len + 4;
00837 if (count >= MAXMODEPARAMS ||
00838 (cur_len + 1 + (plen - 1)) > IRCD_BUFSIZE - 2)
00839 {
00840
00841 *mbuf = *(pbuf - 1) = '\0';
00842 sendto_channel_local(ALL_MEMBERS, NO, chptr, "%s %s",
00843 lmodebuf, lparabuf);
00844 sendto_server(source_p, NULL, chptr, cap, CAP_TS6, NOFLAGS,
00845 "%s %s", lmodebuf, lparabuf);
00846
00847 cur_len = mlen;
00848 mbuf = lmodebuf + mlen;
00849 pbuf = lparabuf;
00850 count = 0;
00851 }
00852
00853 *mbuf++ = c;
00854 cur_len += plen;
00855 pbuf += ircsprintf(pbuf, "%s!%s@%s ", banptr->name, banptr->username,
00856 banptr->host);
00857 ++count;
00858
00859 remove_ban(banptr, list);
00860 }
00861
00862 *mbuf = *(pbuf - 1) = '\0';
00863 sendto_channel_local(ALL_MEMBERS, NO, chptr, "%s %s", lmodebuf, lparabuf);
00864 sendto_server(source_p, NULL, chptr, cap, CAP_TS6, NOFLAGS,
00865 "%s %s", lmodebuf, lparabuf);
00866 }
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877 static void
00878 introduce_lazy_link_clients(struct Client *client_p,
00879 struct Client *target_p, struct Channel *chptr)
00880 {
00881 struct Client *lclient_p;
00882 dlink_node *m;
00883
00884 DLINK_FOREACH(m, serv_list.head)
00885 {
00886 lclient_p = m->data;
00887
00888
00889 if (client_p == lclient_p)
00890 continue;
00891
00892
00893 if (!IsCapable(lclient_p,CAP_LL))
00894 continue;
00895
00896
00897 if (!chptr->lazyLinkChannelExists &
00898 (lclient_p->localClient->serverMask))
00899 continue;
00900
00901
00902 if (!(target_p->lazyLinkClientExists &
00903 lclient_p->localClient->serverMask))
00904 {
00905
00906
00907 sendnick_TS(lclient_p, target_p);
00908 add_lazylinkclient(lclient_p,target_p);
00909 }
00910 }
00911 }