ViewVC Help

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

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

Comparing ircd-hybrid/trunk/src/conf_class.c (file contents):
Revision 1646 by michael, Wed Nov 7 21:02:43 2012 UTC vs.
Revision 4565 by michael, Sun Aug 24 10:27:40 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 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
22	<	/*! \file
22	>	/*! \file conf_class.c
23		* \brief Configuration managment for class{} blocks
24		* \version $Id$
25		*/
26
27		#include "stdinc.h"
28		#include "list.h"
29	–	#include "ircd_defs.h"
30	–	#include "balloc.h"
31	–	#include "conf.h"
32	–	#include "s_serv.h"
33	–	#include "resv.h"
34	–	#include "channel.h"
35	–	#include "client.h"
36	–	#include "event.h"
37	–	#include "hook.h"
38	–	#include "irc_string.h"
39	–	#include "s_bsd.h"
29		#include "ircd.h"
30	<	#include "listener.h"
30	>	#include "conf.h"
31		#include "hostmask.h"
32	<	#include "modules.h"
44	<	#include "numeric.h"
45	<	#include "fdlist.h"
46	<	#include "log.h"
47	<	#include "send.h"
48	<	#include "s_gline.h"
32	>	#include "irc_string.h"
33		#include "memory.h"
50	–	#include "irc_res.h"
51	–	#include "userhost.h"
52	–	#include "s_user.h"
53	–	#include "channel_mode.h"
54	–	#include "parse.h"
55	–	#include "s_misc.h"
56	–	#include "conf_db.h"
34
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 70 | 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;
54	>	class->ping_freq = DEFAULT_PINGFREQUENCY;
55	>	class->max_total = MAXIMUM_LINKS_DEFAULT;
56	>	class->max_sendq = DEFAULT_SENDQ;
57	>	class->max_recvq = DEFAULT_RECVQ;
58
59		dlinkAdd(class, &class->node, &class_list);
60
#	Line 80 | Line 64 | class_make(void)
64		void
65		class_free(struct ClassItem *class)
66		{
67	<	assert(class);
67	>	assert(class != class_default);
68		assert(class->active    == 0);
69		assert(class->ref_count == 0);
70
#	Line 92 | Line 76 | class_free(struct ClassItem *class)
76		void
77		class_init(void)
78		{
79	<	class_default = class_make();
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	<	class_default->name      = xstrdup("default");
95	<	class_default->active    = 1;
96	<	class_default->con_freq  = DEFAULT_CONNECTFREQUENCY;
97	<	class_default->ping_freq = DEFAULT_PINGFREQUENCY;
101	<	class_default->max_total = MAXIMUM_LINKS_DEFAULT;
102	<	class_default->max_sendq = DEFAULT_SENDQ;
103	<	class_default->max_recvq = DEFAULT_RECVQ;
94	>	return conf->class;
95	>	}
96	>
97	>	return class_default;
98		}
99
100		const char *
#	Line 108 | Line 102 | get_client_class(const dlink_list *const
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);
110	<	assert(conf->type & (CONF_OPERATOR | CONF_CLIENT | CONF_SERVER));
110	>	assert(conf->type & (CONF_OPER | CONF_CLIENT | CONF_SERVER));
111
112		return conf->class->name;
113		}
#	Line 125 | 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(aconf->class);
128	<	assert(aconf->type & (CONF_OPERATOR | CONF_CLIENT | CONF_SERVER));
127	>	assert(conf->class);
128	>	assert(conf->type & (CONF_OPER | CONF_CLIENT | CONF_SERVER));
129
130		return conf->class->ping_freq;
131		}
#	Line 142 | 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);
146	<	assert(conf->type & (CONF_OPERATOR | CONF_CLIENT | CONF_SERVER));
146	>	assert(conf->type & (CONF_OPER | CONF_CLIENT | CONF_SERVER));
147
148		return conf->class->max_sendq;
149		}
#	Line 159 | 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);
164	<	assert(conf->type & (CONF_OPERATOR | CONF_CLIENT | CONF_SERVER));
164	>	assert(conf->type & (CONF_OPER | CONF_CLIENT | CONF_SERVER));
165
166		return conf->class->max_recvq;
167		}
#	Line 181 | 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 200 | Line 199 | class_mark_for_deletion(void)
199		{
200		dlink_node *ptr = NULL;
201
202	<	DLINK_FOREACH(ptr, class_list.head)
203	<	{
205	<	struct ClassItem *class = ptr->data;
206	<
207	<	if (class != class_default)
208	<	class->active = 0;
209	<	}
202	>	DLINK_FOREACH_PREV(ptr, class_list.tail->prev)
203	>	((struct ClassItem *)ptr->data)->active = 0;
204		}
205
206		void
#	Line 214 | 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 236 | Line 231 | class_delete_marked(void)
231		* side effects -
232		*/
233		int
234	<	cidr_limit_reached(int over_rule,
240	<	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 253 | 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);
265		dlinkAdd(cidr, &cidr->node, &class->list_ipv4);
266		}
270	–	#ifdef IPV6
267		else if (class->cidr_bitlen_ipv6 > 0)
268		{
269		DLINK_FOREACH(ptr, class->list_ipv6.head)
270		{
271		cidr = ptr->data;
272	+
273		if (match_ipv6(ip, &cidr->mask, class->cidr_bitlen_ipv6))
274		{
275		if (!over_rule && (cidr->number_on_this_cidr >= class->number_per_cidr))
276		return -1;
277	+
278		cidr->number_on_this_cidr++;
279		return 0;
280		}
281		}
282	<	cidr = MyMalloc(sizeof(struct CidrItem));
282	>
283	>	cidr = MyCalloc(sizeof(struct CidrItem));
284		cidr->number_on_this_cidr = 1;
285		cidr->mask = *ip;
286		mask_addr(&cidr->mask, class->cidr_bitlen_ipv6);
287		dlinkAdd(cidr, &cidr->node, &class->list_ipv6);
288		}
289	<	#endif
289	>
290		return 0;
291		}
292
#	Line 317 | Line 316 | remove_from_cidr_check(struct irc_ssaddr
316		DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv4.head)
317		{
318		cidr = ptr->data;
319	+
320		if (match_ipv4(ip, &cidr->mask, aclass->cidr_bitlen_ipv4))
321		{
322	<	cidr->number_on_this_cidr--;
323	<	if (cidr->number_on_this_cidr == 0)
324	<	{
325	<	dlinkDelete(ptr, &aclass->list_ipv4);
326	<	MyFree(cidr);
327	<	return;
328	<	}
322	>	cidr->number_on_this_cidr--;
323	>
324	>	if (cidr->number_on_this_cidr == 0)
325	>	{
326	>	dlinkDelete(ptr, &aclass->list_ipv4);
327	>	MyFree(cidr);
328	>	return;
329	>	}
330		}
331		}
332		}
332	–	#ifdef IPV6
333		else if (aclass->cidr_bitlen_ipv6 > 0)
334		{
335		DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv6.head)
336		{
337		cidr = ptr->data;
338	+
339		if (match_ipv6(ip, &cidr->mask, aclass->cidr_bitlen_ipv6))
340		{
341	<	cidr->number_on_this_cidr--;
342	<	if (cidr->number_on_this_cidr == 0)
343	<	{
344	<	dlinkDelete(ptr, &aclass->list_ipv6);
345	<	MyFree(cidr);
346	<	return;
347	<	}
341	>	cidr->number_on_this_cidr--;
342	>
343	>	if (cidr->number_on_this_cidr == 0)
344	>	{
345	>	dlinkDelete(ptr, &aclass->list_ipv6);
346	>	MyFree(cidr);
347	>	return;
348	>	}
349		}
350		}
351		}
350	–	#endif
352		}
353
354	<	static void
355	<	rebuild_cidr_list(int aftype, struct ClassItem *oldcl, struct ClassItem *newcl,
355	<	dlink_list *old_list, dlink_list *new_list, int changed)
354	>	void
355	>	rebuild_cidr_list(struct ClassItem *class)
356		{
357	<	dlink_node *ptr;
358	<	struct Client *client_p;
359	<	struct MaskItem *conf;
360	<
361	<	if (!changed)
362	<	{
363	<	*new_list = *old_list;
364	<	old_list->head = old_list->tail = NULL;
365	<	old_list->length = 0;
366	<	return;
367	<	}
357	>	dlink_node *ptr = NULL;
358
359	<	DLINK_FOREACH(ptr, local_client_list.head)
370	<	{
371	<	client_p = ptr->data;
372	<	if (client_p->localClient->aftype != aftype)
373	<	continue;
374	<	if (dlink_list_length(&client_p->localClient->confs) == 0)
375	<	continue;
376	<
377	<	conf = client_p->localClient->confs.tail->data;
378	<	if (conf->type == CONF_CLIENT)
379	<	if (conf->class == oldcl)
380	<	cidr_limit_reached(1, &client_p->localClient->ip, newcl);
381	<	}
382	<	}
359	>	destroy_cidr_class(class);
360
361	<	/*
385	<	* rebuild_cidr_class
386	<	*
387	<	* inputs       - pointer to old conf
388	<	*              - pointer to new_class
389	<	* output       - none
390	<	* side effects - rebuilds the class link list of cidr blocks
391	<	*/
392	<	void
393	<	rebuild_cidr_class(struct ClassItem *old_class, struct ClassItem *new_class)
394	<	{
395	<	if (old_class->number_per_cidr > 0 && new_class->number_per_cidr > 0)
361	>	DLINK_FOREACH(ptr, local_client_list.head)
362		{
363	<	if (old_class->cidr_bitlen_ipv4 > 0 && new_class->cidr_bitlen_ipv4 > 0)
364	<	rebuild_cidr_list(AF_INET, old_class, new_class,
399	<	&old_class->list_ipv4, &new_class->list_ipv4,
400	<	old_class->cidr_bitlen_ipv4 != new_class->cidr_bitlen_ipv4);
363	>	struct Client *client_p = ptr->data;
364	>	struct MaskItem *conf = client_p->localClient->confs.tail->data;
365
366	<	#ifdef IPV6
367	<	if (old_class->cidr_bitlen_ipv6 > 0 && new_class->cidr_bitlen_ipv6 > 0)
368	<	rebuild_cidr_list(AF_INET6, old_class, new_class,
405	<	&old_class->list_ipv6, &new_class->list_ipv6,
406	<	old_class->cidr_bitlen_ipv6 != new_class->cidr_bitlen_ipv6);
407	<	#endif
366	>	if (conf && (conf->type == CONF_CLIENT))
367	>	if (conf->class == class)
368	>	cidr_limit_reached(1, &client_p->localClient->ip, class);
369		}
409	–
410	–	destroy_cidr_class(old_class);
370		}
371
372		/*
#	Line 420 | Line 379 | rebuild_cidr_class(struct ClassItem *old
379		static void
380		destroy_cidr_list(dlink_list *list)
381		{
382	<	dlink_node *ptr = NULL, *next_ptr = NULL;
382	>	dlink_node *ptr = NULL, *ptr_next = NULL;
383
384	<	DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
384	>	DLINK_FOREACH_SAFE(ptr, ptr_next, list->head)
385		{
386		dlinkDelete(ptr, list);
387		MyFree(ptr->data);

Comparing ircd-hybrid/trunk/src/conf_class.c (property svn:eol-style):
Revision 1646 by michael, Wed Nov 7 21:02:43 2012 UTC vs.
Revision 4565 by michael, Sun Aug 24 10:27:40 2014 UTC

#	Line 0 | Line 1
1	+	native

Comparing ircd-hybrid/trunk/src/conf_class.c (property svn:executable):
Revision 1646 by michael, Wed Nov 7 21:02:43 2012 UTC vs.
Revision 4565 by michael, Sun Aug 24 10:27:40 2014 UTC

#	Line 1 | Line 0
1	–	*

Comparing ircd-hybrid/trunk/src/conf_class.c (property svn:keywords):
Revision 1646 by michael, Wed Nov 7 21:02:43 2012 UTC vs.
Revision 4565 by michael, Sun Aug 24 10:27:40 2014 UTC

#	Line 1 | Line 1
1	<	Id
1	>	Id Revision

Diff Legend

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