ViewVC Help

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

root/svn/ircd-hybrid/branches/8.2.x/src/conf_class.c

Comparing:
ircd-hybrid/trunk/src/conf_class.c (file contents), Revision 1666 by michael, Sun Nov 18 17:03:18 2012 UTC vs.
ircd-hybrid/branches/8.2.x/src/conf_class.c (file contents), Revision 3505 by michael, Sat May 10 19:51:42 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2002 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 1997-2014 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
#	Line 19 | Line 19
19		*  USA
20		*/
21
22	<	/*! \file
22	>	/*! \file conf_class.c
23		* \brief Configuration managment for class{} blocks
24		* \version $Id$
25		*/
#	Line 35 | Line 35
35
36		struct ClassItem *class_default;
37
38	<	static dlink_list class_list = { NULL, NULL, 0 };
38	>	static dlink_list class_list;
39
40
41		const dlink_list *
#	Line 47 | Line 47 | class_get_list(void)
47		struct ClassItem *
48		class_make(void)
49		{
50	<	struct ClassItem *class = MyMalloc(sizeof(*class));
50	>	struct ClassItem *class = MyCalloc(sizeof(*class));
51
52		class->active    = 1;
53		class->con_freq  = DEFAULT_CONNECTFREQUENCY;
#	Line 79 | Line 79 | class_init(void)
79		(class_default = class_make())->name = xstrdup("default");
80		}
81
82	+	struct ClassItem *
83	+	get_class_ptr(const dlink_list *const list)
84	+	{
85	+	const dlink_node *ptr = NULL;
86	+
87	+	if ((ptr = list->head))
88	+	{
89	+	const struct MaskItem *conf = ptr->data;
90	+
91	+	assert(conf->class);
92	+	assert(conf->type & (CONF_OPER | CONF_CLIENT | CONF_SERVER));
93	+
94	+	return conf->class;
95	+	}
96	+
97	+	return class_default;
98	+	}
99	+
100		const char *
101		get_client_class(const dlink_list *const list)
102		{
103		const dlink_node *ptr = NULL;
104
105	<	if ((ptr = list->head)) {
105	>	if ((ptr = list->head))
106	>	{
107		const struct MaskItem *conf = ptr->data;
108
109		assert(conf->class);
#	Line 101 | Line 120 | get_client_ping(const dlink_list *const
120		{
121		const dlink_node *ptr = NULL;
122
123	<	if ((ptr = list->head)) {
123	>	if ((ptr = list->head))
124	>	{
125		const struct MaskItem *conf = ptr->data;
126
127		assert(conf->class);
#	Line 118 | Line 138 | get_sendq(const dlink_list *const list)
138		{
139		const dlink_node *ptr = NULL;
140
141	<	if ((ptr = list->head)) {
141	>	if ((ptr = list->head))
142	>	{
143		const struct MaskItem *conf = ptr->data;
144
145		assert(conf->class);
#	Line 135 | Line 156 | get_recvq(const dlink_list *const list)
156		{
157		const dlink_node *ptr = NULL;
158
159	<	if ((ptr = list->head)) {
159	>	if ((ptr = list->head))
160	>	{
161		const struct MaskItem *conf = ptr->data;
162
163		assert(conf->class);
#	Line 157 | Line 179 | class_find(const char *name, int active)
179		{
180		dlink_node *ptr = NULL;
181
182	<	DLINK_FOREACH(ptr, class_list.head) {
182	>	DLINK_FOREACH(ptr, class_list.head)
183	>	{
184		struct ClassItem *class = ptr->data;
185
186		if (!irccmp(class->name, name))
#	Line 185 | Line 208 | class_delete_marked(void)
208		{
209		dlink_node *ptr = NULL, *ptr_next = NULL;
210
211	<	DLINK_FOREACH_SAFE(ptr, ptr_next, class_list.head) {
211	>	DLINK_FOREACH_SAFE(ptr, ptr_next, class_list.head)
212	>	{
213		struct ClassItem *class = ptr->data;
214
215		if (!class->active && !class->ref_count)
#	Line 207 | Line 231 | class_delete_marked(void)
231		* side effects -
232		*/
233		int
234	<	cidr_limit_reached(int over_rule,
211	<	struct irc_ssaddr *ip, struct ClassItem *class)
234	>	cidr_limit_reached(int over_rule, struct irc_ssaddr *ip, struct ClassItem *class)
235		{
236		dlink_node *ptr = NULL;
237		struct CidrItem *cidr = NULL;
#	Line 224 | Line 247 | cidr_limit_reached(int over_rule,
247		DLINK_FOREACH(ptr, class->list_ipv4.head)
248		{
249		cidr = ptr->data;
250	+
251		if (match_ipv4(ip, &cidr->mask, class->cidr_bitlen_ipv4))
252		{
253		if (!over_rule && (cidr->number_on_this_cidr >= class->number_per_cidr))
254		return -1;
255	+
256		cidr->number_on_this_cidr++;
257		return 0;
258		}
259		}
260	<	cidr = MyMalloc(sizeof(struct CidrItem));
260	>
261	>	cidr = MyCalloc(sizeof(struct CidrItem));
262		cidr->number_on_this_cidr = 1;
263		cidr->mask = *ip;
264		mask_addr(&cidr->mask, class->cidr_bitlen_ipv4);
#	Line 244 | Line 270 | cidr_limit_reached(int over_rule,
270		DLINK_FOREACH(ptr, class->list_ipv6.head)
271		{
272		cidr = ptr->data;
273	+
274		if (match_ipv6(ip, &cidr->mask, class->cidr_bitlen_ipv6))
275		{
276		if (!over_rule && (cidr->number_on_this_cidr >= class->number_per_cidr))
277		return -1;
278	+
279		cidr->number_on_this_cidr++;
280		return 0;
281		}
282		}
283	<	cidr = MyMalloc(sizeof(struct CidrItem));
283	>
284	>	cidr = MyCalloc(sizeof(struct CidrItem));
285		cidr->number_on_this_cidr = 1;
286		cidr->mask = *ip;
287		mask_addr(&cidr->mask, class->cidr_bitlen_ipv6);
#	Line 288 | Line 317 | remove_from_cidr_check(struct irc_ssaddr
317		DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv4.head)
318		{
319		cidr = ptr->data;
320	+
321		if (match_ipv4(ip, &cidr->mask, aclass->cidr_bitlen_ipv4))
322		{
323	<	cidr->number_on_this_cidr--;
324	<	if (cidr->number_on_this_cidr == 0)
325	<	{
326	<	dlinkDelete(ptr, &aclass->list_ipv4);
327	<	MyFree(cidr);
328	<	return;
329	<	}
323	>	cidr->number_on_this_cidr--;
324	>
325	>	if (cidr->number_on_this_cidr == 0)
326	>	{
327	>	dlinkDelete(ptr, &aclass->list_ipv4);
328	>	MyFree(cidr);
329	>	return;
330	>	}
331		}
332		}
333		}
#	Line 306 | Line 337 | remove_from_cidr_check(struct irc_ssaddr
337		DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv6.head)
338		{
339		cidr = ptr->data;
340	+
341		if (match_ipv6(ip, &cidr->mask, aclass->cidr_bitlen_ipv6))
342		{
343	<	cidr->number_on_this_cidr--;
344	<	if (cidr->number_on_this_cidr == 0)
345	<	{
346	<	dlinkDelete(ptr, &aclass->list_ipv6);
347	<	MyFree(cidr);
348	<	return;
349	<	}
343	>	cidr->number_on_this_cidr--;
344	>
345	>	if (cidr->number_on_this_cidr == 0)
346	>	{
347	>	dlinkDelete(ptr, &aclass->list_ipv6);
348	>	MyFree(cidr);
349	>	return;
350	>	}
351		}
352		}
353		}
#	Line 324 | Line 357 | remove_from_cidr_check(struct irc_ssaddr
357		void
358		rebuild_cidr_list(struct ClassItem *class)
359		{
360	<	dlink_node *ptr;
360	>	dlink_node *ptr = NULL;
361
362		destroy_cidr_class(class);
363
#	Line 349 | Line 382 | rebuild_cidr_list(struct ClassItem *clas
382		static void
383		destroy_cidr_list(dlink_list *list)
384		{
385	<	dlink_node *ptr = NULL, *next_ptr = NULL;
385	>	dlink_node *ptr = NULL, *ptr_next = NULL;
386
387	<	DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
387	>	DLINK_FOREACH_SAFE(ptr, ptr_next, list->head)
388		{
389		dlinkDelete(ptr, list);
390		MyFree(ptr->data);

Diff Legend

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