ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/channel_mode.c

Comparing ircd-hybrid/trunk/src/channel_mode.c (file contents):
Revision 3841 by michael, Thu Jun 5 11:19:00 2014 UTC vs.
Revision 4800 by michael, Tue Oct 28 13:59:43 2014 UTC

#	Line 15 | Line 15
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18	>	*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19		*  USA
20		*/
21
#	Line 112 | Line 112 | int
112		add_id(struct Client *client_p, struct Channel *chptr, char *banid, unsigned int type)
113		{
114		dlink_list *list = NULL;
115	<	dlink_node *ptr = NULL;
115	>	dlink_node *node = NULL;
116		struct Ban *banptr = NULL;
117		size_t len = 0;
118		char name[NICKLEN + 1] = "";
#	Line 129 | Line 129 | add_id(struct Client *client_p, struct C
129
130		if (num_mask >= ConfigChannel.max_bans)
131		{
132	<	sendto_one_numeric(client_p, &me, ERR_BANLISTFULL, chptr->chname, banid);
132	>	sendto_one_numeric(client_p, &me, ERR_BANLISTFULL, chptr->name, banid);
133		return 0;
134		}
135
#	Line 171 | Line 171 | add_id(struct Client *client_p, struct C
171		return 0;
172		}
173
174	<	DLINK_FOREACH(ptr, list->head)
174	>	DLINK_FOREACH(node, list->head)
175		{
176	<	banptr = ptr->data;
176	>	banptr = node->data;
177
178		if (!irccmp(banptr->name, name) &&
179		!irccmp(banptr->user, user) &&
#	Line 182 | Line 182 | add_id(struct Client *client_p, struct C
182		}
183
184		banptr = mp_pool_get(ban_pool);
185	–	memset(banptr, 0, sizeof(*banptr));
186	–
185		banptr->name = xstrdup(name);
186		banptr->user = xstrdup(user);
187		banptr->host = xstrdup(host);
188		banptr->when = CurrentTime;
189	<	banptr->len = len - 2;  /* -2 for @ and ! */
189	>	banptr->len = len - 2;  /* -2 for ! + @ */
190		banptr->type = parse_netmask(host, &banptr->addr, &banptr->bits);
191
192		if (IsClient(client_p))
#	Line 220 | Line 218 | static int
218		del_id(struct Channel *chptr, char *banid, unsigned int type)
219		{
220		dlink_list *list = NULL;
221	<	dlink_node *ptr = NULL;
221	>	dlink_node *node = NULL;
222		char name[NICKLEN + 1] = "";
223		char user[USERLEN + 1] = "";
224		char host[HOSTLEN + 1] = "";
#	Line 263 | Line 261 | del_id(struct Channel *chptr, char *bani
261		return 0;
262		}
263
264	<	DLINK_FOREACH(ptr, list->head)
264	>	DLINK_FOREACH(node, list->head)
265		{
266	<	struct Ban *banptr = ptr->data;
266	>	struct Ban *banptr = node->data;
267
268		if (!irccmp(name, banptr->name) &&
269		!irccmp(user, banptr->user) &&
#	Line 351 | Line 349 | fix_key(char *arg)
349		void
350		clear_ban_cache(struct Channel *chptr)
351		{
352	<	dlink_node *ptr = NULL;
352	>	dlink_node *node = NULL;
353
354	<	DLINK_FOREACH(ptr, chptr->members.head)
354	>	DLINK_FOREACH(node, chptr->locmembers.head)
355		{
356	<	struct Membership *ms = ptr->data;
357	<
360	<	if (MyConnect(ms->client_p))
361	<	ms->flags &= ~(CHFL_BAN_SILENCED|CHFL_BAN_CHECKED);
356	>	struct Membership *ms = node->data;
357	>	ms->flags &= ~(CHFL_BAN_SILENCED|CHFL_BAN_CHECKED);
358		}
359		}
360
361		void
362		clear_ban_cache_client(struct Client *client_p)
363		{
364	<	dlink_node *ptr = NULL;
364	>	dlink_node *node = NULL;
365
366	<	DLINK_FOREACH(ptr, client_p->channel.head)
366	>	DLINK_FOREACH(node, client_p->channel.head)
367		{
368	<	struct Membership *ms = ptr->data;
368	>	struct Membership *ms = node->data;
369		ms->flags &= ~(CHFL_BAN_SILENCED|CHFL_BAN_CHECKED);
370		}
371		}
#	Line 411 | Line 407 | chm_simple(struct Client *source_p, stru
407		if (!(*errors & SM_ERR_NOOPS))
408		sendto_one_numeric(source_p, &me,
409		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
410	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
410	>	ERR_CHANOPRIVSNEEDED, chptr->name);
411		*errors |= SM_ERR_NOOPS;
412		return;
413		}
#	Line 437 | Line 433 | chm_simple(struct Client *source_p, stru
433		mode_changes[mode_count].letter = c;
434		mode_changes[mode_count].arg = NULL;
435		mode_changes[mode_count].id = NULL;
436	<	mode_changes[mode_count].dir = dir;
441	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
436	>	mode_changes[mode_count++].dir = dir;
437		}
438		else if (dir == MODE_DEL) /* && (chptr->mode.mode & d)) */
439		{
#	Line 449 | Line 444 | chm_simple(struct Client *source_p, stru
444		mode_changes[mode_count].letter = c;
445		mode_changes[mode_count].arg = NULL;
446		mode_changes[mode_count].id = NULL;
447	<	mode_changes[mode_count].dir = dir;
453	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
447	>	mode_changes[mode_count++].dir = dir;
448		}
449		}
450
#	Line 463 | Line 457 | chm_registered(struct Client *source_p,
457		if (!(*errors & SM_ERR_ONLYSERVER))
458		sendto_one_numeric(source_p, &me,
459		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
460	<	ERR_ONLYSERVERSCANCHANGE, chptr->chname);
460	>	ERR_ONLYSERVERSCANCHANGE, chptr->name);
461		*errors |= SM_ERR_ONLYSERVER;
462		return;
463		}
#	Line 489 | Line 483 | chm_registered(struct Client *source_p,
483		mode_changes[mode_count].letter = c;
484		mode_changes[mode_count].arg = NULL;
485		mode_changes[mode_count].id = NULL;
486	<	mode_changes[mode_count].dir = dir;
493	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
486	>	mode_changes[mode_count++].dir = dir;
487		}
488		else if (dir == MODE_DEL) /* && (chptr->mode.mode & d)) */
489		{
#	Line 501 | Line 494 | chm_registered(struct Client *source_p,
494		mode_changes[mode_count].letter = c;
495		mode_changes[mode_count].arg = NULL;
496		mode_changes[mode_count].id = NULL;
497	<	mode_changes[mode_count].dir = dir;
505	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
497	>	mode_changes[mode_count++].dir = dir;
498		}
499		}
500
#	Line 515 | Line 507 | chm_operonly(struct Client *source_p, st
507		if (!(*errors & SM_ERR_NOOPS))
508		sendto_one_numeric(source_p, &me,
509		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
510	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
510	>	ERR_CHANOPRIVSNEEDED, chptr->name);
511
512		*errors |= SM_ERR_NOOPS;
513		return;
#	Line 543 | Line 535 | chm_operonly(struct Client *source_p, st
535		mode_changes[mode_count].letter = c;
536		mode_changes[mode_count].arg = NULL;
537		mode_changes[mode_count].id = NULL;
538	<	mode_changes[mode_count].dir = dir;
547	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
538	>	mode_changes[mode_count++].dir = dir;
539		}
540		else if (dir == MODE_DEL) /* && (chptr->mode.mode & d)) */
541		{
#	Line 555 | Line 546 | chm_operonly(struct Client *source_p, st
546		mode_changes[mode_count].letter = c;
547		mode_changes[mode_count].arg = NULL;
548		mode_changes[mode_count].id = NULL;
549	<	mode_changes[mode_count].dir = dir;
559	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
549	>	mode_changes[mode_count++].dir = dir;
550		}
551		}
552
#	Line 568 | Line 558 | chm_ban(struct Client *source_p, struct
558
559		if (dir == MODE_QUERY || parc <= *parn)
560		{
561	<	dlink_node *ptr = NULL;
561	>	dlink_node *node = NULL;
562
563		if (*errors & SM_ERR_RPL_B)
564		return;
565
566		*errors |= SM_ERR_RPL_B;
567
568	<	DLINK_FOREACH(ptr, chptr->banlist.head)
568	>	DLINK_FOREACH(node, chptr->banlist.head)
569		{
570	<	const struct Ban *banptr = ptr->data;
571	<	sendto_one_numeric(source_p, &me, RPL_BANLIST, chptr->chname,
570	>	const struct Ban *banptr = node->data;
571	>	sendto_one_numeric(source_p, &me, RPL_BANLIST, chptr->name,
572		banptr->name, banptr->user, banptr->host,
573		banptr->who, banptr->when);
574		}
575
576	<	sendto_one_numeric(source_p, &me, RPL_ENDOFBANLIST, chptr->chname);
576	>	sendto_one_numeric(source_p, &me, RPL_ENDOFBANLIST, chptr->name);
577		return;
578		}
579
#	Line 592 | Line 582 | chm_ban(struct Client *source_p, struct
582		if (!(*errors & SM_ERR_NOOPS))
583		sendto_one_numeric(source_p, &me,
584		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
585	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
585	>	ERR_CHANOPRIVSNEEDED, chptr->name);
586		*errors |= SM_ERR_NOOPS;
587		return;
588		}
#	Line 602 | Line 592 | chm_ban(struct Client *source_p, struct
592
593		mask = nuh_mask[*parn];
594		memcpy(mask, parv[*parn], sizeof(nuh_mask[*parn]));
595	<	++*parn;
595	>	++(*parn);
596
597		if (!MyConnect(source_p))
598		if (strchr(mask, ' '))
#	Line 625 | Line 615 | chm_ban(struct Client *source_p, struct
615		mode_changes[mode_count].letter = c;
616		mode_changes[mode_count].arg = mask;
617		mode_changes[mode_count].id = NULL;
618	<	mode_changes[mode_count].dir = dir;
629	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
618	>	mode_changes[mode_count++].dir = dir;
619		}
620
621		static void
#	Line 637 | Line 626 | chm_except(struct Client *source_p, stru
626
627		if (dir == MODE_QUERY || parc <= *parn)
628		{
629	<	dlink_node *ptr = NULL;
629	>	dlink_node *node = NULL;
630
631		if (*errors & SM_ERR_RPL_E)
632		return;
633
634		*errors |= SM_ERR_RPL_E;
635
636	<	DLINK_FOREACH(ptr, chptr->exceptlist.head)
636	>	DLINK_FOREACH(node, chptr->exceptlist.head)
637		{
638	<	const struct Ban *banptr = ptr->data;
638	>	const struct Ban *banptr = node->data;
639
640	<	sendto_one_numeric(source_p, &me, RPL_EXCEPTLIST, chptr->chname,
640	>	sendto_one_numeric(source_p, &me, RPL_EXCEPTLIST, chptr->name,
641		banptr->name, banptr->user, banptr->host,
642		banptr->who, banptr->when);
643		}
644
645	<	sendto_one_numeric(source_p, &me, RPL_ENDOFEXCEPTLIST, chptr->chname);
645	>	sendto_one_numeric(source_p, &me, RPL_ENDOFEXCEPTLIST, chptr->name);
646		return;
647		}
648
#	Line 662 | Line 651 | chm_except(struct Client *source_p, stru
651		if (!(*errors & SM_ERR_NOOPS))
652		sendto_one_numeric(source_p, &me,
653		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
654	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
654	>	ERR_CHANOPRIVSNEEDED, chptr->name);
655		*errors |= SM_ERR_NOOPS;
656		return;
657		}
#	Line 672 | Line 661 | chm_except(struct Client *source_p, stru
661
662		mask = nuh_mask[*parn];
663		memcpy(mask, parv[*parn], sizeof(nuh_mask[*parn]));
664	<	++*parn;
664	>	++(*parn);
665
666		if (!MyConnect(source_p))
667		if (strchr(mask, ' '))
#	Line 695 | Line 684 | chm_except(struct Client *source_p, stru
684		mode_changes[mode_count].letter = c;
685		mode_changes[mode_count].arg = mask;
686		mode_changes[mode_count].id = NULL;
687	<	mode_changes[mode_count].dir = dir;
699	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
687	>	mode_changes[mode_count++].dir = dir;
688		}
689
690		static void
#	Line 707 | Line 695 | chm_invex(struct Client *source_p, struc
695
696		if (dir == MODE_QUERY || parc <= *parn)
697		{
698	<	dlink_node *ptr = NULL;
698	>	dlink_node *node = NULL;
699
700		if (*errors & SM_ERR_RPL_I)
701		return;
702
703		*errors |= SM_ERR_RPL_I;
704
705	<	DLINK_FOREACH(ptr, chptr->invexlist.head)
705	>	DLINK_FOREACH(node, chptr->invexlist.head)
706		{
707	<	const struct Ban *banptr = ptr->data;
707	>	const struct Ban *banptr = node->data;
708
709	<	sendto_one_numeric(source_p, &me, RPL_INVEXLIST, chptr->chname,
709	>	sendto_one_numeric(source_p, &me, RPL_INVEXLIST, chptr->name,
710		banptr->name, banptr->user, banptr->host,
711		banptr->who, banptr->when);
712		}
713
714	<	sendto_one_numeric(source_p, &me, RPL_ENDOFINVEXLIST, chptr->chname);
714	>	sendto_one_numeric(source_p, &me, RPL_ENDOFINVEXLIST, chptr->name);
715		return;
716		}
717
#	Line 732 | Line 720 | chm_invex(struct Client *source_p, struc
720		if (!(*errors & SM_ERR_NOOPS))
721		sendto_one_numeric(source_p, &me,
722		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
723	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
723	>	ERR_CHANOPRIVSNEEDED, chptr->name);
724		*errors |= SM_ERR_NOOPS;
725		return;
726		}
#	Line 742 | Line 730 | chm_invex(struct Client *source_p, struc
730
731		mask = nuh_mask[*parn];
732		memcpy(mask, parv[*parn], sizeof(nuh_mask[*parn]));
733	<	++*parn;
733	>	++(*parn);
734
735		if (!MyConnect(source_p))
736		if (strchr(mask, ' '))
#	Line 765 | Line 753 | chm_invex(struct Client *source_p, struc
753		mode_changes[mode_count].letter = c;
754		mode_changes[mode_count].arg = mask;
755		mode_changes[mode_count].id = NULL;
756	<	mode_changes[mode_count].dir = dir;
769	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
756	>	mode_changes[mode_count++].dir = dir;
757		}
758
759		static void
#	Line 781 | Line 768 | chm_voice(struct Client *source_p, struc
768		if (!(*errors & SM_ERR_NOOPS))
769		sendto_one_numeric(source_p, &me,
770		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
771	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
771	>	ERR_CHANOPRIVSNEEDED, chptr->name);
772		*errors |= SM_ERR_NOOPS;
773		return;
774		}
#	Line 795 | Line 782 | chm_voice(struct Client *source_p, struc
782		if ((member = find_channel_link(target_p, chptr)) == NULL)
783		{
784		if (!(*errors & SM_ERR_NOTONCHANNEL))
785	<	sendto_one_numeric(source_p, &me, ERR_USERNOTINCHANNEL, target_p->name, chptr->chname);
785	>	sendto_one_numeric(source_p, &me, ERR_USERNOTINCHANNEL, target_p->name, chptr->name);
786		*errors |= SM_ERR_NOTONCHANNEL;
787		return;
788		}
#	Line 812 | Line 799 | chm_voice(struct Client *source_p, struc
799		mode_changes[mode_count].letter = c;
800		mode_changes[mode_count].arg = target_p->name;
801		mode_changes[mode_count].id = target_p->id;
802	<	mode_changes[mode_count].dir = dir;
816	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
802	>	mode_changes[mode_count++].dir = dir;
803
804		if (dir == MODE_ADD)
805		AddMemberFlag(member, CHFL_VOICE);
#	Line 833 | Line 819 | chm_hop(struct Client *source_p, struct
819		if (!(*errors & SM_ERR_NOOPS))
820		sendto_one_numeric(source_p, &me,
821		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
822	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
822	>	ERR_CHANOPRIVSNEEDED, chptr->name);
823		*errors |= SM_ERR_NOOPS;
824		return;
825		}
#	Line 847 | Line 833 | chm_hop(struct Client *source_p, struct
833		if ((member = find_channel_link(target_p, chptr)) == NULL)
834		{
835		if (!(*errors & SM_ERR_NOTONCHANNEL))
836	<	sendto_one_numeric(source_p, &me, ERR_USERNOTINCHANNEL, target_p->name, chptr->chname);
836	>	sendto_one_numeric(source_p, &me, ERR_USERNOTINCHANNEL, target_p->name, chptr->name);
837		*errors |= SM_ERR_NOTONCHANNEL;
838		return;
839		}
#	Line 864 | Line 850 | chm_hop(struct Client *source_p, struct
850		mode_changes[mode_count].letter = c;
851		mode_changes[mode_count].arg = target_p->name;
852		mode_changes[mode_count].id = target_p->id;
853	<	mode_changes[mode_count].dir = dir;
868	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
853	>	mode_changes[mode_count++].dir = dir;
854
855		if (dir == MODE_ADD)
856		AddMemberFlag(member, CHFL_HALFOP);
#	Line 885 | Line 870 | chm_op(struct Client *source_p, struct C
870		if (!(*errors & SM_ERR_NOOPS))
871		sendto_one_numeric(source_p, &me,
872		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
873	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
873	>	ERR_CHANOPRIVSNEEDED, chptr->name);
874		*errors |= SM_ERR_NOOPS;
875		return;
876		}
#	Line 899 | Line 884 | chm_op(struct Client *source_p, struct C
884		if ((member = find_channel_link(target_p, chptr)) == NULL)
885		{
886		if (!(*errors & SM_ERR_NOTONCHANNEL))
887	<	sendto_one_numeric(source_p, &me, ERR_USERNOTINCHANNEL, target_p->name, chptr->chname);
887	>	sendto_one_numeric(source_p, &me, ERR_USERNOTINCHANNEL, target_p->name, chptr->name);
888		*errors |= SM_ERR_NOTONCHANNEL;
889		return;
890		}
#	Line 916 | Line 901 | chm_op(struct Client *source_p, struct C
901		mode_changes[mode_count].letter = c;
902		mode_changes[mode_count].arg = target_p->name;
903		mode_changes[mode_count].id = target_p->id;
904	<	mode_changes[mode_count].dir = dir;
920	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
904	>	mode_changes[mode_count++].dir = dir;
905
906		if (dir == MODE_ADD)
907		AddMemberFlag(member, CHFL_CHANOP);
#	Line 936 | Line 920 | chm_limit(struct Client *source_p, struc
920		if (!(*errors & SM_ERR_NOOPS))
921		sendto_one_numeric(source_p, &me,
922		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
923	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
923	>	ERR_CHANOPRIVSNEEDED, chptr->name);
924		*errors |= SM_ERR_NOOPS;
925		return;
926		}
#	Line 961 | Line 945 | chm_limit(struct Client *source_p, struc
945		mode_changes[mode_count].letter = c;
946		mode_changes[mode_count].arg = lstr;
947		mode_changes[mode_count].id = NULL;
948	<	mode_changes[mode_count].dir = dir;
965	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
948	>	mode_changes[mode_count++].dir = dir;
949
950		chptr->mode.limit = limit;
951		}
#	Line 976 | Line 959 | chm_limit(struct Client *source_p, struc
959		mode_changes[mode_count].letter = c;
960		mode_changes[mode_count].arg = NULL;
961		mode_changes[mode_count].id = NULL;
962	<	mode_changes[mode_count].dir = dir;
980	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
962	>	mode_changes[mode_count++].dir = dir;
963		}
964		}
965
#	Line 990 | Line 972 | chm_key(struct Client *source_p, struct
972		if (!(*errors & SM_ERR_NOOPS))
973		sendto_one_numeric(source_p, &me,
974		alev == CHACCESS_NOTONCHAN ? ERR_NOTONCHANNEL :
975	<	ERR_CHANOPRIVSNEEDED, chptr->chname);
975	>	ERR_CHANOPRIVSNEEDED, chptr->name);
976		*errors |= SM_ERR_NOOPS;
977		return;
978		}
#	Line 1016 | Line 998 | chm_key(struct Client *source_p, struct
998		mode_changes[mode_count].letter = c;
999		mode_changes[mode_count].arg = chptr->mode.key;
1000		mode_changes[mode_count].id = NULL;
1001	<	mode_changes[mode_count].dir = dir;
1020	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
1001	>	mode_changes[mode_count++].dir = dir;
1002		}
1003		else if (dir == MODE_DEL)
1004		{
1005		if (parc > *parn)
1006	<	(*parn)++;
1006	>	++(*parn);
1007
1008		if (chptr->mode.key[0] == '\0')
1009		return;
#	Line 1032 | Line 1013 | chm_key(struct Client *source_p, struct
1013		mode_changes[mode_count].letter = c;
1014		mode_changes[mode_count].arg = "*";
1015		mode_changes[mode_count].id = NULL;
1016	<	mode_changes[mode_count].dir = dir;
1036	<	mode_changes[mode_count++].mems = ALL_MEMBERS;
1016	>	mode_changes[mode_count++].dir = dir;
1017		}
1018		}
1019
#	Line 1311 | Line 1291 | get_channel_access(const struct Client *
1291		{
1292		/* Let hacked servers in for now... */
1293		if (!MyClient(source_p))
1294	<	return CHACCESS_CHANOP;
1294	>	return CHACCESS_REMOTE;
1295
1296		if (!member)
1297		return CHACCESS_NOTONCHAN;
#	Line 1348 | Line 1328 | send_mode_changes_server(struct Client *
1328		parptr = parabuf;
1329
1330		mbl = snprintf(modebuf, sizeof(modebuf), ":%s TMODE %lu %s ", source_p->id,
1331	<	(unsigned long)chptr->channelts, chptr->chname);
1331	>	(unsigned long)chptr->channelts, chptr->name);
1332
1333		/* Loop the list of modes we have */
1334		for (unsigned i = 0; i < mode_count; ++i)
#	Line 1381 | Line 1361 | send_mode_changes_server(struct Client *
1361		mc = 0;
1362
1363		mbl = snprintf(modebuf, sizeof(modebuf), ":%s TMODE %lu %s ", source_p->id,
1364	<	(unsigned long)chptr->channelts, chptr->chname);
1364	>	(unsigned long)chptr->channelts, chptr->name);
1365
1366		pbl = 0;
1367		parabuf[0] = '\0';
#	Line 1397 | Line 1377 | send_mode_changes_server(struct Client *
1377
1378		modebuf[mbl++] = mode_changes[i].letter;
1379		modebuf[mbl] = '\0';
1380	<	nc++;
1380	>	++nc;
1381
1382		if (arg)
1383		{
1384		len = sprintf(parptr, "%s ", arg);
1385		pbl += len;
1386		parptr += len;
1387	<	mc++;
1387	>	++mc;
1388		}
1389		}
1390
#	Line 1442 | Line 1422 | send_mode_changes(struct Client *source_
1422		if (IsServer(source_p))
1423		mbl = snprintf(modebuf, sizeof(modebuf), ":%s MODE %s ", (IsHidden(source_p) ||
1424		ConfigServerHide.hide_servers) ?
1425	<	me.name : source_p->name, chptr->chname);
1425	>	me.name : source_p->name, chptr->name);
1426		else
1427		mbl = snprintf(modebuf, sizeof(modebuf), ":%s!%s@%s MODE %s ", source_p->name,
1428	<	source_p->username, source_p->host, chptr->chname);
1428	>	source_p->username, source_p->host, chptr->name);
1429
1430		parabuf[0] = '\0';
1431		parptr = parabuf;
1432
1433		for (unsigned int i = 0; i < mode_count; ++i)
1434		{
1435	<	if (mode_changes[i].letter == 0 ||
1456	<	mode_changes[i].mems == ONLY_SERVERS)
1435	>	if (mode_changes[i].letter == 0)
1436		continue;
1437
1438		arg = mode_changes[i].arg;
#	Line 1462 | Line 1441 | send_mode_changes(struct Client *source_
1441		else
1442		arglen = 0;
1443
1444	<	if ((mc == MAXMODEPARAMS)  ||
1444	>	if ((mc == MAXMODEPARAMS) ||
1445		((arglen + mbl + pbl + 2) > IRCD_BUFSIZE) ||
1446		((arglen + pbl + BAN_FUDGE) >= MODEBUFLEN))
1447		{
#	Line 1470 | Line 1449 | send_mode_changes(struct Client *source_
1449		modebuf[mbl - 1] = '\0';
1450
1451		if (nc)
1452	<	sendto_channel_local(ALL_MEMBERS, 0, chptr, "%s %s", modebuf, parabuf);
1452	>	sendto_channel_local(0, chptr, "%s %s", modebuf, parabuf);
1453
1454		nc = 0;
1455		mc = 0;
#	Line 1478 | Line 1457 | send_mode_changes(struct Client *source_
1457		if (IsServer(source_p))
1458		mbl = snprintf(modebuf, sizeof(modebuf), ":%s MODE %s ", (IsHidden(source_p) ||
1459		ConfigServerHide.hide_servers) ?
1460	<	me.name : source_p->name, chptr->chname);
1460	>	me.name : source_p->name, chptr->name);
1461		else
1462		mbl = snprintf(modebuf, sizeof(modebuf), ":%s!%s@%s MODE %s ", source_p->name,
1463	<	source_p->username, source_p->host, chptr->chname);
1463	>	source_p->username, source_p->host, chptr->name);
1464
1465		pbl = 0;
1466		parabuf[0] = '\0';
#	Line 1497 | Line 1476 | send_mode_changes(struct Client *source_
1476
1477		modebuf[mbl++] = mode_changes[i].letter;
1478		modebuf[mbl] = '\0';
1479	<	nc++;
1479	>	++nc;
1480
1481		if (arg)
1482		{
1483		len = sprintf(parptr, "%s ", arg);
1484		pbl += len;
1485		parptr += len;
1486	<	mc++;
1486	>	++mc;
1487		}
1488		}
1489
#	Line 1512 | Line 1491 | send_mode_changes(struct Client *source_
1491		parabuf[pbl - 1] = '\0';
1492
1493		if (nc)
1494	<	sendto_channel_local(ALL_MEMBERS, 0, chptr, "%s %s", modebuf, parabuf);
1494	>	sendto_channel_local(0, chptr, "%s %s", modebuf, parabuf);
1495
1496		send_mode_changes_server(source_p, chptr);
1497		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)