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 3009 by michael, Wed Feb 19 11:45:36 2014 UTC vs.
Revision 3347 by michael, Sun Apr 20 14:03:06 2014 UTC

#	Line 28 | Line 28
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"
36	–	#include "hook.h"
36		#include "irc_string.h"
37		#include "s_bsd.h"
38		#include "ircd.h"
#	Line 44 | Line 43
43		#include "fdlist.h"
44		#include "log.h"
45		#include "send.h"
47	–	#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 };
#	Line 130 | Line 129 | conf_dns_callback(void *vptr, const stru
129
130		conf->dns_pending = 0;
131
132	<	if (addr != NULL)
132	>	if (addr)
133		memcpy(&conf->addr, addr, sizeof(conf->addr));
134		else
135		conf->dns_failed = 1;
#	Line 181 | Line 180 | conf_free(struct MaskItem *conf)
180
181		if (conf->dns_pending)
182		delete_resolver_queries(conf);
183	<	if (conf->passwd != NULL)
183	>	if (conf->passwd)
184		memset(conf->passwd, 0, strlen(conf->passwd));
185	<	if (conf->spasswd != NULL)
185	>	if (conf->spasswd)
186		memset(conf->spasswd, 0, strlen(conf->spasswd));
187
188		conf->class = NULL;
#	Line 260 | Line 259 | check_client(struct Client *source_p)
259		ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
260		get_client_name(source_p, SHOW_IP));
261		++ServerStats.is_ref;
262	<	exit_client(source_p, &me, "No more connections allowed on that IP");
262	>	exit_client(source_p, "No more connections allowed on that IP");
263		break;
264
265		case I_LINE_FULL:
#	Line 271 | Line 270 | check_client(struct Client *source_p)
270		ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
271		get_client_name(source_p, SHOW_IP));
272		++ServerStats.is_ref;
273	<	exit_client(source_p, &me,
275	<	"No more connections allowed in your connection class");
273	>	exit_client(source_p, "No more connections allowed in your connection class");
274		break;
275
276		case NOT_AUTHORIZED:
#	Line 291 | Line 289 | check_client(struct Client *source_p)
289		source_p->localClient->listener->name,
290		source_p->localClient->listener->port);
291
292	<	exit_client(source_p, &me, "You are not authorized to use this server");
292	>	exit_client(source_p, "You are not authorized to use this server");
293		break;
294
295		case BANNED_CLIENT:
296	<	exit_client(source_p, &me, "Banned");
296	>	exit_client(source_p, "Banned");
297		++ServerStats.is_ref;
298		break;
299
#	Line 317 | Line 315 | static int
315		verify_access(struct Client *client_p)
316		{
317		struct MaskItem *conf = NULL;
318	<	char non_ident[USERLEN + 1] = { '~', '\0' };
318	>	char non_ident[USERLEN + 1] = "~";
319
320		if (IsGotId(client_p))
321		{
#	Line 335 | Line 333 | verify_access(struct Client *client_p)
333		client_p->localClient->passwd);
334		}
335
336	<	if (conf != NULL)
336	>	if (conf)
337		{
338		if (IsConfClient(conf))
339		{
340		if (IsConfRedir(conf))
341		{
342	<	sendto_one(client_p, form_str(RPL_REDIR),
343	<	me.name, client_p->name,
344	<	conf->name ? conf->name : "",
347	<	conf->port);
342	>	sendto_one_numeric(client_p, &me, RPL_REDIR,
343	>	conf->name ? conf->name : "",
344	>	conf->port);
345		return NOT_AUTHORIZED;
346		}
347
#	Line 367 | Line 364 | verify_access(struct Client *client_p)
364		else if (IsConfKill(conf) || (ConfigFileEntry.glines && IsConfGline(conf)))
365		{
366		if (IsConfGline(conf))
367	<	sendto_one(client_p, ":%s NOTICE %s :*** G-lined", me.name,
368	<	client_p->name);
372	<	sendto_one(client_p, ":%s NOTICE %s :*** Banned: %s",
373	<	me.name, client_p->name, conf->reason);
367	>	sendto_one_notice(client_p, &me, ":*** G-lined");
368	>	sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
369		return BANNED_CLIENT;
370		}
371		}
#	Line 425 | Line 420 | attach_iline(struct Client *client_p, st
420		if (!IsConfExemptLimits(conf))
421		return TOO_MANY;   /* Already at maximum allowed */
422
423	<	sendto_one(client_p,
424	<	":%s NOTICE %s :*** Your connection class is full, "
430	<	"but you have exceed_limit = yes;", me.name, client_p->name);
423	>	sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
424	>	"but you have exceed_limit = yes;");
425		}
426
427		return attach_conf(client_p, conf);
#	Line 674 | Line 668 | garbage_collect_ip_entries(void)
668		void
669		detach_conf(struct Client *client_p, enum maskitem_type type)
670		{
671	<	dlink_node *ptr = NULL, *next_ptr = NULL;
671	>	dlink_node *ptr = NULL, *ptr_next = NULL;
672
673	<	DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
673	>	DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->localClient->confs.head)
674		{
675		struct MaskItem *conf = ptr->data;
676
#	Line 717 | Line 711 | detach_conf(struct Client *client_p, enu
711		int
712		attach_conf(struct Client *client_p, struct MaskItem *conf)
713		{
714	<	if (dlinkFind(&client_p->localClient->confs, conf) != NULL)
714	>	if (dlinkFind(&client_p->localClient->confs, conf))
715		return 1;
716
717		if (conf->type == CONF_CLIENT)
#	Line 1037 | Line 1031 | find_exact_name_conf(enum maskitem_type
1031		int
1032		rehash(int sig)
1033		{
1034	<	if (sig != 0)
1034	>	if (sig)
1035		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1036		"Got signal SIGHUP, reloading configuration file(s)");
1037
#	Line 1050 | Line 1044 | rehash(int sig)
1044
1045		read_conf_files(0);
1046
1047	<	if (ServerInfo.description != NULL)
1047	>	if (ServerInfo.description)
1048		strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1049
1050		load_conf_modules();
#	Line 1250 | Line 1244 | lookup_confhost(struct MaskItem *conf)
1244		return;
1245		}
1246
1247	<	assert(res != NULL);
1247	>	assert(res);
1248
1249		memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
1250		conf->addr.ss_len = res->ai_addrlen;
#	Line 1276 | Line 1270 | conf_connect_allowed(struct irc_ssaddr *
1270		if (conf && (conf->type == CONF_EXEMPT))
1271		return 0;
1272
1273	<	if (conf != NULL)
1273	>	if (conf)
1274		return BANNED_CLIENT;
1275
1276		ip_found = find_or_add_ip(addr);
#	Line 1317 | Line 1311 | cleanup_tklines(void *notused)
1311		static void
1312		expire_tklines(dlink_list *tklist)
1313		{
1314	<	dlink_node *ptr;
1315	<	dlink_node *next_ptr;
1322	<	struct MaskItem *conf;
1314	>	dlink_node *ptr = NULL, *ptr_next = NULL;
1315	>	struct MaskItem *conf = NULL;
1316
1317	<	DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
1317	>	DLINK_FOREACH_SAFE(ptr, ptr_next, tklist->head)
1318		{
1319		conf = ptr->data;
1320
#	Line 1379 | Line 1372 | oper_privs_as_string(const unsigned int
1372		{
1373		static char privs_out[IRCD_BUFSIZE];
1374		char *privs_ptr = privs_out;
1382	–	const struct oper_privs *opriv = flag_list;
1375
1376	<	for (; opriv->flag; ++opriv)
1376	>	for (const struct oper_privs *opriv = flag_list; opriv->flag; ++opriv)
1377		{
1378		if (port & opriv->flag)
1379		*privs_ptr++ = opriv->c;
#	Line 1574 | Line 1566 | clear_out_old_conf(void)
1566		MyFree(ConfigFileEntry.egdpool_path);
1567		ConfigFileEntry.egdpool_path = NULL;
1568		#ifdef HAVE_LIBCRYPTO
1569	<	if (ServerInfo.rsa_private_key != NULL)
1569	>	if (ServerInfo.rsa_private_key)
1570		{
1571		RSA_free(ServerInfo.rsa_private_key);
1572		ServerInfo.rsa_private_key = NULL;
#	Line 1816 | Line 1808 | valid_wild_card(struct Client *source_p,
1808		}
1809
1810		if (warn)
1811	<	sendto_one(source_p, ":%s NOTICE %s :Please include at least %d non-wildcard characters with the mask",
1812	<	me.name, source_p->name, ConfigFileEntry.min_nonwildcard);
1811	>	sendto_one_notice(source_p, &me,
1812	>	":Please include at least %d non-wildcard characters with the mask",
1813	>	ConfigFileEntry.min_nonwildcard);
1814		va_end(args);
1815		return 0;
1816		}
#	Line 1877 | Line 1870 | parse_aline(const char *cmd, struct Clie
1870		*tkline_time = found_tkline_time;
1871		else
1872		{
1873	<	sendto_one(source_p, ":%s NOTICE %s :temp_line not supported by %s",
1881	<	me.name, source_p->name, cmd);
1873	>	sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1874		return -1;
1875		}
1876		}
1877
1878		if (parc == 0)
1879		{
1880	<	sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1889	<	me.name, source_p->name, cmd);
1880	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1881		return -1;
1882		}
1883
#	Line 1913 | Line 1904 | parse_aline(const char *cmd, struct Clie
1904
1905		if (target_server == NULL)
1906		{
1907	<	sendto_one(source_p, ":%s NOTICE %s :ON server not supported by %s",
1917	<	me.name, source_p->name, cmd);
1907	>	sendto_one_notice(source_p, &me, ":ON server not supported by %s", cmd);
1908		return -1;
1909		}
1910
1911		if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1912		{
1913	<	sendto_one(source_p, form_str(ERR_NOPRIVS),
1924	<	me.name, source_p->name, "remoteban");
1913	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1914		return -1;
1915		}
1916
1917		if (parc == 0 || EmptyString(*parv))
1918		{
1919	<	sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1931	<	me.name, source_p->name, cmd);
1919	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1920		return -1;
1921		}
1922
#	Line 1950 | Line 1938 | parse_aline(const char *cmd, struct Clie
1938		{
1939		if (strchr(user, '!') != NULL)
1940		{
1941	<	sendto_one(source_p, ":%s NOTICE %s :Invalid character '!' in kline",
1954	<	me.name, source_p->name);
1941	>	sendto_one_notice(source_p, &me, ":Invalid character '!' in kline");
1942		return -1;
1943		}
1944
#	Line 2030 | Line 2017 | find_user_host(struct Client *source_p,
2017		/* Try to find user@host mask from nick */
2018		/* Okay to use source_p as the first param, because source_p == client_p */
2019		if ((target_p =
2020	<	find_chasing(source_p, user_host_or_nick, NULL)) == NULL)
2020	>	find_chasing(source_p, user_host_or_nick)) == NULL)
2021		return 0;
2022
2023		if (IsExemptKline(target_p))
2024		{
2025		if (!IsServer(source_p))
2026	<	sendto_one(source_p,
2040	<	":%s NOTICE %s :%s is E-lined",
2041	<	me.name, source_p->name, target_p->name);
2026	>	sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
2027		return 0;
2028		}
2029
#	Line 2099 | Line 2084 | match_conf_password(const char *password
2084		else
2085		encr = password;
2086
2087	<	return !strcmp(encr, conf->passwd);
2087	>	return encr && !strcmp(encr, conf->passwd);
2088		}
2089
2090		/*
#	Line 2107 | Line 2092 | match_conf_password(const char *password
2092		*
2093		* inputs       - client sending the cluster
2094		*              - command name "KLINE" "XLINE" etc.
2095	<	*              - capab -- CAP_KLN etc. from s_serv.h
2095	>	*              - capab -- CAP_KLN etc. from server.h
2096		*              - cluster type -- CLUSTER_KLINE etc. from conf.h
2097		*              - pattern and args to send along
2098		* output       - none

Diff Legend

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