ViewVC Help

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

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

Comparing ircd-hybrid/trunk/src/server.c (file contents):
Revision 4113 by michael, Tue Jul 1 16:02:52 2014 UTC vs.
Revision 4464 by michael, Wed Aug 13 17:28:00 2014 UTC

#	Line 52 | Line 52
52
53		dlink_list flatten_links;
54		static dlink_list cap_list = { NULL, NULL, 0 };
55	<	static CNCB serv_connect_callback;
55	>	static void serv_connect_callback(fde_t *, int, void *);
56
57
58		/*
#	Line 64 | Line 64 | static CNCB serv_connect_callback;
64		*                but in no particular order.
65		*/
66		void
67	<	write_links_file(void *notused)
67	>	write_links_file(void *unused)
68		{
69		FILE *file = NULL;
70		dlink_node *ptr = NULL, *ptr_next = NULL;
#	Line 80 | Line 80 | write_links_file(void *notused)
80		free_dlink_node(ptr);
81		}
82
83	<	DLINK_FOREACH(ptr, global_serv_list.head)
83	>	DLINK_FOREACH(ptr, global_server_list.head)
84		{
85		const struct Client *target_p = ptr->data;
86
#	Line 157 | Line 157 | hunt_server(struct Client *source_p, con
157		const int server, const int parc, char *parv[])
158		{
159		struct Client *target_p = NULL;
160	<	struct Client *target_tmp = NULL;
161	<	dlink_node *ptr;
160	>	dlink_node *ptr = NULL;
161
162		/* Assume it's me, if no server */
163		if (parc <= server || EmptyString(parv[server]))
164		return HUNTED_ISME;
165
166	<	if (!strcmp(parv[server], me.id) || !match(parv[server], me.name))
167	<	return HUNTED_ISME;
166	>	if ((target_p = find_person(source_p, parv[server])) == NULL)
167	>	target_p = hash_find_server(parv[server]);
168
169	<	/* These are to pickup matches that would cause the following
169	>	/*
170	>	* These are to pickup matches that would cause the following
171		* message to go in the wrong direction while doing quick fast
172		* non-matching lookups.
173		*/
174	–	if (MyClient(source_p))
175	–	target_p = hash_find_client(parv[server]);
176	–	else
177	–	target_p = find_person(source_p, parv[server]);
178	–
174		if (target_p)
175		if (target_p->from == source_p->from && !MyConnect(target_p))
176		target_p = NULL;
177
178	<	if (target_p == NULL && (target_p = hash_find_server(parv[server])))
184	<	if (target_p->from == source_p->from && !MyConnect(target_p))
185	<	target_p = NULL;
186	<
187	<	/* Again, if there are no wild cards involved in the server
188	<	* name, use the hash lookup
189	<	*/
190	<	if (target_p == NULL)
178	>	if (!target_p && has_wildcards(parv[server]))
179		{
180	<	if (!has_wildcards(parv[server]))
180	>	DLINK_FOREACH(ptr, global_client_list.head)
181		{
182	<	if (!(target_p = hash_find_server(parv[server])))
195	<	{
196	<	sendto_one_numeric(source_p, &me, ERR_NOSUCHSERVER, parv[server]);
197	<	return HUNTED_NOSUCH;
198	<	}
199	<	}
200	<	else
201	<	{
202	<	DLINK_FOREACH(ptr, global_client_list.head)
203	<	{
204	<	target_tmp = ptr->data;
182	>	struct Client *tmp = ptr->data;
183
184	<	if (!match(parv[server], target_tmp->name))
185	<	{
186	<	if (target_tmp->from == source_p->from && !MyConnect(target_tmp))
187	<	continue;
188	<	target_p = ptr->data;
184	>	assert(IsMe(tmp) || IsServer(tmp) || IsClient(tmp));
185	>	if (!match(parv[server], tmp->name))
186	>	{
187	>	if (tmp->from == source_p->from && !MyConnect(tmp))
188	>	continue;
189
190	<	if (IsRegistered(target_p) && (target_p != source_p->from))
191	<	break;
214	<	}
190	>	target_p = ptr->data;
191	>	break;
192		}
193		}
194		}
195
196		if (target_p)
197		{
198	<	if (!IsRegistered(target_p))
222	<	{
223	<	sendto_one_numeric(source_p, &me, ERR_NOSUCHSERVER, parv[server]);
224	<	return HUNTED_NOSUCH;
225	<	}
226	<
198	>	assert(IsMe(target_p) || IsServer(target_p) || IsClient(target_p));
199		if (IsMe(target_p) || MyClient(target_p))
200		return HUNTED_ISME;
201
202	<	if (match(target_p->name, parv[server]))
203	<	parv[server] = target_p->name;
232	<
233	<	/* This is a little kludgy but should work... */
234	<	sendto_one(target_p, command, ID_or_name(source_p, target_p),
202	>	parv[server] = target_p->id;
203	>	sendto_one(target_p, command, source_p->id,
204		parv[1], parv[2], parv[3], parv[4],
205		parv[5], parv[6], parv[7], parv[8]);
206		return HUNTED_PASS;
#	Line 269 | Line 238 | try_connections(void *unused)
238
239		/* Also when already connecting! (update holdtimes) --SRB
240		*/
241	<	if (!conf->port ||!IsConfAllowAutoConn(conf))
241	>	if (!conf->port || !IsConfAllowAutoConn(conf))
242		continue;
243
244
#	Line 379 | Line 348 | check_server(const char *name, struct Cl
348		{
349		error = -2;
350
351	<	if (!match_conf_password(client_p->localClient->passwd, conf))
351	>	if (!match_conf_password(client_p->localClient->password, conf))
352		return -2;
353
354		if (!EmptyString(conf->certfp))
#	Line 399 | Line 368 | check_server(const char *name, struct Cl
368		if (server_conf)
369		{
370		struct sockaddr_in *v4;
402	–	#ifdef IPV6
371		struct sockaddr_in6 *v6;
372	<	#endif
372	>
373		switch (server_conf->aftype)
374		{
407	–	#ifdef IPV6
375		case AF_INET6:
376		v6 = (struct sockaddr_in6 *)&server_conf->addr;
377
378		if (IN6_IS_ADDR_UNSPECIFIED(&v6->sin6_addr))
379		memcpy(&server_conf->addr, &client_p->localClient->ip, sizeof(struct irc_ssaddr));
380		break;
414	–	#endif
381		case AF_INET:
382		v4 = (struct sockaddr_in *)&server_conf->addr;
383
#	Line 699 | Line 665 | serv_connect(struct MaskItem *conf, stru
665		strlcpy(client_p->serv->by, "AutoConn.", sizeof(client_p->serv->by));
666
667		SetConnecting(client_p);
702	–	dlinkAdd(client_p, &client_p->node, &global_client_list);
703	–
668		client_p->localClient->aftype = conf->aftype;
669
670		/* Now, initiate the connection */
#	Line 723 | Line 687 | serv_connect(struct MaskItem *conf, stru
687		serv_connect_callback, client_p, conf->aftype,
688		CONNECTTIMEOUT);
689		}
690	<	else if (ServerInfo.specific_ipv4_vhost)
690	>	else if (ConfigServerInfo.specific_ipv4_vhost)
691		{
692		struct irc_ssaddr ipn;
693		memset(&ipn, 0, sizeof(struct irc_ssaddr));
694		ipn.ss.ss_family = AF_INET;
695		ipn.ss_port = 0;
696	<	memcpy(&ipn, &ServerInfo.ip, sizeof(struct irc_ssaddr));
696	>	memcpy(&ipn, &ConfigServerInfo.ip, sizeof(struct irc_ssaddr));
697		comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port,
698		(struct sockaddr *)&ipn, ipn.ss_len,
699		serv_connect_callback, client_p, conf->aftype,
#	Line 740 | Line 704 | serv_connect(struct MaskItem *conf, stru
704		NULL, 0, serv_connect_callback, client_p, conf->aftype,
705		CONNECTTIMEOUT);
706		break;
743	–	#ifdef IPV6
707		case AF_INET6:
708		{
709		struct irc_ssaddr ipn;
#	Line 762 | Line 725 | serv_connect(struct MaskItem *conf, stru
725		serv_connect_callback, client_p,
726		conf->aftype, CONNECTTIMEOUT);
727		}
728	<	else if (ServerInfo.specific_ipv6_vhost)
728	>	else if (ConfigServerInfo.specific_ipv6_vhost)
729		{
730	<	memcpy(&ipn, &ServerInfo.ip6, sizeof(struct irc_ssaddr));
730	>	memcpy(&ipn, &ConfigServerInfo.ip6, sizeof(struct irc_ssaddr));
731		ipn.ss.ss_family = AF_INET6;
732		ipn.ss_port = 0;
733		comm_connect_tcp(&client_p->localClient->fd,
#	Line 779 | Line 742 | serv_connect(struct MaskItem *conf, stru
742		NULL, 0, serv_connect_callback, client_p,
743		conf->aftype, CONNECTTIMEOUT);
744		}
782	–	#endif
745		}
746	+
747		return 1;
748		}
749
#	Line 831 | Line 794 | finish_ssl_server_handshake(struct Clien
794		}
795
796		static void
797	<	ssl_server_handshake(fde_t *fd, struct Client *client_p)
797	>	ssl_server_handshake(fde_t *fd, void *data)
798		{
799	+	struct Client *client_p = data;
800		X509 *cert = NULL;
801		int ret = 0;
802
#	Line 842 | Line 806 | ssl_server_handshake(fde_t *fd, struct C
806		{
807		case SSL_ERROR_WANT_WRITE:
808		comm_setselect(&client_p->localClient->fd, COMM_SELECT_WRITE,
809	<	(PF *)ssl_server_handshake, client_p, 0);
809	>	ssl_server_handshake, client_p, 0);
810		return;
811		case SSL_ERROR_WANT_READ:
812		comm_setselect(&client_p->localClient->fd, COMM_SELECT_READ,
813	<	(PF *)ssl_server_handshake, client_p, 0);
813	>	ssl_server_handshake, client_p, 0);
814		return;
815		default:
816		{
#	Line 872 | Line 836 | ssl_server_handshake(fde_t *fd, struct C
836		{
837		unsigned int n = 0;
838
839	<	if (X509_digest(cert, EVP_sha256(), md, &n))
839	>	if (X509_digest(cert, ConfigServerInfo.message_digest_algorithm, md, &n))
840		{
841		binary_to_hex(md, buf, n);
842		client_p->certfp = xstrdup(buf);
#	Line 890 | Line 854 | ssl_server_handshake(fde_t *fd, struct C
854		static void
855		ssl_connect_init(struct Client *client_p, struct MaskItem *conf, fde_t *fd)
856		{
857	<	if ((client_p->localClient->fd.ssl = SSL_new(ServerInfo.client_ctx)) == NULL)
857	>	if ((client_p->localClient->fd.ssl = SSL_new(ConfigServerInfo.client_ctx)) == NULL)
858		{
859		ilog(LOG_TYPE_IRCD, "SSL_new() ERROR! -- %s",
860		ERR_error_string(ERR_get_error(), NULL));
#	Line 922 | Line 886 | serv_connect_callback(fde_t *fd, int sta
886		struct Client *client_p = data;
887		struct MaskItem *conf = NULL;
888
889	<	/* First, make sure its a real client! */
889	>	/* First, make sure it's a real client! */
890		assert(client_p);
891		assert(&client_p->localClient->fd == fd);
892

Diff Legend

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