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 2133 by michael, Wed May 29 18:27:24 2013 UTC vs.
Revision 3933 by michael, Mon Jun 9 17:56:42 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  conf.c: Configuration file functions.
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 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
20	<	*
21	<	*  $Id$
20	>	*/
21	>
22	>	/*! \file conf.c
23	>	* \brief Configuration file functions.
24	>	* \version $Id$
25		*/
26
27		#include "stdinc.h"
28		#include "list.h"
29		#include "ircd_defs.h"
30		#include "conf.h"
31	<	#include "s_serv.h"
31	>	#include "server.h"
32		#include "resv.h"
33		#include "channel.h"
34		#include "client.h"
35		#include "event.h"
34	–	#include "hook.h"
36		#include "irc_string.h"
37		#include "s_bsd.h"
38		#include "ircd.h"
#	Line 42 | Line 43
43		#include "fdlist.h"
44		#include "log.h"
45		#include "send.h"
45	–	#include "s_gline.h"
46		#include "memory.h"
47		#include "mempool.h"
48	<	#include "irc_res.h"
48	>	#include "res.h"
49		#include "userhost.h"
50	<	#include "s_user.h"
50	>	#include "user.h"
51		#include "channel_mode.h"
52		#include "parse.h"
53	<	#include "s_misc.h"
53	>	#include "misc.h"
54		#include "conf_db.h"
55		#include "conf_class.h"
56	+	#include "motd.h"
57
58	+
59	+	struct config_channel_entry ConfigChannel;
60		struct config_server_hide ConfigServerHide;
61	+	struct config_file_entry ConfigFileEntry;
62	+	struct logging_entry ConfigLoggingEntry = { .use_logging = 1 };
63	+	struct server_info ServerInfo;
64	+	struct admin_info AdminInfo;
65
66		/* general conf items link list root, other than k lines etc. */
67		dlink_list service_items = { NULL, NULL, 0 };
#	Line 64 | Line 71 | dlink_list oconf_items   = { NULL, NULL,
71		dlink_list uconf_items   = { NULL, NULL, 0 };
72		dlink_list xconf_items   = { NULL, NULL, 0 };
73		dlink_list nresv_items   = { NULL, NULL, 0 };
74	<	dlink_list temporary_resv = { NULL, NULL, 0 };
74	>	dlink_list cresv_items = { NULL, NULL, 0 };
75
76		extern unsigned int lineno;
77		extern char linebuf[];
#	Line 95 | Line 102 | static int find_user_host(struct Client
102		struct ip_entry
103		{
104		struct irc_ssaddr ip;
105	<	unsigned int count;
106	<	time_t last_attempt;
105	>	unsigned int count;  /**< Number of registered users using this IP */
106	>	unsigned int connection_count;  /**< Number of connections from this IP in the last throttle_time duration */
107	>	time_t last_attempt;  /**< The last time someone connected from this IP */
108		struct ip_entry *next;
109		};
110
#	Line 122 | Line 130 | conf_dns_callback(void *vptr, const stru
130
131		conf->dns_pending = 0;
132
133	<	if (addr != NULL)
133	>	if (addr)
134		memcpy(&conf->addr, addr, sizeof(conf->addr));
135		else
136		conf->dns_failed = 1;
#	Line 147 | Line 155 | conf_dns_lookup(struct MaskItem *conf)
155		struct MaskItem *
156		conf_make(enum maskitem_type type)
157		{
158	<	struct MaskItem *conf = MyMalloc(sizeof(*conf));
158	>	struct MaskItem *conf = MyCalloc(sizeof(*conf));
159		dlink_list *list = NULL;
160
161		conf->type   = type;
#	Line 173 | Line 181 | conf_free(struct MaskItem *conf)
181
182		if (conf->dns_pending)
183		delete_resolver_queries(conf);
184	<	if (conf->passwd != NULL)
184	>	if (conf->passwd)
185		memset(conf->passwd, 0, strlen(conf->passwd));
186	<	if (conf->spasswd != NULL)
186	>	if (conf->spasswd)
187		memset(conf->spasswd, 0, strlen(conf->spasswd));
188
189		conf->class = NULL;
#	Line 183 | Line 191 | conf_free(struct MaskItem *conf)
191		MyFree(conf->passwd);
192		MyFree(conf->spasswd);
193		MyFree(conf->reason);
194	+	MyFree(conf->certfp);
195		MyFree(conf->user);
196		MyFree(conf->host);
197		#ifdef HAVE_LIBCRYPTO
#	Line 194 | Line 203 | conf_free(struct MaskItem *conf)
203		DLINK_FOREACH_SAFE(ptr, ptr_next, conf->hub_list.head)
204		{
205		MyFree(ptr->data);
206	+	dlinkDelete(ptr, &conf->hub_list);
207		free_dlink_node(ptr);
208		}
209
210		DLINK_FOREACH_SAFE(ptr, ptr_next, conf->leaf_list.head)
211		{
212		MyFree(ptr->data);
213	+	dlinkDelete(ptr, &conf->leaf_list);
214		free_dlink_node(ptr);
215		}
216
#	Line 207 | Line 218 | conf_free(struct MaskItem *conf)
218		{
219		struct exempt *exptr = ptr->data;
220
221	+	dlinkDelete(ptr, &conf->exempt_list);
222		MyFree(exptr->name);
223		MyFree(exptr->user);
224		MyFree(exptr->host);
#	Line 233 | Line 245 | int
245		check_client(struct Client *source_p)
246		{
247		int i;
248	<
248	>
249		if ((i = verify_access(source_p)))
250	<	ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
250	>	ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
251		source_p->name, source_p->sockhost);
252
253		switch (i)
#	Line 243 | Line 255 | check_client(struct Client *source_p)
255		case TOO_MANY:
256		sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
257		"Too many on IP for %s (%s).",
258	<	get_client_name(source_p, SHOW_IP),
259	<	source_p->sockhost);
258	>	get_client_name(source_p, SHOW_IP),
259	>	source_p->sockhost);
260		ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
261	<	get_client_name(source_p, SHOW_IP));
261	>	get_client_name(source_p, SHOW_IP));
262		++ServerStats.is_ref;
263	<	exit_client(source_p, &me, "No more connections allowed on that IP");
263	>	exit_client(source_p, "No more connections allowed on that IP");
264		break;
265
266		case I_LINE_FULL:
267		sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
268		"auth{} block is full for %s (%s).",
269	<	get_client_name(source_p, SHOW_IP),
270	<	source_p->sockhost);
269	>	get_client_name(source_p, SHOW_IP),
270	>	source_p->sockhost);
271		ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
272	<	get_client_name(source_p, SHOW_IP));
272	>	get_client_name(source_p, SHOW_IP));
273		++ServerStats.is_ref;
274	<	exit_client(source_p, &me,
263	<	"No more connections allowed in your connection class");
274	>	exit_client(source_p, "No more connections allowed in your connection class");
275		break;
276
277		case NOT_AUTHORIZED:
#	Line 268 | Line 279 | check_client(struct Client *source_p)
279		/* jdc - lists server name & port connections are on */
280		/*       a purely cosmetical change */
281		sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
282	<	"Unauthorized client connection from %s [%s] on [%s/%u].",
283	<	get_client_name(source_p, SHOW_IP),
284	<	source_p->sockhost,
285	<	source_p->localClient->listener->name,
286	<	source_p->localClient->listener->port);
282	>	"Unauthorized client connection from %s [%s] on [%s/%u].",
283	>	get_client_name(source_p, SHOW_IP),
284	>	source_p->sockhost,
285	>	source_p->localClient->listener->name,
286	>	source_p->localClient->listener->port);
287		ilog(LOG_TYPE_IRCD,
288	<	"Unauthorized client connection from %s on [%s/%u].",
289	<	get_client_name(source_p, SHOW_IP),
290	<	source_p->localClient->listener->name,
291	<	source_p->localClient->listener->port);
288	>	"Unauthorized client connection from %s on [%s/%u].",
289	>	get_client_name(source_p, SHOW_IP),
290	>	source_p->localClient->listener->name,
291	>	source_p->localClient->listener->port);
292
293	<	exit_client(source_p, &me, "You are not authorized to use this server");
293	>	exit_client(source_p, "You are not authorized to use this server");
294		break;
295
296		case BANNED_CLIENT:
297	<	exit_client(source_p, &me, "Banned");
297	>	exit_client(source_p, "Banned");
298		++ServerStats.is_ref;
299		break;
300
#	Line 305 | Line 316 | static int
316		verify_access(struct Client *client_p)
317		{
318		struct MaskItem *conf = NULL;
319	<	char non_ident[USERLEN + 1] = { '~', '\0' };
319	>	char non_ident[USERLEN + 1] = "~";
320
321		if (IsGotId(client_p))
322		{
323		conf = find_address_conf(client_p->host, client_p->username,
324	<	&client_p->localClient->ip,
325	<	client_p->localClient->aftype,
324	>	&client_p->localClient->ip,
325	>	client_p->localClient->aftype,
326		client_p->localClient->passwd);
327		}
328		else
329		{
330	<	strlcpy(non_ident+1, client_p->username, sizeof(non_ident)-1);
330	>	strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
331		conf = find_address_conf(client_p->host,non_ident,
332	<	&client_p->localClient->ip,
333	<	client_p->localClient->aftype,
334	<	client_p->localClient->passwd);
332	>	&client_p->localClient->ip,
333	>	client_p->localClient->aftype,
334	>	client_p->localClient->passwd);
335		}
336
337	<	if (conf != NULL)
337	>	if (conf)
338		{
339		if (IsConfClient(conf))
340		{
341		if (IsConfRedir(conf))
342		{
343	<	sendto_one(client_p, form_str(RPL_REDIR),
344	<	me.name, client_p->name,
345	<	conf->name ? conf->name : "",
346	<	conf->port);
336	<	return(NOT_AUTHORIZED);
343	>	sendto_one_numeric(client_p, &me, RPL_REDIR,
344	>	conf->name ? conf->name : "",
345	>	conf->port);
346	>	return NOT_AUTHORIZED;
347		}
348
349		if (IsConfDoIdentd(conf))
350	<	SetNeedId(client_p);
350	>	SetNeedId(client_p);
351
352		/* Thanks for spoof idea amm */
353		if (IsConfDoSpoofIp(conf))
#	Line 347 | Line 357 | verify_access(struct Client *client_p)
357		"%s spoofing: %s as %s",
358		client_p->name, client_p->host, conf->name);
359		strlcpy(client_p->host, conf->name, sizeof(client_p->host));
360	<	SetIPSpoof(client_p);
360	>	AddFlag(client_p, FLAGS_IP_SPOOFING | FLAGS_AUTH_SPOOF);
361		}
362
363	<	return(attach_iline(client_p, conf));
363	>	return attach_iline(client_p, conf);
364		}
365		else if (IsConfKill(conf) || (ConfigFileEntry.glines && IsConfGline(conf)))
366		{
367		if (IsConfGline(conf))
368	<	sendto_one(client_p, ":%s NOTICE %s :*** G-lined", me.name,
369	<	client_p->name);
370	<	sendto_one(client_p, ":%s NOTICE %s :*** Banned: %s",
361	<	me.name, client_p->name, conf->reason);
362	<	return(BANNED_CLIENT);
368	>	sendto_one_notice(client_p, &me, ":*** G-lined");
369	>	sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
370	>	return BANNED_CLIENT;
371		}
372		}
373
374	<	return(NOT_AUTHORIZED);
374	>	return NOT_AUTHORIZED;
375		}
376
377		/* attach_iline()
#	Line 381 | Line 389 | attach_iline(struct Client *client_p, st
389		int a_limit_reached = 0;
390		unsigned int local = 0, global = 0, ident = 0;
391
392	+	assert(conf->class);
393	+
394		ip_found = find_or_add_ip(&client_p->localClient->ip);
395		ip_found->count++;
396		SetIpHash(client_p);
397
388	–	if (conf->class == NULL)
389	–	return NOT_AUTHORIZED;  /* If class is missing, this is best */
390	–
398		class = conf->class;
399
400		count_user_host(client_p->username, client_p->host,
#	Line 397 | Line 404 | attach_iline(struct Client *client_p, st
404		* setting a_limit_reached if any limit is reached.
405		* - Dianora
406		*/
407	<	if (class->max_total != 0 && class->ref_count >= class->max_total)
407	>	if (class->max_total && class->ref_count >= class->max_total)
408		a_limit_reached = 1;
409	<	else if (class->max_perip != 0 && ip_found->count > class->max_perip)
409	>	else if (class->max_perip && ip_found->count > class->max_perip)
410		a_limit_reached = 1;
411	<	else if (class->max_local != 0 && local >= class->max_local)
411	>	else if (class->max_local && local >= class->max_local)
412		a_limit_reached = 1;
413	<	else if (class->max_global != 0 && global >= class->max_global)
413	>	else if (class->max_global && global >= class->max_global)
414		a_limit_reached = 1;
415	<	else if (class->max_ident != 0 && ident >= class->max_ident &&
415	>	else if (class->max_ident && ident >= class->max_ident &&
416		client_p->username[0] != '~')
417		a_limit_reached = 1;
418
#	Line 414 | Line 421 | attach_iline(struct Client *client_p, st
421		if (!IsConfExemptLimits(conf))
422		return TOO_MANY;   /* Already at maximum allowed */
423
424	<	sendto_one(client_p,
425	<	":%s NOTICE %s :*** Your connection class is full, "
419	<	"but you have exceed_limit = yes;", me.name, client_p->name);
424	>	sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
425	>	"but you have exceed_limit = yes;");
426		}
427
428		return attach_conf(client_p, conf);
#	Line 533 | Line 539 | remove_one_ip(struct irc_ssaddr *ip_in)
539		if (ptr->count > 0)
540		ptr->count--;
541		if (ptr->count == 0 &&
542	<	(CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
542	>	(CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
543		{
544		if (last_ptr != NULL)
545	<	last_ptr->next = ptr->next;
545	>	last_ptr->next = ptr->next;
546		else
547	<	ip_hash_table[hash_index] = ptr->next;
547	>	ip_hash_table[hash_index] = ptr->next;
548
549		mp_pool_release(ptr);
550		ip_entries_count--;
#	Line 575 | Line 581 | hash_ip(struct irc_ssaddr *addr)
581		uint32_t *ip = (uint32_t *)&v6->sin6_addr.s6_addr;
582
583		hash  = ip[0] ^ ip[3];
584	<	hash ^= hash >> 16;
585	<	hash ^= hash >> 8;
584	>	hash ^= hash >> 16;
585	>	hash ^= hash >> 8;
586		hash  = hash & (IP_HASH_SIZE - 1);
587		return hash;
588		}
#	Line 587 | Line 593 | hash_ip(struct irc_ssaddr *addr)
593
594		/* count_ip_hash()
595		*
596	<	* inputs        - pointer to counter of number of ips hashed
596	>	* inputs        - pointer to counter of number of ips hashed
597		*               - pointer to memory used for ip hash
598		* output        - returned via pointers input
599		* side effects  - NONE
#	Line 599 | Line 605 | void
605		count_ip_hash(unsigned int *number_ips_stored, uint64_t *mem_ips_stored)
606		{
607		struct ip_entry *ptr;
602	–	int i;
608
609		*number_ips_stored = 0;
610		*mem_ips_stored    = 0;
611
612	<	for (i = 0; i < IP_HASH_SIZE; i++)
612	>	for (unsigned int i = 0; i < IP_HASH_SIZE; ++i)
613		{
614		for (ptr = ip_hash_table[i]; ptr; ptr = ptr->next)
615		{
#	Line 626 | Line 631 | garbage_collect_ip_entries(void)
631		struct ip_entry *ptr;
632		struct ip_entry *last_ptr;
633		struct ip_entry *next_ptr;
629	–	int i;
634
635	<	for (i = 0; i < IP_HASH_SIZE; i++)
635	>	for (unsigned int i = 0; i < IP_HASH_SIZE; ++i)
636		{
637		last_ptr = NULL;
638
#	Line 663 | Line 667 | garbage_collect_ip_entries(void)
667		void
668		detach_conf(struct Client *client_p, enum maskitem_type type)
669		{
670	<	dlink_node *ptr = NULL, *next_ptr = NULL;
670	>	dlink_node *ptr = NULL, *ptr_next = NULL;
671
672	<	DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
672	>	DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->localClient->confs.head)
673		{
674		struct MaskItem *conf = ptr->data;
675
#	Line 706 | Line 710 | detach_conf(struct Client *client_p, enu
710		int
711		attach_conf(struct Client *client_p, struct MaskItem *conf)
712		{
713	<	if (dlinkFind(&client_p->localClient->confs, conf) != NULL)
713	>	if (dlinkFind(&client_p->localClient->confs, conf))
714		return 1;
715
716		if (conf->type == CONF_CLIENT)
#	Line 775 | Line 779 | find_conf_name(dlink_list *list, const c
779		DLINK_FOREACH(ptr, list->head)
780		{
781		conf = ptr->data;
782	<
782	>
783		if (conf->type == type)
784		{
785	<	if (conf->name && (irccmp(conf->name, name) == 0 ||
785	>	if (conf->name && (!irccmp(conf->name, name) ||
786		!match(conf->name, name)))
787		return conf;
788		}
#	Line 808 | Line 812 | map_to_list(enum maskitem_type type)
812		return(&nresv_items);
813		break;
814		case CONF_CRESV:
815	<	return(&resv_channel_list);
815	>	return(&cresv_items);
816		case CONF_OPER:
817		return(&oconf_items);
818		break;
#	Line 867 | Line 871 | find_matching_name_conf(enum maskitem_ty
871		conf = ptr->data;
872
873		if (EmptyString(conf->name))
874	<	continue;
874	>	continue;
875		if ((name != NULL) && !match(conf->name, name))
876		{
877	<	if ((user == NULL && (host == NULL)))
878	<	return conf;
879	<	if ((conf->flags & flags) != flags)
877	>	if ((user == NULL && (host == NULL)))
878	>	return conf;
879	>	if ((conf->flags & flags) != flags)
880		continue;
881	<	if (EmptyString(conf->user) || EmptyString(conf->host))
882	<	return conf;
883	<	if (!match(conf->user, user) && !match(conf->host, host))
884	<	return conf;
881	>	if (EmptyString(conf->user) || EmptyString(conf->host))
882	>	return conf;
883	>	if (!match(conf->user, user) && !match(conf->host, host))
884	>	return conf;
885		}
886		}
887		break;
#	Line 893 | Line 897 | find_matching_name_conf(enum maskitem_ty
897		return conf;
898		}
899		break;
900	<
900	>
901		default:
902		break;
903		}
#	Line 929 | Line 933 | find_exact_name_conf(enum maskitem_type
933		conf = ptr->data;
934
935		if (EmptyString(conf->name))
936	<	continue;
937	<
936	>	continue;
937	>
938		if (irccmp(conf->name, name) == 0)
939		{
940	<	if ((user == NULL && (host == NULL)))
941	<	return (conf);
942	<	if (EmptyString(conf->user) || EmptyString(conf->host))
943	<	return (conf);
944	<	if (!match(conf->user, user) && !match(conf->host, host))
945	<	return (conf);
940	>	if ((user == NULL && (host == NULL)))
941	>	return conf;
942	>	if (EmptyString(conf->user) || EmptyString(conf->host))
943	>	return conf;
944	>	if (!match(conf->user, user) && !match(conf->host, host))
945	>	return conf;
946		}
947		}
948		break;
#	Line 995 | Line 999 | find_exact_name_conf(enum maskitem_type
999		conf = ptr->data;
1000
1001		if (EmptyString(conf->name))
1002	<	continue;
1003	<
1002	>	continue;
1003	>
1004		if (name == NULL)
1005		{
1006	<	if (EmptyString(conf->host))
1007	<	continue;
1008	<	if (irccmp(conf->host, host) == 0)
1009	<	return(conf);
1006	>	if (EmptyString(conf->host))
1007	>	continue;
1008	>	if (irccmp(conf->host, host) == 0)
1009	>	return conf;
1010		}
1011		else if (irccmp(conf->name, name) == 0)
1012	<	{
1009	<	return (conf);
1010	<	}
1012	>	return conf;
1013		}
1014	+
1015		break;
1016
1017		default:
1018		break;
1019		}
1020	<	return(NULL);
1020	>
1021	>	return NULL;
1022		}
1023
1024		/* rehash()
#	Line 1026 | Line 1030 | find_exact_name_conf(enum maskitem_type
1030		int
1031		rehash(int sig)
1032		{
1033	<	if (sig != 0)
1033	>	if (sig)
1034		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1035	<	"Got signal SIGHUP, reloading ircd.conf file");
1035	>	"Got signal SIGHUP, reloading configuration file(s)");
1036
1037		restart_resolver();
1038
#	Line 1039 | Line 1043 | rehash(int sig)
1043
1044		read_conf_files(0);
1045
1046	<	if (ServerInfo.description != NULL)
1046	>	if (ServerInfo.description)
1047		strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1048
1049		load_conf_modules();
1050	<
1047	<	rehashed_klines = 1;
1050	>	check_conf_klines();
1051
1052		return 0;
1053		}
#	Line 1098 | Line 1101 | set_default_conf(void)
1101		ConfigLoggingEntry.use_logging = 1;
1102
1103		ConfigChannel.disable_fake_channels = 0;
1104	<	ConfigChannel.knock_delay = 300;
1104	>	ConfigChannel.invite_client_count = 10;
1105	>	ConfigChannel.invite_client_time = 300;
1106	>	ConfigChannel.knock_client_count = 1;
1107	>	ConfigChannel.knock_client_time = 300;
1108		ConfigChannel.knock_delay_channel = 60;
1109	<	ConfigChannel.max_chans_per_user = 25;
1104	<	ConfigChannel.max_chans_per_oper = 50;
1109	>	ConfigChannel.max_channels = 25;
1110		ConfigChannel.max_bans = 25;
1111		ConfigChannel.default_split_user_count = 0;
1112		ConfigChannel.default_split_server_count = 0;
#	Line 1115 | Line 1120 | set_default_conf(void)
1120		ConfigServerHide.hide_services = 0;
1121		ConfigServerHide.hidden_name = xstrdup(NETWORK_NAME_DEFAULT);
1122		ConfigServerHide.hide_server_ips = 0;
1123	+	ConfigServerHide.disable_remote_commands = 0;
1124
1119	–
1125		ConfigFileEntry.service_name = xstrdup(SERVICE_NAME_DEFAULT);
1126		ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
1127	+	ConfigFileEntry.cycle_on_host_change = 1;
1128		ConfigFileEntry.glines = 0;
1129		ConfigFileEntry.gline_time = 12 * 3600;
1130		ConfigFileEntry.gline_request_time = GLINE_REQUEST_EXPIRE_DEFAULT;
#	Line 1129 | Line 1135 | set_default_conf(void)
1135		ConfigFileEntry.hide_spoof_ips = 1;
1136		ConfigFileEntry.ignore_bogus_ts = 0;
1137		ConfigFileEntry.disable_auth = 0;
1132	–	ConfigFileEntry.disable_remote = 0;
1138		ConfigFileEntry.kill_chase_time_limit = 90;
1139		ConfigFileEntry.default_floodcount = 8;
1140		ConfigFileEntry.failed_oper_notice = 1;
#	Line 1143 | Line 1148 | set_default_conf(void)
1148		ConfigFileEntry.anti_spam_exit_message_time = 0;
1149		ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1150		ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1151	<	ConfigFileEntry.warn_no_nline = 1;
1151	>	ConfigFileEntry.warn_no_connect_block = 1;
1152	>	ConfigFileEntry.stats_e_disabled = 0;
1153		ConfigFileEntry.stats_o_oper_only = 0;
1154	<	ConfigFileEntry.stats_k_oper_only = 1;  /* masked */
1155	<	ConfigFileEntry.stats_i_oper_only = 1;  /* masked */
1154	>	ConfigFileEntry.stats_k_oper_only = 1;  /* 1 = masked */
1155	>	ConfigFileEntry.stats_i_oper_only = 1;  /* 1 = masked */
1156		ConfigFileEntry.stats_P_oper_only = 0;
1157	+	ConfigFileEntry.stats_u_oper_only = 0;
1158		ConfigFileEntry.caller_id_wait = 60;
1159		ConfigFileEntry.opers_bypass_callerid = 0;
1160		ConfigFileEntry.pace_wait = 10;
#	Line 1159 | Line 1166 | set_default_conf(void)
1166		ConfigFileEntry.oper_pass_resv = 1;
1167		ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
1168		ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;
1169	<	ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE |
1163	<	UMODE_OPERWALL | UMODE_WALLOP;
1169	>	ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
1170		ConfigFileEntry.use_egd = 0;
1171		ConfigFileEntry.egdpool_path = NULL;
1172	+	ConfigFileEntry.throttle_count = 0;
1173		ConfigFileEntry.throttle_time = 10;
1174		}
1175
#	Line 1187 | Line 1194 | validate_conf(void)
1194		ConfigFileEntry.max_watch = IRCD_MAX(ConfigFileEntry.max_watch, WATCHSIZE_MIN);
1195		}
1196
1197	<	/* read_conf()
1197	>	/* read_conf()
1198		*
1199		* inputs       - file descriptor pointing to config file to use
1200		* output       - None
#	Line 1198 | Line 1205 | read_conf(FILE *file)
1205		{
1206		lineno = 0;
1207
1208	<	set_default_conf(); /* Set default values prior to conf parsing */
1208	>	set_default_conf();  /* Set default values prior to conf parsing */
1209		conf_parser_ctx.pass = 1;
1210	<	yyparse();          /* pick up the classes first */
1210	>	yyparse();  /* Pick up the classes first */
1211
1212		rewind(file);
1213
1214		conf_parser_ctx.pass = 2;
1215	<	yyparse();          /* Load the values from the conf */
1216	<	validate_conf();    /* Check to make sure some values are still okay. */
1217	<	/* Some global values are also loaded here. */
1218	<	class_delete_marked();      /* Make sure classes are valid */
1215	>	yyparse();  /* Load the values from the conf */
1216	>	validate_conf();  /* Check to make sure some values are still okay. */
1217	>	/* Some global values are also loaded here. */
1218	>	class_delete_marked();  /* Delete unused classes that are marked for deletion */
1219		}
1220
1221		/* lookup_confhost()
#	Line 1221 | Line 1228 | lookup_confhost(struct MaskItem *conf)
1228		{
1229		struct addrinfo hints, *res;
1230
1231	<	/* Do name lookup now on hostnames given and store the
1231	>	/*
1232	>	* Do name lookup now on hostnames given and store the
1233		* ip numbers in conf structure.
1234		*/
1235		memset(&hints, 0, sizeof(hints));
#	Line 1238 | Line 1246 | lookup_confhost(struct MaskItem *conf)
1246		return;
1247		}
1248
1249	<	assert(res != NULL);
1249	>	assert(res);
1250
1251		memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
1252		conf->addr.ss_len = res->ai_addrlen;
#	Line 1257 | Line 1265 | lookup_confhost(struct MaskItem *conf)
1265		int
1266		conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
1267		{
1268	<	struct ip_entry *ip_found;
1268	>	struct ip_entry *ip_found = NULL;
1269		struct MaskItem *conf = find_dline_conf(addr, aftype);
1270
1271		/* DLINE exempt also gets you out of static limits/pacing... */
1272		if (conf && (conf->type == CONF_EXEMPT))
1273		return 0;
1274
1275	<	if (conf != NULL)
1275	>	if (conf)
1276		return BANNED_CLIENT;
1277
1278		ip_found = find_or_add_ip(addr);
1279	+	++ip_found->connection_count;
1280
1281	<	if ((CurrentTime - ip_found->last_attempt) <
1273	<	ConfigFileEntry.throttle_time)
1281	>	if ((CurrentTime - ip_found->last_attempt) < ConfigFileEntry.throttle_time)
1282		{
1283	<	ip_found->last_attempt = CurrentTime;
1284	<	return TOO_FAST;
1283	>	if (ip_found->connection_count >= ConfigFileEntry.throttle_count)
1284	>	{
1285	>	ip_found->last_attempt = CurrentTime;
1286	>	return TOO_FAST;
1287	>	}
1288		}
1289	+	else
1290	+	ip_found->connection_count = 1;
1291
1292		ip_found->last_attempt = CurrentTime;
1293		return 0;
1294		}
1295
1283	–	/* find_kill()
1284	–	*
1285	–	* inputs       - pointer to client structure
1286	–	* output       - pointer to struct MaskItem if found
1287	–	* side effects - See if this user is klined already,
1288	–	*                and if so, return struct MaskItem pointer
1289	–	*/
1290	–	struct MaskItem *
1291	–	find_kill(struct Client *client_p)
1292	–	{
1293	–	struct MaskItem *conf = NULL;
1294	–
1295	–	assert(client_p != NULL);
1296	–
1297	–	conf = find_conf_by_address(client_p->host, &client_p->localClient->ip,
1298	–	CONF_KLINE, client_p->localClient->aftype,
1299	–	client_p->username, NULL, 1);
1300	–	return conf;
1301	–	}
1302	–
1303	–	struct MaskItem *
1304	–	find_gline(struct Client *client_p)
1305	–	{
1306	–	struct MaskItem *conf;
1307	–
1308	–	assert(client_p != NULL);
1309	–
1310	–	conf = find_conf_by_address(client_p->host, &client_p->localClient->ip,
1311	–	CONF_GLINE, client_p->localClient->aftype,
1312	–	client_p->username, NULL, 1);
1313	–	return conf;
1314	–	}
1315	–
1296		/* cleanup_tklines()
1297		*
1298		* inputs       - NONE
#	Line 1324 | Line 1304 | void
1304		cleanup_tklines(void *notused)
1305		{
1306		hostmask_expire_temporary();
1307	<	expire_tklines(&xconf_items);
1307	>	expire_tklines(&xconf_items);
1308		expire_tklines(&nresv_items);
1309	<	expire_tklines(&resv_channel_list);
1309	>	expire_tklines(&cresv_items);
1310		}
1311
1312		/* expire_tklines()
#	Line 1338 | Line 1318 | cleanup_tklines(void *notused)
1318		static void
1319		expire_tklines(dlink_list *tklist)
1320		{
1321	<	dlink_node *ptr;
1322	<	dlink_node *next_ptr;
1343	<	struct MaskItem *conf;
1321	>	dlink_node *ptr = NULL, *ptr_next = NULL;
1322	>	struct MaskItem *conf = NULL;
1323
1324	<	DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
1324	>	DLINK_FOREACH_SAFE(ptr, ptr_next, tklist->head)
1325		{
1326		conf = ptr->data;
1327
#	Line 1383 | Line 1362 | static const struct oper_privs
1362		{ OPER_FLAG_GLINE,          'G' },
1363		{ OPER_FLAG_REHASH,         'H' },
1364		{ OPER_FLAG_K,              'K' },
1386	–	{ OPER_FLAG_OPERWALL,       'L' },
1365		{ OPER_FLAG_KILL,           'N' },
1366		{ OPER_FLAG_KILL_REMOTE,    'O' },
1367		{ OPER_FLAG_CONNECT,        'P' },
#	Line 1391 | Line 1369 | static const struct oper_privs
1369		{ OPER_FLAG_SQUIT,          'R' },
1370		{ OPER_FLAG_SQUIT_REMOTE,   'S' },
1371		{ OPER_FLAG_UNKLINE,        'U' },
1372	<	{ OPER_FLAG_X,              'X' },
1372	>	{ OPER_FLAG_XLINE,          'X' },
1373		{ 0, '\0' }
1374		};
1375
1376		char *
1377		oper_privs_as_string(const unsigned int port)
1378		{
1379	<	static char privs_out[16];
1379	>	static char privs_out[IRCD_BUFSIZE];
1380		char *privs_ptr = privs_out;
1403	–	const struct oper_privs *opriv = flag_list;
1381
1382	<	for (; opriv->flag; ++opriv)
1382	>	for (const struct oper_privs *opriv = flag_list; opriv->flag; ++opriv)
1383		{
1384		if (port & opriv->flag)
1385		*privs_ptr++ = opriv->c;
#	Line 1424 | Line 1401 | oper_privs_as_string(const unsigned int
1401		const char *
1402		get_oper_name(const struct Client *client_p)
1403		{
1404	<	dlink_node *cnode = NULL;
1404	>	const dlink_node *cnode = NULL;
1405		/* +5 for !,@,{,} and null */
1406		static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
1407
#	Line 1432 | Line 1409 | get_oper_name(const struct Client *clien
1409		{
1410		if ((cnode = client_p->localClient->confs.head))
1411		{
1412	<	struct MaskItem *conf = cnode->data;
1412	>	const struct MaskItem *conf = cnode->data;
1413
1414		if (IsConfOperator(conf))
1415		{
1416	<	snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1416	>	snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1417		client_p->username, client_p->host, conf->name);
1418	<	return buffer;
1418	>	return buffer;
1419		}
1420		}
1421
1422	<	/* Probably should assert here for now. If there is an oper out there
1422	>	/* Probably should assert here for now. If there is an oper out there
1423		* with no oper{} conf attached, it would be good for us to know...
1424		*/
1425		assert(0); /* Oper without oper conf! */
1426		}
1427
1428		snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1429	<	client_p->username, client_p->host, client_p->servptr->name);
1429	>	client_p->username, client_p->host, client_p->servptr->name);
1430		return buffer;
1431		}
1432
#	Line 1462 | Line 1439 | get_oper_name(const struct Client *clien
1439		void
1440		read_conf_files(int cold)
1441		{
1442	<	const char *filename;
1443	<	char chanmodes[32];
1444	<	char chanlimit[32];
1442	>	const char *filename = NULL;
1443	>	char chanmodes[IRCD_BUFSIZE] = "";
1444	>	char chanlimit[IRCD_BUFSIZE] = "";
1445
1446		conf_parser_ctx.boot = cold;
1447		filename = ConfigFileEntry.configfile;
#	Line 1473 | Line 1450 | read_conf_files(int cold)
1450		FIXME: The full path is in conffilenamebuf first time since we
1451		dont know anything else
1452
1453	<	- Gozem 2002-07-21
1453	>	- Gozem 2002-07-21
1454		*/
1455		strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1456
#	Line 1488 | Line 1465 | read_conf_files(int cold)
1465		else
1466		{
1467		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1468	<	"Unable to read configuration file '%s': %s",
1469	<	filename, strerror(errno));
1468	>	"Unable to read configuration file '%s': %s",
1469	>	filename, strerror(errno));
1470		return;
1471		}
1472		}
#	Line 1511 | Line 1488 | read_conf_files(int cold)
1488		add_isupport("CHANTYPES", "#", -1);
1489
1490		snprintf(chanlimit, sizeof(chanlimit), "#:%d",
1491	<	ConfigChannel.max_chans_per_user);
1491	>	ConfigChannel.max_channels);
1492		add_isupport("CHANLIMIT", chanlimit, -1);
1493		snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,imnprstORS");
1494	<	add_isupport("CHANNELLEN", NULL, LOCAL_CHANNELLEN);
1494	>	add_isupport("CHANNELLEN", NULL, CHANNELLEN);
1495		add_isupport("TOPICLEN", NULL, ServerInfo.max_topic_length);
1519	–	add_isupport("EXCEPTS", "e", -1);
1520	–	add_isupport("INVEX", "I", -1);
1496		add_isupport("CHANMODES", chanmodes, -1);
1497
1498		/*
#	Line 1541 | Line 1516 | clear_out_old_conf(void)
1516		dlink_list *free_items [] = {
1517		&server_items,   &oconf_items,
1518		&uconf_items,   &xconf_items,
1519	<	&nresv_items, &cluster_items,  &service_items, &resv_channel_list, NULL
1519	>	&nresv_items, &cluster_items,  &service_items, &cresv_items, NULL
1520		};
1521
1522		dlink_list ** iterator = free_items; /* C is dumb */
#	Line 1549 | Line 1524 | clear_out_old_conf(void)
1524		/* We only need to free anything allocated by yyparse() here.
1525		* Resetting structs, etc, is taken care of by set_default_conf().
1526		*/
1527	<
1527	>
1528		for (; *iterator != NULL; iterator++)
1529		{
1530		DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
#	Line 1562 | Line 1537 | clear_out_old_conf(void)
1537		if (conf->type == CONF_SERVER || conf->type == CONF_OPER)
1538		{
1539		if (!conf->ref_count)
1540	<	conf_free(conf);
1540	>	conf_free(conf);
1541		}
1542		else if (conf->type == CONF_XLINE)
1543		{
#	Line 1574 | Line 1549 | clear_out_old_conf(void)
1549		}
1550		}
1551
1552	+	motd_clear();
1553	+
1554		/*
1555		* don't delete the class table, rather mark all entries
1556		* for deletion. The table is cleaned up by class_delete_marked. - avalon
#	Line 1595 | Line 1572 | clear_out_old_conf(void)
1572		MyFree(ConfigFileEntry.egdpool_path);
1573		ConfigFileEntry.egdpool_path = NULL;
1574		#ifdef HAVE_LIBCRYPTO
1575	<	if (ServerInfo.rsa_private_key != NULL)
1575	>	if (ServerInfo.rsa_private_key)
1576		{
1577		RSA_free(ServerInfo.rsa_private_key);
1578		ServerInfo.rsa_private_key = NULL;
#	Line 1628 | Line 1605 | clear_out_old_conf(void)
1605		/* clean out general */
1606		MyFree(ConfigFileEntry.service_name);
1607		ConfigFileEntry.service_name = NULL;
1631	–
1632	–	delete_isupport("INVEX");
1633	–	delete_isupport("EXCEPTS");
1608		}
1609
1610		/* conf_add_class_to_conf()
1611		*
1612		* inputs       - pointer to config item
1613		* output       - NONE
1614	<	* side effects - Add a class pointer to a conf
1614	>	* side effects - Add a class pointer to a conf
1615		*/
1616		void
1617		conf_add_class_to_conf(struct MaskItem *conf, const char *class_name)
1618		{
1619	<	if (class_name == NULL)
1619	>	if (class_name == NULL)
1620		{
1621		conf->class = class_default;
1622
1623		if (conf->type == CONF_CLIENT)
1624		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1625	<	"Warning *** Defaulting to default class for %s@%s",
1626	<	conf->user, conf->host);
1625	>	"Warning *** Defaulting to default class for %s@%s",
1626	>	conf->user, conf->host);
1627		else
1628		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1629	<	"Warning *** Defaulting to default class for %s",
1630	<	conf->name);
1629	>	"Warning *** Defaulting to default class for %s",
1630	>	conf->name);
1631		}
1632		else
1633		conf->class = class_find(class_name, 1);
#	Line 1662 | Line 1636 | conf_add_class_to_conf(struct MaskItem *
1636		{
1637		if (conf->type == CONF_CLIENT)
1638		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1639	<	"Warning *** Defaulting to default class for %s@%s",
1640	<	conf->user, conf->host);
1639	>	"Warning *** Defaulting to default class for %s@%s",
1640	>	conf->user, conf->host);
1641		else
1642		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1643	<	"Warning *** Defaulting to default class for %s",
1644	<	conf->name);
1643	>	"Warning *** Defaulting to default class for %s",
1644	>	conf->name);
1645		conf->class = class_default;
1646		}
1647		}
#	Line 1709 | Line 1683 | conf_error_report(const char *msg)
1683
1684		/*
1685		* valid_tkline()
1686	<	*
1686	>	*
1687		* inputs       - pointer to ascii string to check
1688		*              - whether the specified time is in seconds or minutes
1689		* output       - -1 not enough parameters
#	Line 1718 | Line 1692 | conf_error_report(const char *msg)
1692		* Originally written by Dianora (Diane, db@db.net)
1693		*/
1694		time_t
1695	<	valid_tkline(const char *p, int minutes)
1695	>	valid_tkline(const char *data, const int minutes)
1696		{
1697	+	const unsigned char *p = (const unsigned char *)data;
1698	+	unsigned char tmpch = '\0';
1699		time_t result = 0;
1700
1701	<	for (; *p; ++p)
1701	>	while ((tmpch = *p++))
1702		{
1703	<	if (!IsDigit(*p))
1703	>	if (!IsDigit(tmpch))
1704		return 0;
1705
1706		result *= 10;
1707	<	result += ((*p) & 0xF);
1707	>	result += (tmpch & 0xF);
1708		}
1709
1710		/*
1711	<	* In the degenerate case where oper does a /quote kline 0 user@host :reason
1711	>	* In the degenerate case where oper does a /quote kline 0 user@host :reason
1712		* i.e. they specifically use 0, I am going to return 1 instead
1713		* as a return value of non-zero is used to flag it as a temporary kline
1714		*/
1715		if (result == 0)
1716		result = 1;
1717
1718	<	/*
1718	>	/*
1719		* If the incoming time is in seconds convert it to minutes for the purpose
1720		* of this calculation
1721		*/
1722		if (!minutes)
1723	<	result = result / (time_t)60;
1723	>	result = result / 60;
1724
1725		if (result > MAX_TDKLINE_TIME)
1726		result = MAX_TDKLINE_TIME;
1727
1728	<	result = result * (time_t)60;  /* turn it into seconds */
1728	>	result = result * 60;  /* turn it into seconds */
1729
1730		return result;
1731		}
#	Line 1765 | Line 1741 | valid_wild_card_simple(const char *data)
1741		{
1742		const unsigned char *p = (const unsigned char *)data;
1743		unsigned char tmpch = '\0';
1744	<	int nonwild = 0;
1744	>	unsigned int nonwild = 0;
1745
1746		while ((tmpch = *p++))
1747		{
#	Line 1796 | Line 1772 | valid_wild_card_simple(const char *data)
1772		int
1773		valid_wild_card(struct Client *source_p, int warn, int count, ...)
1774		{
1775	<	char tmpch;
1776	<	int nonwild = 0;
1775	>	unsigned char tmpch = '\0';
1776	>	unsigned int nonwild = 0;
1777		va_list args;
1778
1779		/*
#	Line 1816 | Line 1792 | valid_wild_card(struct Client *source_p,
1792
1793		while (count--)
1794		{
1795	<	const char *p = va_arg(args, const char *);
1795	>	const unsigned char *p = va_arg(args, const unsigned char *);
1796		if (p == NULL)
1797		continue;
1798
#	Line 1829 | Line 1805 | valid_wild_card(struct Client *source_p,
1805		* break - no point in searching further.
1806		*/
1807		if (++nonwild >= ConfigFileEntry.min_nonwildcard)
1808	+	{
1809	+	va_end(args);
1810		return 1;
1811	+	}
1812		}
1813		}
1814		}
1815
1816		if (warn)
1817	<	sendto_one(source_p, ":%s NOTICE %s :Please include at least %d non-wildcard characters with the mask",
1818	<	me.name, source_p->name, ConfigFileEntry.min_nonwildcard);
1817	>	sendto_one_notice(source_p, &me,
1818	>	":Please include at least %d non-wildcard characters with the mask",
1819	>	ConfigFileEntry.min_nonwildcard);
1820	>	va_end(args);
1821		return 0;
1822		}
1823
#	Line 1850 | Line 1831 | valid_wild_card(struct Client *source_p,
1831		*              - parse_flags bit map of things to test
1832		*              - pointer to user or string to parse into
1833		*              - pointer to host or NULL to parse into if non NULL
1834	<	*              - pointer to optional tkline time or NULL
1834	>	*              - pointer to optional tkline time or NULL
1835		*              - pointer to target_server to parse into if non NULL
1836		*              - pointer to reason to parse into
1837		*
#	Line 1872 | Line 1853 | valid_wild_card(struct Client *source_p,
1853		*/
1854		int
1855		parse_aline(const char *cmd, struct Client *source_p,
1856	<	int parc, char **parv,
1857	<	int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1858	<	char **target_server, char **reason)
1856	>	int parc, char **parv,
1857	>	int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1858	>	char **target_server, char **reason)
1859		{
1860		int found_tkline_time=0;
1861	<	static char def_reason[] = "No Reason";
1861	>	static char def_reason[] = CONF_NOREASON;
1862		static char user[USERLEN*4+1];
1863		static char host[HOSTLEN*4+1];
1864
#	Line 1895 | Line 1876 | parse_aline(const char *cmd, struct Clie
1876		*tkline_time = found_tkline_time;
1877		else
1878		{
1879	<	sendto_one(source_p, ":%s NOTICE %s :temp_line not supported by %s",
1899	<	me.name, source_p->name, cmd);
1879	>	sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1880		return -1;
1881		}
1882		}
1883
1884		if (parc == 0)
1885		{
1886	<	sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1907	<	me.name, source_p->name, cmd);
1886	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1887		return -1;
1888		}
1889
#	Line 1918 | Line 1897 | parse_aline(const char *cmd, struct Clie
1897		*up_p = user;
1898		*h_p = host;
1899		}
1900	<
1900	>
1901		parc--;
1902		parv++;
1903
#	Line 1931 | Line 1910 | parse_aline(const char *cmd, struct Clie
1910
1911		if (target_server == NULL)
1912		{
1913	<	sendto_one(source_p, ":%s NOTICE %s :ON server not supported by %s",
1914	<	me.name, source_p->name, cmd);
1936	<	return -1;
1913	>	sendto_one_notice(source_p, &me, ":ON server not supported by %s", cmd);
1914	>	return -1;
1915		}
1916
1917		if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1918		{
1919	<	sendto_one(source_p, form_str(ERR_NOPRIVS),
1942	<	me.name, source_p->name, "remoteban");
1919	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1920		return -1;
1921		}
1922
1923		if (parc == 0 || EmptyString(*parv))
1924		{
1925	<	sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1926	<	me.name, source_p->name, cmd);
1950	<	return -1;
1925	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1926	>	return -1;
1927		}
1928
1929		*target_server = *parv;
#	Line 1960 | Line 1936 | parse_aline(const char *cmd, struct Clie
1936		* caller probably NULL'd it first, but no harm to do it again -db
1937		*/
1938		if (target_server != NULL)
1939	<	*target_server = NULL;
1939	>	*target_server = NULL;
1940		}
1941		}
1942
#	Line 1968 | Line 1944 | parse_aline(const char *cmd, struct Clie
1944		{
1945		if (strchr(user, '!') != NULL)
1946		{
1947	<	sendto_one(source_p, ":%s NOTICE %s :Invalid character '!' in kline",
1972	<	me.name, source_p->name);
1947	>	sendto_one_notice(source_p, &me, ":Invalid character '!' in kline");
1948		return -1;
1949		}
1950
#	Line 1986 | Line 1961 | parse_aline(const char *cmd, struct Clie
1961		{
1962		*reason = *parv;
1963		if (!valid_comment(source_p, *reason, 1))
1964	<	return -1;
1964	>	return -1;
1965		}
1966		else
1967		*reason = def_reason;
#	Line 2025 | Line 2000 | find_user_host(struct Client *source_p,
2000		{
2001		*(hostp++) = '\0';                       /* short and squat */
2002		if (*user_host_or_nick)
2003	<	strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
2003	>	strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
2004		else
2005	<	strcpy(luser, "*");
2005	>	strcpy(luser, "*");
2006	>
2007		if (*hostp)
2008	<	strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
2008	>	strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
2009		else
2010	<	strcpy(lhost, "*");
2010	>	strcpy(lhost, "*");
2011		}
2012		else
2013		{
2014		luser[0] = '*';             /* no @ found, assume its *@somehost */
2015	<	luser[1] = '\0';
2015	>	luser[1] = '\0';
2016		strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
2017		}
2018	<
2018	>
2019		return 1;
2020		}
2021		else
2022		{
2023		/* Try to find user@host mask from nick */
2024		/* Okay to use source_p as the first param, because source_p == client_p */
2025	<	if ((target_p =
2026	<	find_chasing(source_p, source_p, user_host_or_nick, NULL)) == NULL)
2027	<	return 0;
2025	>	if ((target_p =
2026	>	find_chasing(source_p, user_host_or_nick)) == NULL)
2027	>	return 0;  /* find_chasing sends ERR_NOSUCHNICK */
2028
2029		if (IsExemptKline(target_p))
2030		{
2031		if (!IsServer(source_p))
2032	<	sendto_one(source_p,
2057	<	":%s NOTICE %s :%s is E-lined",
2058	<	me.name, source_p->name, target_p->name);
2032	>	sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
2033		return 0;
2034		}
2035
#	Line 2116 | Line 2090 | match_conf_password(const char *password
2090		else
2091		encr = password;
2092
2093	<	return !strcmp(encr, conf->passwd);
2093	>	return encr && !strcmp(encr, conf->passwd);
2094		}
2095
2096		/*
#	Line 2124 | Line 2098 | match_conf_password(const char *password
2098		*
2099		* inputs       - client sending the cluster
2100		*              - command name "KLINE" "XLINE" etc.
2101	<	*              - capab -- CAP_KLN etc. from s_serv.h
2101	>	*              - capab -- CAP_KLN etc. from server.h
2102		*              - cluster type -- CLUSTER_KLINE etc. from conf.h
2103		*              - pattern and args to send along
2104		* output       - none
#	Line 2136 | Line 2110 | cluster_a_line(struct Client *source_p,
2110		int capab, int cluster_type, const char *pattern, ...)
2111		{
2112		va_list args;
2113	<	char buffer[IRCD_BUFSIZE];
2113	>	char buffer[IRCD_BUFSIZE] = "";
2114		const dlink_node *ptr = NULL;
2115
2116		va_start(args, pattern);
#	Line 2149 | Line 2123 | cluster_a_line(struct Client *source_p,
2123
2124		if (conf->flags & cluster_type)
2125		sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
2126	<	"%s %s %s", command, conf->name, buffer);
2126	>	"%s %s %s", command, conf->name, buffer);
2127		}
2128		}
2129
#	Line 2197 | Line 2171 | split_nuh(struct split_nuh_item *const i
2171		{
2172		*p = '\0';
2173
2174	<	if (iptr->nickptr && *iptr->nuhmask != '\0')
2174	>	if (iptr->nickptr && *iptr->nuhmask)
2175		strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
2176
2177	<	if ((q = strchr(++p, '@'))) {
2177	>	if ((q = strchr(++p, '@')))
2178	>	{
2179		*q++ = '\0';
2180
2181	<	if (*p != '\0')
2181	>	if (*p)
2182		strlcpy(iptr->userptr, p, iptr->usersize);
2183
2184	<	if (*q != '\0')
2184	>	if (*q)
2185		strlcpy(iptr->hostptr, q, iptr->hostsize);
2186		}
2187		else
2188		{
2189	<	if (*p != '\0')
2189	>	if (*p)
2190		strlcpy(iptr->userptr, p, iptr->usersize);
2191		}
2192		}
#	Line 2223 | Line 2198 | split_nuh(struct split_nuh_item *const i
2198		/* if found a @ */
2199		*p++ = '\0';
2200
2201	<	if (*iptr->nuhmask != '\0')
2201	>	if (*iptr->nuhmask)
2202		strlcpy(iptr->userptr, iptr->nuhmask, iptr->usersize);
2203
2204	<	if (*p != '\0')
2204	>	if (*p)
2205		strlcpy(iptr->hostptr, p, iptr->hostsize);
2206		}
2207		else

Diff Legend

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