ViewVC Help

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

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

Comparing ircd-hybrid/trunk/src/conf.c (file contents):
Revision 4343 by michael, Sat Aug 2 16:58:33 2014 UTC vs.
Revision 8314 by michael, Wed Feb 28 17:47:23 2018 UTC

#	Line 1 | Line 1
1		/*
2		*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (c) 1997-2014 ircd-hybrid development team
4	>	*  Copyright (c) 1997-2018 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
#	Line 28 | Line 28
28		#include "list.h"
29		#include "ircd_defs.h"
30		#include "conf.h"
31	+	#include "conf_cluster.h"
32	+	#include "conf_gecos.h"
33	+	#include "conf_pseudo.h"
34	+	#include "conf_resv.h"
35	+	#include "conf_service.h"
36	+	#include "conf_shared.h"
37		#include "server.h"
32	–	#include "resv.h"
38		#include "channel.h"
39		#include "client.h"
40		#include "event.h"
#	Line 54 | Line 59
59		#include "conf_class.h"
60		#include "motd.h"
61		#include "ipcache.h"
62	+	#include "isupport.h"
63	+	#include "whowas.h"
64
65
66	+	struct config_channel_entry ConfigChannel;
67	+	struct config_serverhide_entry ConfigServerHide;
68	+	struct config_general_entry ConfigGeneral;
69	+	struct config_log_entry ConfigLog = { .use_logging = 1 };
70	+	struct config_serverinfo_entry ConfigServerInfo;
71	+	struct config_admin_entry ConfigAdminInfo;
72	+	struct conf_parser_context conf_parser_ctx;
73	+
74		/* general conf items link list root, other than k lines etc. */
75	<	dlink_list service_items = { NULL, NULL, 0 };
76	<	dlink_list server_items  = { NULL, NULL, 0 };
62	<	dlink_list cluster_items = { NULL, NULL, 0 };
63	<	dlink_list oconf_items   = { NULL, NULL, 0 };
64	<	dlink_list uconf_items   = { NULL, NULL, 0 };
65	<	dlink_list xconf_items   = { NULL, NULL, 0 };
66	<	dlink_list nresv_items   = { NULL, NULL, 0 };
67	<	dlink_list cresv_items   = { NULL, NULL, 0 };
75	>	dlink_list connect_items;
76	>	dlink_list operator_items;
77
78		extern unsigned int lineno;
79		extern char linebuf[];
80		extern char conffilebuf[IRCD_BUFSIZE];
81		extern int yyparse(); /* defined in y.tab.c */
82
74	–	/* internally defined functions */
75	–	static void read_conf(FILE *);
76	–	static void clear_out_old_conf(void);
77	–	static void expire_tklines(dlink_list *);
78	–	static int verify_access(struct Client *);
79	–	static int attach_iline(struct Client *, struct MaskItem *);
80	–	static dlink_list *map_to_list(enum maskitem_type);
81	–	static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
82	–
83
84		/* conf_dns_callback()
85		*
#	Line 92 | Line 92 | static int find_user_host(struct Client
92		* if successful save hp in the conf item it was called with
93		*/
94		static void
95	<	conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name)
95	>	conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name, size_t namelength)
96		{
97	<	struct MaskItem *conf = vptr;
97	>	struct MaskItem *const conf = vptr;
98
99		conf->dns_pending = 0;
100
#	Line 113 | Line 113 | conf_dns_callback(void *vptr, const stru
113		static void
114		conf_dns_lookup(struct MaskItem *conf)
115		{
116	<	if (!conf->dns_pending)
116	>	if (conf->dns_pending)
117	>	return;
118	>
119	>	conf->dns_pending = 1;
120	>
121	>	if (conf->aftype == AF_INET)
122	>	gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
123	>	else
124	>	gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
125	>	}
126	>
127	>	/* map_to_list()
128	>	*
129	>	* inputs       - ConfType conf
130	>	* output       - pointer to dlink_list to use
131	>	* side effects - none
132	>	*/
133	>	static dlink_list *
134	>	map_to_list(enum maskitem_type type)
135	>	{
136	>	switch (type)
137		{
138	<	conf->dns_pending = 1;
139	<	gethost_byname(conf_dns_callback, conf, conf->host);
138	>	case CONF_OPER:
139	>	return &operator_items;
140	>	break;
141	>	case CONF_SERVER:
142	>	return &connect_items;
143	>	break;
144	>	default:
145	>	return NULL;
146		}
147		}
148
149		struct MaskItem *
150		conf_make(enum maskitem_type type)
151		{
152	<	struct MaskItem *conf = MyCalloc(sizeof(*conf));
152	>	struct MaskItem *const conf = xcalloc(sizeof(*conf));
153		dlink_list *list = NULL;
154
155		conf->type   = type;
#	Line 138 | Line 164 | conf_make(enum maskitem_type type)
164		void
165		conf_free(struct MaskItem *conf)
166		{
167	<	dlink_node *ptr = NULL, *ptr_next = NULL;
167	>	dlink_node *node = NULL, *node_next = NULL;
168		dlink_list *list = NULL;
169
170	<	if (conf->node.next)
171	<	if ((list = map_to_list(conf->type)))
146	<	dlinkDelete(&conf->node, list);
170	>	if ((list = map_to_list(conf->type)))
171	>	dlinkFindDelete(list, conf);
172
173	<	MyFree(conf->name);
173	>	xfree(conf->name);
174
175		if (conf->dns_pending)
176		delete_resolver_queries(conf);
#	Line 156 | Line 181 | conf_free(struct MaskItem *conf)
181
182		conf->class = NULL;
183
184	<	MyFree(conf->passwd);
185	<	MyFree(conf->spasswd);
186	<	MyFree(conf->reason);
187	<	MyFree(conf->certfp);
188	<	MyFree(conf->user);
189	<	MyFree(conf->host);
190	<	#ifdef HAVE_LIBCRYPTO
191	<	MyFree(conf->cipher_list);
184	>	xfree(conf->passwd);
185	>	xfree(conf->spasswd);
186	>	xfree(conf->reason);
187	>	xfree(conf->certfp);
188	>	xfree(conf->whois);
189	>	xfree(conf->user);
190	>	xfree(conf->host);
191	>	xfree(conf->cipher_list);
192
193	<	if (conf->rsa_public_key)
169	<	RSA_free(conf->rsa_public_key);
170	<	#endif
171	<	DLINK_FOREACH_SAFE(ptr, ptr_next, conf->hub_list.head)
193	>	DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
194		{
195	<	MyFree(ptr->data);
196	<	dlinkDelete(ptr, &conf->hub_list);
197	<	free_dlink_node(ptr);
195	>	xfree(node->data);
196	>	dlinkDelete(node, &conf->hub_list);
197	>	free_dlink_node(node);
198		}
199
200	<	DLINK_FOREACH_SAFE(ptr, ptr_next, conf->leaf_list.head)
200	>	DLINK_FOREACH_SAFE(node, node_next, conf->leaf_list.head)
201		{
202	<	MyFree(ptr->data);
203	<	dlinkDelete(ptr, &conf->leaf_list);
204	<	free_dlink_node(ptr);
202	>	xfree(node->data);
203	>	dlinkDelete(node, &conf->leaf_list);
204	>	free_dlink_node(node);
205		}
206
207	<	DLINK_FOREACH_SAFE(ptr, ptr_next, conf->exempt_list.head)
207	>	xfree(conf);
208	>	}
209	>
210	>	/* attach_iline()
211	>	*
212	>	* inputs       - client pointer
213	>	*              - conf pointer
214	>	* output       -
215	>	* side effects - do actual attach
216	>	*/
217	>	static int
218	>	attach_iline(struct Client *client_p, struct MaskItem *conf)
219	>	{
220	>	const struct ClassItem *const class = conf->class;
221	>	struct ip_entry *ip_found;
222	>	int a_limit_reached = 0;
223	>	unsigned int local = 0, global = 0;
224	>
225	>	ip_found = ipcache_find_or_add_address(&client_p->connection->ip);
226	>	ip_found->count++;
227	>	AddFlag(client_p, FLAGS_IPHASH);
228	>
229	>	userhost_count(client_p->sockhost, &global, &local);
230	>
231	>	/* XXX blah. go down checking the various silly limits
232	>	* setting a_limit_reached if any limit is reached.
233	>	* - Dianora
234	>	*/
235	>	if (class->max_total && class->ref_count >= class->max_total)
236	>	a_limit_reached = 1;
237	>	else if (class->max_perip && ip_found->count > class->max_perip)
238	>	a_limit_reached = 1;
239	>	else if (class->max_local && local >= class->max_local) /* XXX: redundant */
240	>	a_limit_reached = 1;
241	>	else if (class->max_global && global >= class->max_global)
242	>	a_limit_reached = 1;
243	>
244	>	if (a_limit_reached)
245		{
246	<	struct exempt *exptr = ptr->data;
246	>	if (!IsConfExemptLimits(conf))
247	>	return TOO_MANY;   /* Already at maximum allowed */
248	>
249	>	sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
250	>	"but you have exceed_limit = yes;");
251	>	}
252	>
253	>	return attach_conf(client_p, conf);
254	>	}
255	>
256	>	/* verify_access()
257	>	*
258	>	* inputs       - pointer to client to verify
259	>	* output       - 0 if success -'ve if not
260	>	* side effect  - find the first (best) I line to attach.
261	>	*/
262	>	static int
263	>	verify_access(struct Client *client_p)
264	>	{
265	>	struct MaskItem *conf = NULL;
266	>
267	>	if (HasFlag(client_p, FLAGS_GOTID))
268	>	{
269	>	conf = find_address_conf(client_p->host, client_p->username,
270	>	&client_p->connection->ip,
271	>	client_p->connection->aftype,
272	>	client_p->connection->password);
273	>	}
274	>	else
275	>	{
276	>	char non_ident[USERLEN + 1] = "~";
277	>
278	>	strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
279	>	conf = find_address_conf(client_p->host, non_ident,
280	>	&client_p->connection->ip,
281	>	client_p->connection->aftype,
282	>	client_p->connection->password);
283	>	}
284	>
285	>	if (!conf)
286	>	return NOT_AUTHORIZED;
287	>
288	>	assert(IsConfClient(conf) || IsConfKill(conf));
289	>
290	>	if (IsConfClient(conf))
291	>	{
292	>	if (IsConfRedir(conf))
293	>	{
294	>	sendto_one_numeric(client_p, &me, RPL_REDIR,
295	>	conf->name ? conf->name : "",
296	>	conf->port);
297	>	return NOT_AUTHORIZED;
298	>	}
299	>
300	>	if (IsConfDoSpoofIp(conf))
301	>	{
302	>	if (IsConfSpoofNotice(conf))
303	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s",
304	>	client_p->name, client_p->host, conf->name);
305	>
306	>	strlcpy(client_p->host, conf->name, sizeof(client_p->host));
307	>	}
308
309	<	dlinkDelete(ptr, &conf->exempt_list);
190	<	MyFree(exptr->name);
191	<	MyFree(exptr->user);
192	<	MyFree(exptr->host);
193	<	MyFree(exptr);
309	>	return attach_iline(client_p, conf);
310		}
311
312	<	MyFree(conf);
312	>	sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
313	>	return BANNED_CLIENT;
314		}
315
316		/* check_client()
#	Line 223 | Line 340 | check_client(struct Client *source_p)
340		case TOO_MANY:
341		sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
342		"Too many on IP for %s (%s).",
343	<	get_client_name(source_p, SHOW_IP),
343	>	client_get_name(source_p, SHOW_IP),
344		source_p->sockhost);
345		ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
346	<	get_client_name(source_p, SHOW_IP));
346	>	client_get_name(source_p, SHOW_IP));
347		++ServerStats.is_ref;
348		exit_client(source_p, "No more connections allowed on that IP");
349		break;
350
351		case I_LINE_FULL:
352		sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
353	<	"auth{} block is full for %s (%s).",
354	<	get_client_name(source_p, SHOW_IP),
353	>	"auth {} block is full for %s (%s).",
354	>	client_get_name(source_p, SHOW_IP),
355		source_p->sockhost);
356		ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
357	<	get_client_name(source_p, SHOW_IP));
357	>	client_get_name(source_p, SHOW_IP));
358		++ServerStats.is_ref;
359		exit_client(source_p, "No more connections allowed in your connection class");
360		break;
361
362		case NOT_AUTHORIZED:
246	–	++ServerStats.is_ref;
363		/* jdc - lists server name & port connections are on */
364		/*       a purely cosmetical change */
365		sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
366	<	"Unauthorized client connection from %s [%s] on [%s/%u].",
367	<	get_client_name(source_p, SHOW_IP),
368	<	source_p->sockhost,
369	<	source_p->localClient->listener->name,
370	<	source_p->localClient->listener->port);
371	<	ilog(LOG_TYPE_IRCD,
372	<	"Unauthorized client connection from %s on [%s/%u].",
373	<	get_client_name(source_p, SHOW_IP),
258	<	source_p->localClient->listener->name,
259	<	source_p->localClient->listener->port);
366	>	"Unauthorized client connection from %s on [%s/%u].",
367	>	client_get_name(source_p, SHOW_IP),
368	>	source_p->connection->listener->name,
369	>	source_p->connection->listener->port);
370	>	ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s on [%s/%u].",
371	>	client_get_name(source_p, SHOW_IP),
372	>	source_p->connection->listener->name,
373	>	source_p->connection->listener->port);
374
375	+	++ServerStats.is_ref;
376		exit_client(source_p, "You are not authorized to use this server");
377		break;
378
379	<	case BANNED_CLIENT:
380	<	exit_client(source_p, "Banned");
381	<	++ServerStats.is_ref;
382	<	break;
268	<
269	<	case 0:
270	<	default:
271	<	break;
272	<	}
273	<
274	<	return (i < 0 ? 0 : 1);
275	<	}
276	<
277	<	/* verify_access()
278	<	*
279	<	* inputs       - pointer to client to verify
280	<	* output       - 0 if success -'ve if not
281	<	* side effect  - find the first (best) I line to attach.
282	<	*/
283	<	static int
284	<	verify_access(struct Client *client_p)
285	<	{
286	<	struct MaskItem *conf = NULL;
287	<	char non_ident[USERLEN + 1] = "~";
288	<
289	<	if (IsGotId(client_p))
290	<	{
291	<	conf = find_address_conf(client_p->host, client_p->username,
292	<	&client_p->localClient->ip,
293	<	client_p->localClient->aftype,
294	<	client_p->localClient->passwd);
295	<	}
296	<	else
297	<	{
298	<	strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
299	<	conf = find_address_conf(client_p->host,non_ident,
300	<	&client_p->localClient->ip,
301	<	client_p->localClient->aftype,
302	<	client_p->localClient->passwd);
303	<	}
304	<
305	<	if (conf)
306	<	{
307	<	if (IsConfClient(conf))
308	<	{
309	<	if (IsConfRedir(conf))
310	<	{
311	<	sendto_one_numeric(client_p, &me, RPL_REDIR,
312	<	conf->name ? conf->name : "",
313	<	conf->port);
314	<	return NOT_AUTHORIZED;
315	<	}
316	<
317	<	if (IsConfDoIdentd(conf))
318	<	SetNeedId(client_p);
319	<
320	<	/* Thanks for spoof idea amm */
321	<	if (IsConfDoSpoofIp(conf))
322	<	{
323	<	if (!ConfigGeneral.hide_spoof_ips && IsConfSpoofNotice(conf))
324	<	sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
325	<	"%s spoofing: %s as %s",
326	<	client_p->name, client_p->host, conf->name);
327	<	strlcpy(client_p->host, conf->name, sizeof(client_p->host));
328	<	AddFlag(client_p, FLAGS_IP_SPOOFING | FLAGS_AUTH_SPOOF);
329	<	}
379	>	case BANNED_CLIENT:
380	>	++ServerStats.is_ref;
381	>	exit_client(source_p, "Banned");
382	>	break;
383
384	<	return attach_iline(client_p, conf);
385	<	}
386	<	else if (IsConfKill(conf) || (ConfigGeneral.glines && IsConfGline(conf)))
334	<	{
335	<	if (IsConfGline(conf))
336	<	sendto_one_notice(client_p, &me, ":*** G-lined");
337	<	sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
338	<	return BANNED_CLIENT;
339	<	}
384	>	case 0:
385	>	default:
386	>	break;
387		}
388
389	<	return NOT_AUTHORIZED;
343	<	}
344	<
345	<	/* attach_iline()
346	<	*
347	<	* inputs       - client pointer
348	<	*              - conf pointer
349	<	* output       -
350	<	* side effects - do actual attach
351	<	*/
352	<	static int
353	<	attach_iline(struct Client *client_p, struct MaskItem *conf)
354	<	{
355	<	const struct ClassItem *class = conf->class;
356	<	struct ip_entry *ip_found;
357	<	int a_limit_reached = 0;
358	<	unsigned int local = 0, global = 0, ident = 0;
359	<
360	<	ip_found = ipcache_find_or_add_address(&client_p->localClient->ip);
361	<	ip_found->count++;
362	<	SetIpHash(client_p);
363	<
364	<	count_user_host(client_p->username, client_p->host,
365	<	&global, &local, &ident);
366	<
367	<	/* XXX blah. go down checking the various silly limits
368	<	* setting a_limit_reached if any limit is reached.
369	<	* - Dianora
370	<	*/
371	<	if (class->max_total && class->ref_count >= class->max_total)
372	<	a_limit_reached = 1;
373	<	else if (class->max_perip && ip_found->count > class->max_perip)
374	<	a_limit_reached = 1;
375	<	else if (class->max_local && local >= class->max_local)
376	<	a_limit_reached = 1;
377	<	else if (class->max_global && global >= class->max_global)
378	<	a_limit_reached = 1;
379	<	else if (class->max_ident && ident >= class->max_ident &&
380	<	client_p->username[0] != '~')
381	<	a_limit_reached = 1;
382	<
383	<	if (a_limit_reached)
384	<	{
385	<	if (!IsConfExemptLimits(conf))
386	<	return TOO_MANY;   /* Already at maximum allowed */
387	<
388	<	sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
389	<	"but you have exceed_limit = yes;");
390	<	}
391	<
392	<	return attach_conf(client_p, conf);
389	>	return !(i < 0);
390		}
391
392		/* detach_conf()
#	Line 403 | Line 400 | attach_iline(struct Client *client_p, st
400		void
401		detach_conf(struct Client *client_p, enum maskitem_type type)
402		{
403	<	dlink_node *ptr = NULL, *ptr_next = NULL;
403	>	dlink_node *node = NULL, *node_next = NULL;
404
405	<	DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->localClient->confs.head)
405	>	DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
406		{
407	<	struct MaskItem *conf = ptr->data;
407	>	struct MaskItem *conf = node->data;
408
409		assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
410		assert(conf->ref_count > 0);
#	Line 416 | Line 413 | detach_conf(struct Client *client_p, enu
413		if (!(conf->type & type))
414		continue;
415
416	<	dlinkDelete(ptr, &client_p->localClient->confs);
417	<	free_dlink_node(ptr);
416	>	dlinkDelete(node, &client_p->connection->confs);
417	>	free_dlink_node(node);
418
419		if (conf->type == CONF_CLIENT)
420	<	remove_from_cidr_check(&client_p->localClient->ip, conf->class);
420	>	remove_from_cidr_check(&client_p->connection->ip, conf->class);
421
422		if (--conf->class->ref_count == 0 && conf->class->active == 0)
423		{
#	Line 446 | Line 443 | detach_conf(struct Client *client_p, enu
443		int
444		attach_conf(struct Client *client_p, struct MaskItem *conf)
445		{
446	<	if (dlinkFind(&client_p->localClient->confs, conf))
446	>	if (dlinkFind(&client_p->connection->confs, conf))
447		return 1;
448
449		if (conf->type == CONF_CLIENT)
450		if (cidr_limit_reached(IsConfExemptLimits(conf),
451	<	&client_p->localClient->ip, conf->class))
451	>	&client_p->connection->ip, conf->class))
452		return TOO_MANY;    /* Already at maximum allowed */
453
454		conf->class->ref_count++;
455		conf->ref_count++;
456
457	<	dlinkAdd(conf, make_dlink_node(), &client_p->localClient->confs);
457	>	dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs);
458
459		return 0;
460		}
#	Line 474 | Line 471 | int
471		attach_connect_block(struct Client *client_p, const char *name,
472		const char *host)
473		{
474	<	dlink_node *ptr;
478	<	struct MaskItem *conf = NULL;
474	>	dlink_node *node = NULL;
475
476	<	assert(client_p != NULL);
481	<	assert(host != NULL);
476	>	assert(host);
477
478	<	if (client_p == NULL || host == NULL)
484	<	return 0;
485	<
486	<	DLINK_FOREACH(ptr, server_items.head)
478	>	DLINK_FOREACH(node, connect_items.head)
479		{
480	<	conf = ptr->data;
480	>	struct MaskItem *conf = node->data;
481
482	<	if (match(conf->name, name) || match(conf->host, host))
482	>	if (irccmp(conf->name, name) ||
483	>	irccmp(conf->host, host))
484		continue;
485
486		attach_conf(client_p, conf);
487	<	return -1;
487	>	return 1;
488		}
489
490		return 0;
#	Line 509 | Line 502 | attach_connect_block(struct Client *clie
502		struct MaskItem *
503		find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
504		{
505	<	dlink_node *ptr;
513	<	struct MaskItem* conf;
505	>	dlink_node *node = NULL;
506
507	<	DLINK_FOREACH(ptr, list->head)
507	>	DLINK_FOREACH(node, list->head)
508		{
509	<	conf = ptr->data;
509	>	struct MaskItem *conf = node->data;
510
511		if (conf->type == type)
512		{
513	<	if (conf->name && (!irccmp(conf->name, name) ||
514	<	!match(conf->name, name)))
523	<	return conf;
513	>	if (conf->name && !irccmp(conf->name, name))
514	>	return conf;
515		}
516		}
517
518		return NULL;
519		}
520
530	–	/* map_to_list()
531	–	*
532	–	* inputs       - ConfType conf
533	–	* output       - pointer to dlink_list to use
534	–	* side effects - none
535	–	*/
536	–	static dlink_list *
537	–	map_to_list(enum maskitem_type type)
538	–	{
539	–	switch(type)
540	–	{
541	–	case CONF_XLINE:
542	–	return(&xconf_items);
543	–	break;
544	–	case CONF_ULINE:
545	–	return(&uconf_items);
546	–	break;
547	–	case CONF_NRESV:
548	–	return(&nresv_items);
549	–	break;
550	–	case CONF_CRESV:
551	–	return(&cresv_items);
552	–	case CONF_OPER:
553	–	return(&oconf_items);
554	–	break;
555	–	case CONF_SERVER:
556	–	return(&server_items);
557	–	break;
558	–	case CONF_SERVICE:
559	–	return(&service_items);
560	–	break;
561	–	case CONF_CLUSTER:
562	–	return(&cluster_items);
563	–	break;
564	–	default:
565	–	return NULL;
566	–	}
567	–	}
568	–
521		/* find_matching_name_conf()
522		*
523		* inputs       - type of link list to look in
#	Line 577 | Line 529 | map_to_list(enum maskitem_type type)
529		* side effects - looks for a match on name field
530		*/
531		struct MaskItem *
532	<	find_matching_name_conf(enum maskitem_type type, const char *name, const char *user,
581	<	const char *host, unsigned int flags)
532	>	connect_find(const char *name, const char *host, int (*compare)(const char *, const char *))
533		{
534	<	dlink_node *ptr=NULL;
584	<	struct MaskItem *conf=NULL;
585	<	dlink_list *list_p = map_to_list(type);
534	>	dlink_node *node = NULL;
535
536	<	switch (type)
536	>	DLINK_FOREACH(node, connect_items.head)
537		{
538	<	case CONF_SERVICE:
590	<	DLINK_FOREACH(ptr, list_p->head)
591	<	{
592	<	conf = ptr->data;
538	>	struct MaskItem *conf = node->data;
539
540	<	if (EmptyString(conf->name))
541	<	continue;
542	<	if ((name != NULL) && !irccmp(name, conf->name))
543	<	return conf;
598	<	}
599	<	break;
600	<
601	<	case CONF_XLINE:
602	<	case CONF_ULINE:
603	<	case CONF_NRESV:
604	<	case CONF_CRESV:
605	<	DLINK_FOREACH(ptr, list_p->head)
606	<	{
607	<	conf = ptr->data;
608	<
609	<	if (EmptyString(conf->name))
610	<	continue;
611	<	if ((name != NULL) && !match(conf->name, name))
612	<	{
613	<	if ((user == NULL && (host == NULL)))
614	<	return conf;
615	<	if ((conf->flags & flags) != flags)
616	<	continue;
617	<	if (EmptyString(conf->user) || EmptyString(conf->host))
618	<	return conf;
619	<	if (!match(conf->user, user) && !match(conf->host, host))
620	<	return conf;
621	<	}
622	<	}
623	<	break;
624	<
625	<	case CONF_SERVER:
626	<	DLINK_FOREACH(ptr, list_p->head)
627	<	{
628	<	conf = ptr->data;
629	<
630	<	if ((name != NULL) && !match(name, conf->name))
631	<	return conf;
632	<	else if ((host != NULL) && !match(host, conf->host))
633	<	return conf;
634	<	}
635	<	break;
636	<
637	<	default:
638	<	break;
540	>	if (name && !compare(name, conf->name))
541	>	return conf;
542	>	if (host && !compare(host, conf->host))
543	>	return conf;
544		}
545	+
546		return NULL;
547		}
548
#	Line 650 | Line 556 | find_matching_name_conf(enum maskitem_ty
556		* side effects - looks for an exact match on name field
557		*/
558		struct MaskItem *
559	<	find_exact_name_conf(enum maskitem_type type, const struct Client *who, const char *name,
654	<	const char *user, const char *host)
559	>	operator_find(const struct Client *who, const char *name)
560		{
561	<	dlink_node *ptr = NULL;
657	<	struct MaskItem *conf;
658	<	dlink_list *list_p = map_to_list(type);
561	>	dlink_node *node = NULL;
562
563	<	switch(type)
563	>	DLINK_FOREACH(node, operator_items.head)
564		{
565	<	case CONF_XLINE:
663	<	case CONF_ULINE:
664	<	case CONF_NRESV:
665	<	case CONF_CRESV:
565	>	struct MaskItem *conf = node->data;
566
567	<	DLINK_FOREACH(ptr, list_p->head)
567	>	if (!irccmp(conf->name, name))
568		{
569	<	conf = ptr->data;
570	<
671	<	if (EmptyString(conf->name))
672	<	continue;
673	<
674	<	if (irccmp(conf->name, name) == 0)
675	<	{
676	<	if ((user == NULL && (host == NULL)))
677	<	return conf;
678	<	if (EmptyString(conf->user) || EmptyString(conf->host))
679	<	return conf;
680	<	if (!match(conf->user, user) && !match(conf->host, host))
681	<	return conf;
682	<	}
683	<	}
684	<	break;
685	<
686	<	case CONF_OPER:
687	<	DLINK_FOREACH(ptr, list_p->head)
688	<	{
689	<	conf = ptr->data;
690	<
691	<	if (EmptyString(conf->name))
692	<	continue;
569	>	if (!who)
570	>	return conf;
571
572	<	if (!irccmp(conf->name, name))
572	>	if (!match(conf->user, who->username))
573		{
574	<	if (!who)
697	<	return conf;
698	<	if (EmptyString(conf->user) || EmptyString(conf->host))
699	<	return NULL;
700	<	if (!match(conf->user, who->username))
574	>	switch (conf->htype)
575		{
576	<	switch (conf->htype)
577	<	{
578	<	case HM_HOST:
579	<	if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
576	>	case HM_HOST:
577	>	if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
578	>	if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
579	>	return conf;
580	>	break;
581	>	case HM_IPV4:
582	>	if (who->connection->aftype == AF_INET)
583	>	if (match_ipv4(&who->connection->ip, &conf->addr, conf->bits))
584	>	if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
585	>	return conf;
586	>	break;
587	>	case HM_IPV6:
588	>	if (who->connection->aftype == AF_INET6)
589	>	if (match_ipv6(&who->connection->ip, &conf->addr, conf->bits))
590		if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
591		return conf;
592	<	break;
593	<	case HM_IPV4:
594	<	if (who->localClient->aftype == AF_INET)
711	<	if (match_ipv4(&who->localClient->ip, &conf->addr, conf->bits))
712	<	if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
713	<	return conf;
714	<	break;
715	<	#ifdef IPV6
716	<	case HM_IPV6:
717	<	if (who->localClient->aftype == AF_INET6)
718	<	if (match_ipv6(&who->localClient->ip, &conf->addr, conf->bits))
719	<	if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
720	<	return conf;
721	<	break;
722	<	#endif
723	<	default:
724	<	assert(0);
725	<	}
592	>	break;
593	>	default:
594	>	assert(0);
595		}
596		}
597		}
729	–
730	–	break;
731	–
732	–	case CONF_SERVER:
733	–	DLINK_FOREACH(ptr, list_p->head)
734	–	{
735	–	conf = ptr->data;
736	–
737	–	if (EmptyString(conf->name))
738	–	continue;
739	–
740	–	if (name == NULL)
741	–	{
742	–	if (EmptyString(conf->host))
743	–	continue;
744	–	if (irccmp(conf->host, host) == 0)
745	–	return conf;
746	–	}
747	–	else if (irccmp(conf->name, name) == 0)
748	–	return conf;
749	–	}
750	–
751	–	break;
752	–
753	–	default:
754	–	break;
598		}
599
600		return NULL;
601		}
602
760	–	/* rehash()
761	–	*
762	–	* Actual REHASH service routine. Called with sig == 0 if it has been called
763	–	* as a result of an operator issuing this command, else assume it has been
764	–	* called as a result of the server receiving a HUP signal.
765	–	*/
766	–	int
767	–	rehash(int sig)
768	–	{
769	–	if (sig)
770	–	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
771	–	"Got signal SIGHUP, reloading configuration file(s)");
772	–
773	–	restart_resolver();
774	–
775	–	/* don't close listeners until we know we can go ahead with the rehash */
776	–
777	–	/* Check to see if we magically got(or lost) IPv6 support */
778	–	check_can_use_v6();
779	–
780	–	read_conf_files(0);
781	–
782	–	if (ConfigServerInfo.description)
783	–	strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
784	–
785	–	load_conf_modules();
786	–	check_conf_klines();
787	–
788	–	return 0;
789	–	}
790	–
603		/* set_default_conf()
604		*
605		* inputs       - NONE
#	Line 805 | Line 617 | set_default_conf(void)
617		*/
618		assert(class_default == class_get_list()->tail->data);
619
808	–	#ifdef HAVE_LIBCRYPTO
809	–	ConfigServerInfo.message_digest_algorithm = EVP_sha256();
810	–	ConfigServerInfo.rsa_private_key = NULL;
811	–	ConfigServerInfo.rsa_private_key_file = NULL;
812	–	#endif
813	–
814	–	/* ConfigServerInfo.name is not rehashable */
815	–	/* ConfigServerInfo.name = ConfigServerInfo.name; */
816	–	ConfigServerInfo.description = NULL;
620		ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
621		ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
622
#	Line 822 | Line 625 | set_default_conf(void)
625		memset(&ConfigServerInfo.ip6, 0, sizeof(ConfigServerInfo.ip6));
626		ConfigServerInfo.specific_ipv6_vhost = 0;
627
628	<	ConfigServerInfo.max_clients = MAXCLIENTS_MAX;
628	>	ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
629		ConfigServerInfo.max_nick_length = 9;
630		ConfigServerInfo.max_topic_length = 80;
631		ConfigServerInfo.hub = 0;
632
830	–	ConfigAdminInfo.name = NULL;
831	–	ConfigAdminInfo.email = NULL;
832	–	ConfigAdminInfo.description = NULL;
833	–
633		log_del_all();
634
635		ConfigLog.use_logging = 1;
#	Line 838 | Line 637 | set_default_conf(void)
637		ConfigChannel.disable_fake_channels = 0;
638		ConfigChannel.invite_client_count = 10;
639		ConfigChannel.invite_client_time = 300;
640	+	ConfigChannel.invite_delay_channel = 5;
641	+	ConfigChannel.invite_expire_time = 1800;
642		ConfigChannel.knock_client_count = 1;
643		ConfigChannel.knock_client_time = 300;
644		ConfigChannel.knock_delay_channel = 60;
645		ConfigChannel.max_channels = 25;
646	<	ConfigChannel.max_bans = 25;
647	<	ConfigChannel.default_split_user_count = 0;
648	<	ConfigChannel.default_split_server_count = 0;
649	<	ConfigChannel.no_join_on_split = 0;
650	<	ConfigChannel.no_create_on_split = 0;
646	>	ConfigChannel.max_invites = 20;
647	>	ConfigChannel.max_bans = 100;
648	>	ConfigChannel.max_bans_large = 500;
649	>	ConfigChannel.default_join_flood_count = 18;
650	>	ConfigChannel.default_join_flood_time = 6;
651
652		ConfigServerHide.flatten_links = 0;
653	<	ConfigServerHide.links_delay = 300;
653	>	ConfigServerHide.flatten_links_delay = 300;
654		ConfigServerHide.hidden = 0;
655		ConfigServerHide.hide_servers = 0;
656		ConfigServerHide.hide_services = 0;
#	Line 859 | Line 660 | set_default_conf(void)
660
661		ConfigGeneral.away_count = 2;
662		ConfigGeneral.away_time = 10;
663	<	ConfigGeneral.service_name = xstrdup(SERVICE_NAME_DEFAULT);
664	<	ConfigGeneral.max_watch = WATCHSIZE_DEFAULT;
663	>	ConfigGeneral.max_watch = 50;
664	>	ConfigGeneral.whowas_history_length = 15000;
665		ConfigGeneral.cycle_on_host_change = 1;
666	<	ConfigGeneral.glines = 0;
667	<	ConfigGeneral.gline_time = 12 * 3600;
668	<	ConfigGeneral.gline_request_time = GLINE_REQUEST_EXPIRE_DEFAULT;
669	<	ConfigGeneral.gline_min_cidr = 16;
869	<	ConfigGeneral.gline_min_cidr6 = 48;
666	>	ConfigGeneral.dline_min_cidr = 16;
667	>	ConfigGeneral.dline_min_cidr6 = 48;
668	>	ConfigGeneral.kline_min_cidr = 16;
669	>	ConfigGeneral.kline_min_cidr6 = 48;
670		ConfigGeneral.invisible_on_connect = 1;
671		ConfigGeneral.tkline_expire_notices = 1;
872	–	ConfigGeneral.hide_spoof_ips = 1;
672		ConfigGeneral.ignore_bogus_ts = 0;
673		ConfigGeneral.disable_auth = 0;
674		ConfigGeneral.kill_chase_time_limit = 90;
675		ConfigGeneral.default_floodcount = 8;
676	+	ConfigGeneral.default_floodtime = 1;
677		ConfigGeneral.failed_oper_notice = 1;
678		ConfigGeneral.dots_in_ident = 0;
679		ConfigGeneral.min_nonwildcard = 4;
680		ConfigGeneral.min_nonwildcard_simple = 3;
681	<	ConfigGeneral.max_accept = 20;
681	>	ConfigGeneral.max_accept = 50;
682		ConfigGeneral.anti_nick_flood = 0;
683		ConfigGeneral.max_nick_time = 20;
684		ConfigGeneral.max_nick_changes = 5;
685		ConfigGeneral.anti_spam_exit_message_time = 0;
686	<	ConfigGeneral.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
687	<	ConfigGeneral.ts_max_delta = TS_MAX_DELTA_DEFAULT;
686	>	ConfigGeneral.ts_warn_delta = 30;
687	>	ConfigGeneral.ts_max_delta = 600;
688		ConfigGeneral.warn_no_connect_block = 1;
689		ConfigGeneral.stats_e_disabled = 0;
890	–	ConfigGeneral.stats_o_oper_only = 0;
891	–	ConfigGeneral.stats_k_oper_only = 1;  /* 1 = masked */
690		ConfigGeneral.stats_i_oper_only = 1;  /* 1 = masked */
691	+	ConfigGeneral.stats_k_oper_only = 1;  /* 1 = masked */
692	+	ConfigGeneral.stats_o_oper_only = 1;
693	+	ConfigGeneral.stats_m_oper_only = 1;
694		ConfigGeneral.stats_P_oper_only = 0;
695		ConfigGeneral.stats_u_oper_only = 0;
696		ConfigGeneral.caller_id_wait = 60;
697	<	ConfigGeneral.opers_bypass_callerid = 0;
697	>	ConfigGeneral.opers_bypass_callerid = 1;
698		ConfigGeneral.pace_wait = 10;
699		ConfigGeneral.pace_wait_simple = 1;
700		ConfigGeneral.short_motd = 0;
701		ConfigGeneral.ping_cookie = 0;
702		ConfigGeneral.no_oper_flood = 0;
902	–	ConfigGeneral.true_no_oper_flood = 0;
903	–	ConfigGeneral.oper_pass_resv = 1;
703		ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT;
704	<	ConfigGeneral.oper_only_umodes = UMODE_DEBUG;
704	>	ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT |
705	>	UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE |
706	>	UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
707		ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
708		ConfigGeneral.throttle_count = 1;
709		ConfigGeneral.throttle_time = 1;
#	Line 911 | Line 712 | set_default_conf(void)
712		static void
713		validate_conf(void)
714		{
715	<	if (ConfigGeneral.ts_warn_delta < TS_WARN_DELTA_MIN)
915	<	ConfigGeneral.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
916	<
917	<	if (ConfigGeneral.ts_max_delta < TS_MAX_DELTA_MIN)
918	<	ConfigGeneral.ts_max_delta = TS_MAX_DELTA_DEFAULT;
919	<
920	<	if (ConfigServerInfo.network_name == NULL)
715	>	if (EmptyString(ConfigServerInfo.network_name))
716		ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
717
718	<	if (ConfigServerInfo.network_desc == NULL)
718	>	if (EmptyString(ConfigServerInfo.network_desc))
719		ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
925	–
926	–	if (ConfigGeneral.service_name == NULL)
927	–	ConfigGeneral.service_name = xstrdup(SERVICE_NAME_DEFAULT);
928	–
929	–	ConfigGeneral.max_watch = IRCD_MAX(ConfigGeneral.max_watch, WATCHSIZE_MIN);
720		}
721
722		/* read_conf()
#	Line 938 | Line 728 | validate_conf(void)
728		static void
729		read_conf(FILE *file)
730		{
731	<	lineno = 0;
731	>	lineno = 1;
732
733		set_default_conf();  /* Set default values prior to conf parsing */
734		conf_parser_ctx.pass = 1;
#	Line 950 | Line 740 | read_conf(FILE *file)
740		yyparse();  /* Load the values from the conf */
741		validate_conf();  /* Check to make sure some values are still okay. */
742		/* Some global values are also loaded here. */
743	+	whowas_trim();  /* Attempt to trim whowas list if necessary */
744		class_delete_marked();  /* Delete unused classes that are marked for deletion */
745		}
746
747	+	/* conf_rehash()
748	+	*
749	+	* Actual REHASH service routine. Called with sig == 0 if it has been called
750	+	* as a result of an operator issuing this command, else assume it has been
751	+	* called as a result of the server receiving a HUP signal.
752	+	*/
753	+	void
754	+	conf_rehash(int sig)
755	+	{
756	+	if (sig)
757	+	{
758	+	sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
759	+	"Got signal SIGHUP, reloading configuration file(s)");
760	+	ilog(LOG_TYPE_IRCD, "Got signal SIGHUP, reloading configuration file(s)");
761	+	}
762	+
763	+	restart_resolver();
764	+
765	+	/* don't close listeners until we know we can go ahead with the rehash */
766	+
767	+	read_conf_files(0);
768	+
769	+	load_conf_modules();
770	+	check_conf_klines();
771	+	}
772	+
773		/* lookup_confhost()
774		*
775		* start DNS lookups of all hostnames in the conf
#	Line 1001 | Line 818 | int
818		conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
819		{
820		struct ip_entry *ip_found = NULL;
821	<	struct MaskItem *conf = find_dline_conf(addr, aftype);
1005	<
1006	<	/* DLINE exempt also gets you out of static limits/pacing... */
1007	<	if (conf && (conf->type == CONF_EXEMPT))
1008	<	return 0;
821	>	const struct MaskItem *conf = find_dline_conf(addr, aftype);
822
823		if (conf)
824	+	{
825	+	/* DLINE exempt also gets you out of static limits/pacing... */
826	+	if (conf->type == CONF_EXEMPT)
827	+	return 0;
828		return BANNED_CLIENT;
829	+	}
830
831		ip_found = ipcache_find_or_add_address(addr);
832
#	Line 1034 | Line 852 | conf_connect_allowed(struct irc_ssaddr *
852		*                This is an event started off in ircd.c
853		*/
854		void
855	<	cleanup_tklines(void *notused)
855	>	cleanup_tklines(void *unused)
856		{
857		hostmask_expire_temporary();
858	<	expire_tklines(&xconf_items);
859	<	expire_tklines(&nresv_items);
1042	<	expire_tklines(&cresv_items);
1043	<	}
1044	<
1045	<	/* expire_tklines()
1046	<	*
1047	<	* inputs       - tkline list pointer
1048	<	* output       - NONE
1049	<	* side effects - expire tklines
1050	<	*/
1051	<	static void
1052	<	expire_tklines(dlink_list *tklist)
1053	<	{
1054	<	dlink_node *ptr = NULL, *ptr_next = NULL;
1055	<	struct MaskItem *conf = NULL;
1056	<
1057	<	DLINK_FOREACH_SAFE(ptr, ptr_next, tklist->head)
1058	<	{
1059	<	conf = ptr->data;
1060	<
1061	<	if (!conf->until || conf->until > CurrentTime)
1062	<	continue;
1063	<
1064	<	if (conf->type == CONF_XLINE)
1065	<	{
1066	<	if (ConfigGeneral.tkline_expire_notices)
1067	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1068	<	"Temporary X-line for [%s] expired", conf->name);
1069	<	conf_free(conf);
1070	<	}
1071	<	else if (conf->type == CONF_NRESV || conf->type == CONF_CRESV)
1072	<	{
1073	<	if (ConfigGeneral.tkline_expire_notices)
1074	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1075	<	"Temporary RESV for [%s] expired", conf->name);
1076	<	conf_free(conf);
1077	<	}
1078	<	}
858	>	gecos_expire();
859	>	resv_expire();
860		}
861
862		/* oper_privs_as_string()
#	Line 1084 | Line 865 | expire_tklines(dlink_list *tklist)
865		* output        - pointer to static string showing oper privs
866		* side effects  - return as string, the oper privs as derived from port
867		*/
868	<	static const struct oper_privs
868	>	static const struct oper_flags
869		{
870		const unsigned int flag;
871		const unsigned char c;
872	<	} flag_list[] = {
872	>	} flag_table[] = {
873		{ OPER_FLAG_ADMIN,          'A' },
874	<	{ OPER_FLAG_REMOTEBAN,      'B' },
875	<	{ OPER_FLAG_DIE,            'D' },
876	<	{ OPER_FLAG_GLINE,          'G' },
877	<	{ OPER_FLAG_REHASH,         'H' },
874	>	{ OPER_FLAG_CLOSE,          'B' },
875	>	{ OPER_FLAG_CONNECT,        'C' },
876	>	{ OPER_FLAG_CONNECT_REMOTE, 'D' },
877	>	{ OPER_FLAG_DIE,            'E' },
878	>	{ OPER_FLAG_DLINE,          'F' },
879	>	{ OPER_FLAG_GLOBOPS,        'G' },
880	>	{ OPER_FLAG_JOIN_RESV,      'H' },
881	>	{ OPER_FLAG_KILL,           'I' },
882	>	{ OPER_FLAG_KILL_REMOTE,    'J' },
883		{ OPER_FLAG_KLINE,          'K' },
884	<	{ OPER_FLAG_KILL,           'N' },
885	<	{ OPER_FLAG_KILL_REMOTE,    'O' },
886	<	{ OPER_FLAG_CONNECT,        'P' },
887	<	{ OPER_FLAG_CONNECT_REMOTE, 'Q' },
888	<	{ OPER_FLAG_SQUIT,          'R' },
889	<	{ OPER_FLAG_SQUIT_REMOTE,   'S' },
890	<	{ OPER_FLAG_UNKLINE,        'U' },
891	<	{ OPER_FLAG_XLINE,          'X' },
884	>	{ OPER_FLAG_LOCOPS,         'L' },
885	>	{ OPER_FLAG_MODULE,         'M' },
886	>	{ OPER_FLAG_NICK_RESV,      'N' },
887	>	{ OPER_FLAG_OPME,           'O' },
888	>	{ OPER_FLAG_REHASH,         'P' },
889	>	{ OPER_FLAG_REMOTEBAN,      'Q' },
890	>	{ OPER_FLAG_RESTART,        'R' },
891	>	{ OPER_FLAG_RESV,           'S' },
892	>	{ OPER_FLAG_SET,            'T' },
893	>	{ OPER_FLAG_SQUIT,          'U' },
894	>	{ OPER_FLAG_SQUIT_REMOTE,   'V' },
895	>	{ OPER_FLAG_UNDLINE,        'W' },
896	>	{ OPER_FLAG_UNKLINE,        'X' },
897	>	{ OPER_FLAG_UNRESV,         'Y' },
898	>	{ OPER_FLAG_UNXLINE,        'Z' },
899	>	{ OPER_FLAG_WALLOPS,        'a' },
900	>	{ OPER_FLAG_XLINE,          'b' },
901		{ 0, '\0' }
902		};
903
904	<	char *
905	<	oper_privs_as_string(const unsigned int port)
904	>	const char *
905	>	oper_privs_as_string(const unsigned int flags)
906		{
907	<	static char privs_out[IRCD_BUFSIZE];
908	<	char *privs_ptr = privs_out;
907	>	static char buf[sizeof(flag_table) / sizeof(flag_table[0])];
908	>	char *p = buf;
909
910	<	for (const struct oper_privs *opriv = flag_list; opriv->flag; ++opriv)
911	<	{
912	<	if (port & opriv->flag)
913	<	*privs_ptr++ = opriv->c;
914	<	else
915	<	*privs_ptr++ = ToLower(opriv->c);
1121	<	}
910	>	for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
911	>	if (flags & tab->flag)
912	>	*p++ = tab->c;
913	>
914	>	if (p == buf)
915	>	*p++ = '0';
916
917	<	*privs_ptr = '\0';
917	>	*p = '\0';
918
919	<	return privs_out;
919	>	return buf;
920		}
921
922		/*
#	Line 1134 | Line 928 | oper_privs_as_string(const unsigned int
928		const char *
929		get_oper_name(const struct Client *client_p)
930		{
931	<	const dlink_node *cnode = NULL;
932	<	/* +5 for !,@,{,} and null */
933	<	static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
931	>	static char buffer[IRCD_BUFSIZE];
932	>
933	>	if (IsServer(client_p))
934	>	return client_p->name;
935
936		if (MyConnect(client_p))
937		{
938	<	if ((cnode = client_p->localClient->confs.head))
938	>	const dlink_node *const node = client_p->connection->confs.head;
939	>
940	>	if (node)
941		{
942	<	const struct MaskItem *conf = cnode->data;
942	>	const struct MaskItem *const conf = node->data;
943
944	<	if (IsConfOperator(conf))
944	>	if (conf->type == CONF_OPER)
945		{
946		snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
947		client_p->username, client_p->host, conf->name);
#	Line 1164 | Line 961 | get_oper_name(const struct Client *clien
961		return buffer;
962		}
963
964	+	/* clear_out_old_conf()
965	+	*
966	+	* inputs       - none
967	+	* output       - none
968	+	* side effects - Clear out the old configuration
969	+	*/
970	+	static void
971	+	clear_out_old_conf(void)
972	+	{
973	+	dlink_node *node = NULL, *node_next = NULL;
974	+	dlink_list *free_items [] = {
975	+	&connect_items, &operator_items, NULL
976	+	};
977	+
978	+	dlink_list ** iterator = free_items; /* C is dumb */
979	+
980	+	/* We only need to free anything allocated by yyparse() here.
981	+	* Resetting structs, etc, is taken care of by set_default_conf().
982	+	*/
983	+
984	+	for (; *iterator; iterator++)
985	+	{
986	+	DLINK_FOREACH_SAFE(node, node_next, (*iterator)->head)
987	+	{
988	+	struct MaskItem *conf = node->data;
989	+
990	+	conf->active = 0;
991	+	dlinkDelete(&conf->node, *iterator);
992	+
993	+	if (!conf->ref_count)
994	+	conf_free(conf);
995	+	}
996	+	}
997	+
998	+	/*
999	+	* Don't delete the class table, rather mark all entries for deletion.
1000	+	* The table is cleaned up by class_delete_marked. - avalon
1001	+	*/
1002	+	class_mark_for_deletion();
1003	+
1004	+	clear_out_address_conf();
1005	+
1006	+	modules_conf_clear();  /* Clear modules {} items */
1007	+
1008	+	motd_clear();  /* Clear motd {} items and re-cache default motd */
1009	+
1010	+	cluster_clear();  /* Clear cluster {} items */
1011	+
1012	+	gecos_clear();  /* Clear gecos {} items */
1013	+
1014	+	resv_clear();  /* Clear resv {} items */
1015	+
1016	+	service_clear();  /* Clear service {} items */
1017	+
1018	+	shared_clear();  /* Clear shared {} items */
1019	+
1020	+	pseudo_clear();  /* Clear pseudo {} items */
1021	+
1022	+	/* Clean out ConfigServerInfo */
1023	+	xfree(ConfigServerInfo.description);
1024	+	ConfigServerInfo.description = NULL;
1025	+	xfree(ConfigServerInfo.network_name);
1026	+	ConfigServerInfo.network_name = NULL;
1027	+	xfree(ConfigServerInfo.network_desc);
1028	+	ConfigServerInfo.network_desc = NULL;
1029	+	xfree(ConfigServerInfo.rsa_private_key_file);
1030	+	ConfigServerInfo.rsa_private_key_file = NULL;
1031	+	xfree(ConfigServerInfo.ssl_certificate_file);
1032	+	ConfigServerInfo.ssl_certificate_file = NULL;
1033	+	xfree(ConfigServerInfo.ssl_dh_param_file);
1034	+	ConfigServerInfo.ssl_dh_param_file = NULL;
1035	+	xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
1036	+	ConfigServerInfo.ssl_dh_elliptic_curve = NULL;
1037	+	xfree(ConfigServerInfo.ssl_cipher_list);
1038	+	ConfigServerInfo.ssl_cipher_list = NULL;
1039	+	xfree(ConfigServerInfo.ssl_message_digest_algorithm);
1040	+	ConfigServerInfo.ssl_message_digest_algorithm = NULL;
1041	+
1042	+	/* Clean out ConfigAdminInfo */
1043	+	xfree(ConfigAdminInfo.name);
1044	+	ConfigAdminInfo.name = NULL;
1045	+	xfree(ConfigAdminInfo.email);
1046	+	ConfigAdminInfo.email = NULL;
1047	+	xfree(ConfigAdminInfo.description);
1048	+	ConfigAdminInfo.description = NULL;
1049	+
1050	+	xfree(ConfigServerHide.flatten_links_file);
1051	+	ConfigServerHide.flatten_links_file = NULL;
1052	+
1053	+	/* Clean out listeners */
1054	+	listener_close_marked();
1055	+	}
1056	+
1057	+	static void
1058	+	conf_handle_tls(int cold)
1059	+	{
1060	+	if (!tls_new_cred())
1061	+	{
1062	+	if (cold)
1063	+	{
1064	+	ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1065	+	exit(EXIT_FAILURE);
1066	+	}
1067	+	else
1068	+	{
1069	+	/* Failed to load new settings/certs, old ones remain active */
1070	+	sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
1071	+	"Error reloading TLS settings, check the ircd log"); // report_crypto_errors logs this
1072	+	}
1073	+	}
1074	+	}
1075	+
1076		/* read_conf_files()
1077		*
1078		* inputs       - cold start YES or NO
#	Line 1194 | Line 1103 | read_conf_files(int cold)
1103		{
1104		ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1105		filename, strerror(errno));
1106	<	exit(-1);
1106	>	exit(EXIT_FAILURE);
1107		}
1108		else
1109		{
1110	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1110	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1111		"Unable to read configuration file '%s': %s",
1112		filename, strerror(errno));
1113		return;
#	Line 1212 | Line 1121 | read_conf_files(int cold)
1121		fclose(conf_parser_ctx.conf_file);
1122
1123		log_reopen_all();
1124	+	conf_handle_tls(cold);
1125
1126	<	add_isupport("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1127	<	add_isupport("NETWORK", ConfigServerInfo.network_name, -1);
1126	>	isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1127	>	isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
1128
1129	<	snprintf(chanmodes, sizeof(chanmodes), "beI:%d", ConfigChannel.max_bans);
1130	<	add_isupport("MAXLIST", chanmodes, -1);
1131	<	add_isupport("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1132	<	add_isupport("CHANTYPES", "#", -1);
1129	>	snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans);
1130	>	isupport_add("MAXLIST", chanmodes, -1);
1131	>	isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1132	>	isupport_add("CHANTYPES", "#", -1);
1133
1134	<	snprintf(chanlimit, sizeof(chanlimit), "#:%d",
1134	>	snprintf(chanlimit, sizeof(chanlimit), "#:%u",
1135		ConfigChannel.max_channels);
1136	<	add_isupport("CHANLIMIT", chanlimit, -1);
1137	<	snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstMORS");
1138	<	add_isupport("CHANNELLEN", NULL, CHANNELLEN);
1139	<	add_isupport("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1140	<	add_isupport("CHANMODES", chanmodes, -1);
1231	<
1232	<	/*
1233	<	* message_locale may have changed.  rebuild isupport since it relies
1234	<	* on strlen(form_str(RPL_ISUPPORT))
1235	<	*/
1236	<	rebuild_isupport_message_line();
1237	<	}
1238	<
1239	<	/* clear_out_old_conf()
1240	<	*
1241	<	* inputs       - none
1242	<	* output       - none
1243	<	* side effects - Clear out the old configuration
1244	<	*/
1245	<	static void
1246	<	clear_out_old_conf(void)
1247	<	{
1248	<	dlink_node *ptr = NULL, *next_ptr = NULL;
1249	<	struct MaskItem *conf;
1250	<	dlink_list *free_items [] = {
1251	<	&server_items,   &oconf_items,
1252	<	&uconf_items,   &xconf_items,
1253	<	&nresv_items, &cluster_items,  &service_items, &cresv_items, NULL
1254	<	};
1255	<
1256	<	dlink_list ** iterator = free_items; /* C is dumb */
1257	<
1258	<	/* We only need to free anything allocated by yyparse() here.
1259	<	* Resetting structs, etc, is taken care of by set_default_conf().
1260	<	*/
1261	<
1262	<	for (; *iterator != NULL; iterator++)
1263	<	{
1264	<	DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
1265	<	{
1266	<	conf = ptr->data;
1267	<
1268	<	dlinkDelete(&conf->node, map_to_list(conf->type));
1269	<
1270	<	/* XXX This is less than pretty */
1271	<	if (conf->type == CONF_SERVER || conf->type == CONF_OPER)
1272	<	{
1273	<	if (!conf->ref_count)
1274	<	conf_free(conf);
1275	<	}
1276	<	else if (conf->type == CONF_XLINE)
1277	<	{
1278	<	if (!conf->until)
1279	<	conf_free(conf);
1280	<	}
1281	<	else
1282	<	conf_free(conf);
1283	<	}
1284	<	}
1285	<
1286	<	motd_clear();
1287	<
1288	<	/*
1289	<	* don't delete the class table, rather mark all entries
1290	<	* for deletion. The table is cleaned up by class_delete_marked. - avalon
1291	<	*/
1292	<	class_mark_for_deletion();
1293	<
1294	<	clear_out_address_conf();
1295	<
1296	<	/* clean out module paths */
1297	<	mod_clear_paths();
1298	<
1299	<	/* clean out ConfigServerInfo */
1300	<	MyFree(ConfigServerInfo.description);
1301	<	ConfigServerInfo.description = NULL;
1302	<	MyFree(ConfigServerInfo.network_name);
1303	<	ConfigServerInfo.network_name = NULL;
1304	<	MyFree(ConfigServerInfo.network_desc);
1305	<	ConfigServerInfo.network_desc = NULL;
1306	<	#ifdef HAVE_LIBCRYPTO
1307	<	if (ConfigServerInfo.rsa_private_key)
1308	<	{
1309	<	RSA_free(ConfigServerInfo.rsa_private_key);
1310	<	ConfigServerInfo.rsa_private_key = NULL;
1311	<	}
1312	<
1313	<	MyFree(ConfigServerInfo.rsa_private_key_file);
1314	<	ConfigServerInfo.rsa_private_key_file = NULL;
1315	<	#endif
1316	<
1317	<	/* clean out ConfigAdminInfo */
1318	<	MyFree(ConfigAdminInfo.name);
1319	<	ConfigAdminInfo.name = NULL;
1320	<	MyFree(ConfigAdminInfo.email);
1321	<	ConfigAdminInfo.email = NULL;
1322	<	MyFree(ConfigAdminInfo.description);
1323	<	ConfigAdminInfo.description = NULL;
1324	<
1325	<	/* clean out listeners */
1326	<	close_listeners();
1327	<
1328	<	/* clean out general */
1329	<	MyFree(ConfigGeneral.service_name);
1330	<	ConfigGeneral.service_name = NULL;
1136	>	isupport_add("CHANLIMIT", chanlimit, -1);
1137	>	snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstuCLMORST");
1138	>	isupport_add("CHANNELLEN", NULL, CHANNELLEN);
1139	>	isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1140	>	isupport_add("CHANMODES", chanmodes, -1);
1141		}
1142
1143		/* conf_add_class_to_conf()
#	Line 1337 | Line 1147 | clear_out_old_conf(void)
1147		* side effects - Add a class pointer to a conf
1148		*/
1149		void
1150	<	conf_add_class_to_conf(struct MaskItem *conf, const char *class_name)
1150	>	conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1151		{
1152	<	if (class_name == NULL)
1152	>	if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1153		{
1154		conf->class = class_default;
1155
1156	<	if (conf->type == CONF_CLIENT)
1157	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1348	<	"Warning *** Defaulting to default class for %s@%s",
1349	<	conf->user, conf->host);
1350	<	else
1351	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1352	<	"Warning *** Defaulting to default class for %s",
1353	<	conf->name);
1354	<	}
1355	<	else
1356	<	conf->class = class_find(class_name, 1);
1357	<
1358	<	if (conf->class == NULL)
1359	<	{
1360	<	if (conf->type == CONF_CLIENT)
1361	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1156	>	if (conf->type == CONF_CLIENT || conf->type == CONF_OPER)
1157	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1158		"Warning *** Defaulting to default class for %s@%s",
1159		conf->user, conf->host);
1160		else
1161	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1161	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1162		"Warning *** Defaulting to default class for %s",
1163		conf->name);
1368	–	conf->class = class_default;
1164		}
1165		}
1166
#	Line 1378 | Line 1173 | conf_add_class_to_conf(struct MaskItem *
1173		void
1174		yyerror(const char *msg)
1175		{
1381	–	char newlinebuf[IRCD_BUFSIZE];
1382	–
1176		if (conf_parser_ctx.pass != 1)
1177		return;
1178
1179	<	strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1180	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1179	>	const char *p = stripws(linebuf);
1180	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1181		"\"%s\", line %u: %s: %s",
1182	<	conffilebuf, lineno + 1, msg, newlinebuf);
1182	>	conffilebuf, lineno, msg, p);
1183		ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1184	<	conffilebuf, lineno + 1, msg, newlinebuf);
1184	>	conffilebuf, lineno, msg, p);
1185		}
1186
1187		void
1188		conf_error_report(const char *msg)
1189		{
1190	<	char newlinebuf[IRCD_BUFSIZE];
1191	<
1399	<	strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1400	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1190	>	const char *p = stripws(linebuf);
1191	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1192		"\"%s\", line %u: %s: %s",
1193	<	conffilebuf, lineno + 1, msg, newlinebuf);
1193	>	conffilebuf, lineno, msg, p);
1194		ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1195	<	conffilebuf, lineno + 1, msg, newlinebuf);
1195	>	conffilebuf, lineno, msg, p);
1196		}
1197
1198		/*
#	Line 1414 | Line 1205 | conf_error_report(const char *msg)
1205		* side effects - none
1206		* Originally written by Dianora (Diane, db@db.net)
1207		*/
1208	<	time_t
1208	>	uintmax_t
1209		valid_tkline(const char *data, const int minutes)
1210		{
1211		const unsigned char *p = (const unsigned char *)data;
1212		unsigned char tmpch = '\0';
1213	<	time_t result = 0;
1213	>	uintmax_t result = 0;
1214
1215		while ((tmpch = *p++))
1216		{
#	Line 1432 | Line 1223 | valid_tkline(const char *data, const int
1223
1224		/*
1225		* In the degenerate case where oper does a /quote kline 0 user@host :reason
1226	<	* i.e. they specifically use 0, I am going to return 1 instead
1227	<	* as a return value of non-zero is used to flag it as a temporary kline
1226	>	* i.e. they specifically use 0, I am going to return 1 instead as a return
1227	>	* value of non-zero is used to flag it as a temporary kline
1228		*/
1229		if (result == 0)
1230		result = 1;
#	Line 1448 | Line 1239 | valid_tkline(const char *data, const int
1239		if (result > MAX_TDKLINE_TIME)
1240		result = MAX_TDKLINE_TIME;
1241
1242	<	result = result * 60;  /* turn it into seconds */
1242	>	result = result * 60;  /* Turn it into seconds */
1243
1244		return result;
1245		}
#	Line 1464 | Line 1255 | valid_wild_card_simple(const char *data)
1255		{
1256		const unsigned char *p = (const unsigned char *)data;
1257		unsigned char tmpch = '\0';
1258	<	unsigned int nonwild = 0;
1258	>	unsigned int nonwild = 0, wild = 0;
1259
1260		while ((tmpch = *p++))
1261		{
#	Line 1479 | Line 1270 | valid_wild_card_simple(const char *data)
1270		if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1271		return 1;
1272		}
1273	+	else
1274	+	++wild;
1275		}
1276
1277	<	return 0;
1277	>	return !wild;
1278		}
1279
1280		/* valid_wild_card()
#	Line 1493 | Line 1286 | valid_wild_card_simple(const char *data)
1286		* side effects - NOTICE is given to source_p if warn is 1
1287		*/
1288		int
1289	<	valid_wild_card(struct Client *source_p, int warn, int count, ...)
1289	>	valid_wild_card(int count, ...)
1290		{
1291		unsigned char tmpch = '\0';
1292		unsigned int nonwild = 0;
#	Line 1536 | Line 1329 | valid_wild_card(struct Client *source_p,
1329		}
1330		}
1331
1539	–	if (warn)
1540	–	sendto_one_notice(source_p, &me,
1541	–	":Please include at least %u non-wildcard characters with the mask",
1542	–	ConfigGeneral.min_nonwildcard);
1332		va_end(args);
1333		return 0;
1334		}
1335
1336	+	/* find_user_host()
1337	+	*
1338	+	* inputs       - pointer to client placing kline
1339	+	*              - pointer to user_host_or_nick
1340	+	*              - pointer to user buffer
1341	+	*              - pointer to host buffer
1342	+	* output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1343	+	* side effects -
1344	+	*/
1345	+	static int
1346	+	find_user_host(struct Client *source_p, char *user_host_or_nick,
1347	+	char *luser, char *lhost)
1348	+	{
1349	+	struct Client *target_p = NULL;
1350	+	char *hostp = NULL;
1351	+
1352	+	if (lhost == NULL)
1353	+	{
1354	+	strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1355	+	return 1;
1356	+	}
1357	+
1358	+	if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1359	+	{
1360	+	/* Explicit user@host mask given */
1361	+	if (hostp)                            /* I'm a little user@host */
1362	+	{
1363	+	*(hostp++) = '\0';                       /* short and squat */
1364	+
1365	+	if (*user_host_or_nick)
1366	+	strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1367	+	else
1368	+	strcpy(luser, "*");
1369	+
1370	+	if (*hostp)
1371	+	strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1372	+	else
1373	+	strcpy(lhost, "*");
1374	+	}
1375	+	else
1376	+	{
1377	+	luser[0] = '*';             /* no @ found, assume its *@somehost */
1378	+	luser[1] = '\0';
1379	+	strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1380	+	}
1381	+
1382	+	return 1;
1383	+	}
1384	+	else
1385	+	{
1386	+	/* Try to find user@host mask from nick */
1387	+	/* Okay to use source_p as the first param, because source_p == client_p */
1388	+	if ((target_p =
1389	+	find_chasing(source_p, user_host_or_nick)) == NULL)
1390	+	return 0;  /* find_chasing sends ERR_NOSUCHNICK */
1391	+
1392	+	if (HasFlag(target_p, FLAGS_EXEMPTKLINE))
1393	+	{
1394	+	if (IsClient(source_p))
1395	+	sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1396	+	return 0;
1397	+	}
1398	+
1399	+	/*
1400	+	* Turn the "user" bit into "*user", blow away '~'
1401	+	* if found in original user name (non-idented)
1402	+	*/
1403	+	strlcpy(luser, target_p->username, USERLEN*4 + 1);
1404	+
1405	+	if (target_p->username[0] == '~')
1406	+	luser[0] = '*';
1407	+
1408	+	strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1409	+	return 1;
1410	+	}
1411	+
1412	+	return 0;
1413	+	}
1414	+
1415		/* XXX should this go into a separate file ? -Dianora */
1416		/* parse_aline
1417		*
#	Line 1558 | Line 1426 | valid_wild_card(struct Client *source_p,
1426		*              - pointer to target_server to parse into if non NULL
1427		*              - pointer to reason to parse into
1428		*
1429	<	* output       - 1 if valid, -1 if not valid
1429	>	* output       - 1 if valid, 0 if not valid
1430		* side effects - A generalised k/d/x etc. line parser,
1431		*               "ALINE [time] user@host|string [ON] target :reason"
1432		*                will parse returning a parsed user, host if
#	Line 1577 | Line 1445 | valid_wild_card(struct Client *source_p,
1445		int
1446		parse_aline(const char *cmd, struct Client *source_p,
1447		int parc, char **parv,
1448	<	int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1448	>	char **up_p, char **h_p, uintmax_t *tkline_time,
1449		char **target_server, char **reason)
1450		{
1451	<	int found_tkline_time=0;
1452	<	static char def_reason[] = CONF_NOREASON;
1451	>	uintmax_t found_tkline_time=0;
1452	>	static char default_reason[] = CONF_NOREASON;
1453		static char user[USERLEN*4+1];
1454		static char host[HOSTLEN*4+1];
1455
#	Line 1590 | Line 1458 | parse_aline(const char *cmd, struct Clie
1458
1459		found_tkline_time = valid_tkline(*parv, TK_MINUTES);
1460
1461	<	if (found_tkline_time != 0)
1461	>	if (found_tkline_time)
1462		{
1463		parv++;
1464		parc--;
1465
1466	<	if (tkline_time != NULL)
1466	>	if (tkline_time)
1467		*tkline_time = found_tkline_time;
1468		else
1469		{
1470		sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1471	<	return -1;
1471	>	return 0;
1472		}
1473		}
1474
1475		if (parc == 0)
1476		{
1477		sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1478	<	return -1;
1478	>	return 0;
1479		}
1480
1481		if (h_p == NULL)
1482		*up_p = *parv;
1483		else
1484		{
1485	<	if (find_user_host(source_p, *parv, user, host, parse_flags) == 0)
1486	<	return -1;
1485	>	if (find_user_host(source_p, *parv, user, host) == 0)
1486	>	return 0;
1487
1488		*up_p = user;
1489		*h_p = host;
#	Line 1624 | Line 1492 | parse_aline(const char *cmd, struct Clie
1492		parc--;
1493		parv++;
1494
1495	<	if (parc != 0)
1495	>	if (parc)
1496		{
1497		if (irccmp(*parv, "ON") == 0)
1498		{
1499		parc--;
1500		parv++;
1501
1634	–	if (target_server == NULL)
1635	–	{
1636	–	sendto_one_notice(source_p, &me, ":ON server not supported by %s", cmd);
1637	–	return -1;
1638	–	}
1639	–
1502		if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1503		{
1504		sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1505	<	return -1;
1505	>	return 0;
1506		}
1507
1508		if (parc == 0 || EmptyString(*parv))
1509		{
1510		sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1511	<	return -1;
1511	>	return 0;
1512		}
1513
1514		*target_server = *parv;
#	Line 1658 | Line 1520 | parse_aline(const char *cmd, struct Clie
1520		/* Make sure target_server *is* NULL if no ON server found
1521		* caller probably NULL'd it first, but no harm to do it again -db
1522		*/
1523	<	if (target_server != NULL)
1523	>	if (target_server)
1524		*target_server = NULL;
1525		}
1526		}
1527
1528	<	if (h_p != NULL)
1667	<	{
1668	<	if (strchr(user, '!') != NULL)
1669	<	{
1670	<	sendto_one_notice(source_p, &me, ":Invalid character '!' in kline");
1671	<	return -1;
1672	<	}
1673	<
1674	<	if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
1675	<	return -1;
1676	<	}
1677	<	else
1678	<	if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
1679	<	return -1;
1680	<
1681	<	if (reason != NULL)
1528	>	if (reason)
1529		{
1530	<	if (parc != 0 && !EmptyString(*parv))
1684	<	{
1530	>	if (parc && !EmptyString(*parv))
1531		*reason = *parv;
1686	–	if (!valid_comment(source_p, *reason, 1))
1687	–	return -1;
1688	–	}
1532		else
1533	<	*reason = def_reason;
1533	>	*reason = default_reason;
1534		}
1535
1536		return 1;
1537		}
1538
1696	–	/* find_user_host()
1697	–	*
1698	–	* inputs       - pointer to client placing kline
1699	–	*              - pointer to user_host_or_nick
1700	–	*              - pointer to user buffer
1701	–	*              - pointer to host buffer
1702	–	* output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1703	–	* side effects -
1704	–	*/
1705	–	static int
1706	–	find_user_host(struct Client *source_p, char *user_host_or_nick,
1707	–	char *luser, char *lhost, unsigned int flags)
1708	–	{
1709	–	struct Client *target_p = NULL;
1710	–	char *hostp = NULL;
1711	–
1712	–	if (lhost == NULL)
1713	–	{
1714	–	strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1715	–	return 1;
1716	–	}
1717	–
1718	–	if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1719	–	{
1720	–	/* Explicit user@host mask given */
1721	–
1722	–	if (hostp != NULL)                            /* I'm a little user@host */
1723	–	{
1724	–	*(hostp++) = '\0';                       /* short and squat */
1725	–	if (*user_host_or_nick)
1726	–	strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1727	–	else
1728	–	strcpy(luser, "*");
1729	–
1730	–	if (*hostp)
1731	–	strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1732	–	else
1733	–	strcpy(lhost, "*");
1734	–	}
1735	–	else
1736	–	{
1737	–	luser[0] = '*';             /* no @ found, assume its *@somehost */
1738	–	luser[1] = '\0';
1739	–	strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1740	–	}
1741	–
1742	–	return 1;
1743	–	}
1744	–	else
1745	–	{
1746	–	/* Try to find user@host mask from nick */
1747	–	/* Okay to use source_p as the first param, because source_p == client_p */
1748	–	if ((target_p =
1749	–	find_chasing(source_p, user_host_or_nick)) == NULL)
1750	–	return 0;  /* find_chasing sends ERR_NOSUCHNICK */
1751	–
1752	–	if (IsExemptKline(target_p))
1753	–	{
1754	–	if (!IsServer(source_p))
1755	–	sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1756	–	return 0;
1757	–	}
1758	–
1759	–	/*
1760	–	* turn the "user" bit into "*user", blow away '~'
1761	–	* if found in original user name (non-idented)
1762	–	*/
1763	–	strlcpy(luser, target_p->username, USERLEN*4 + 1);
1764	–
1765	–	if (target_p->username[0] == '~')
1766	–	luser[0] = '*';
1767	–
1768	–	if (target_p->sockhost[0] == '\0' ||
1769	–	(target_p->sockhost[0] == '0' && target_p->sockhost[1] == '\0'))
1770	–	strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
1771	–	else
1772	–	strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1773	–	return 1;
1774	–	}
1775	–
1776	–	return 0;
1777	–	}
1778	–
1779	–	/* valid_comment()
1780	–	*
1781	–	* inputs       - pointer to client
1782	–	*              - pointer to comment
1783	–	* output       - 0 if no valid comment,
1784	–	*              - 1 if valid
1785	–	* side effects - truncates reason where necessary
1786	–	*/
1787	–	int
1788	–	valid_comment(struct Client *source_p, char *comment, int warn)
1789	–	{
1790	–	if (strlen(comment) > REASONLEN)
1791	–	comment[REASONLEN-1] = '\0';
1792	–
1793	–	return 1;
1794	–	}
1795	–
1539		/* match_conf_password()
1540		*
1541		* inputs       - pointer to given password
#	Line 1817 | Line 1560 | match_conf_password(const char *password
1560		}
1561
1562		/*
1820	–	* cluster_a_line
1821	–	*
1822	–	* inputs       - client sending the cluster
1823	–	*              - command name "KLINE" "XLINE" etc.
1824	–	*              - capab -- CAP_KLN etc. from server.h
1825	–	*              - cluster type -- CLUSTER_KLINE etc. from conf.h
1826	–	*              - pattern and args to send along
1827	–	* output       - none
1828	–	* side effects - Take source_p send the pattern with args given
1829	–	*                along to all servers that match capab and cluster type
1830	–	*/
1831	–	void
1832	–	cluster_a_line(struct Client *source_p, const char *command,
1833	–	int capab, int cluster_type, const char *pattern, ...)
1834	–	{
1835	–	va_list args;
1836	–	char buffer[IRCD_BUFSIZE] = "";
1837	–	const dlink_node *ptr = NULL;
1838	–
1839	–	va_start(args, pattern);
1840	–	vsnprintf(buffer, sizeof(buffer), pattern, args);
1841	–	va_end(args);
1842	–
1843	–	DLINK_FOREACH(ptr, cluster_items.head)
1844	–	{
1845	–	const struct MaskItem *conf = ptr->data;
1846	–
1847	–	if (conf->flags & cluster_type)
1848	–	sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
1849	–	"%s %s %s", command, conf->name, buffer);
1850	–	}
1851	–	}
1852	–
1853	–	/*
1563		* split_nuh
1564		*
1565		* inputs       - pointer to original mask (modified in place)
#	Line 1885 | Line 1594 | split_nuh(struct split_nuh_item *const i
1594
1595		if (iptr->nickptr)
1596		strlcpy(iptr->nickptr, "*", iptr->nicksize);
1597	+
1598		if (iptr->userptr)
1599		strlcpy(iptr->userptr, "*", iptr->usersize);
1600	+
1601		if (iptr->hostptr)
1602		strlcpy(iptr->hostptr, "*", iptr->hostsize);
1603
#	Line 1929 | Line 1640 | split_nuh(struct split_nuh_item *const i
1640		}
1641		else
1642		{
1643	<	/* no @ found */
1643	>	/* No @ found */
1644		if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:"))
1645		strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
1646		else

Comparing ircd-hybrid/trunk/src/conf.c (property svn:keywords):
Revision 4343 by michael, Sat Aug 2 16:58:33 2014 UTC vs.
Revision 8314 by michael, Wed Feb 28 17:47:23 2018 UTC

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

Diff Legend

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