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 5347 by michael, Sun Jan 11 12:42:20 2015 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-2015 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 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;
70	>	dlink_node *node = NULL, *node_next = NULL;
71		char buff[IRCD_BUFSIZE] = "";
72
73		if ((file = fopen(LIPATH, "w")) == NULL)
74		return;
75
76	<	DLINK_FOREACH_SAFE(ptr, ptr_next, flatten_links.head)
76	>	DLINK_FOREACH_SAFE(node, node_next, flatten_links.head)
77		{
78	<	dlinkDelete(ptr, &flatten_links);
79	<	MyFree(ptr->data);
80	<	free_dlink_node(ptr);
78	>	dlinkDelete(node, &flatten_links);
79	>	MyFree(node->data);
80	>	free_dlink_node(node);
81		}
82
83	<	DLINK_FOREACH(ptr, global_serv_list.head)
83	>	DLINK_FOREACH(node, global_server_list.head)
84		{
85	<	const struct Client *target_p = ptr->data;
85	>	const struct Client *target_p = node->data;
86
87		/*
88		* Skip hidden servers, aswell as ourselves, since we already send
#	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 *node = 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(node, 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 = node->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 = node->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 254 | Line 223 | hunt_server(struct Client *source_p, con
223		void
224		try_connections(void *unused)
225		{
226	<	dlink_node *ptr = NULL;
226	>	dlink_node *node = NULL;
227		int confrq = 0;
228
229		/* TODO: change this to set active flag to 0 when added to event! --Habeeb */
230		if (GlobalSetOptions.autoconn == 0)
231		return;
232
233	<	DLINK_FOREACH(ptr, server_items.head)
233	>	DLINK_FOREACH(node, server_items.head)
234		{
235	<	struct MaskItem *conf = ptr->data;
235	>	struct MaskItem *conf = node->data;
236
237		assert(conf->type == CONF_SERVER);
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 300 | Line 269 | try_connections(void *unused)
269		if (conf->class->ref_count < conf->class->max_total)
270		{
271		/* Go to the end of the list, if not already last */
272	<	if (ptr->next)
272	>	if (node->next)
273		{
274	<	dlinkDelete(ptr, &server_items);
274	>	dlinkDelete(node, &server_items);
275		dlinkAddTail(conf, &conf->node, &server_items);
276		}
277
#	Line 355 | Line 324 | valid_servname(const char *name)
324		int
325		check_server(const char *name, struct Client *client_p)
326		{
327	<	dlink_node *ptr;
327	>	dlink_node *node = NULL;
328		struct MaskItem *conf        = NULL;
329		struct MaskItem *server_conf = NULL;
330		int error = -1;
#	Line 363 | Line 332 | check_server(const char *name, struct Cl
332		assert(client_p);
333
334		/* loop through looking for all possible connect items that might work */
335	<	DLINK_FOREACH(ptr, server_items.head)
335	>	DLINK_FOREACH(node, server_items.head)
336		{
337	<	conf = ptr->data;
337	>	conf = node->data;
338
339		if (match(name, conf->name))
340		continue;
#	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->connection->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));
379	>	memcpy(&server_conf->addr, &client_p->connection->ip, sizeof(struct irc_ssaddr));
380		break;
414	–	#endif
381		case AF_INET:
382		v4 = (struct sockaddr_in *)&server_conf->addr;
383
384		if (v4->sin_addr.s_addr == INADDR_NONE)
385	<	memcpy(&server_conf->addr, &client_p->localClient->ip, sizeof(struct irc_ssaddr));
385	>	memcpy(&server_conf->addr, &client_p->connection->ip, sizeof(struct irc_ssaddr));
386		break;
387		}
388		}
#	Line 455 | Line 421 | add_capability(const char *capab_name, i
421		int
422		delete_capability(const char *capab_name)
423		{
424	<	dlink_node *ptr = NULL, *ptr_next = NULL;
424	>	dlink_node *node = NULL, *node_next = NULL;
425
426	<	DLINK_FOREACH_SAFE(ptr, ptr_next, cap_list.head)
426	>	DLINK_FOREACH_SAFE(node, node_next, cap_list.head)
427		{
428	<	struct Capability *cap = ptr->data;
428	>	struct Capability *cap = node->data;
429
430		if (cap->cap)
431		{
432		if (!irccmp(cap->name, capab_name))
433		{
434		default_server_capabs &= ~(cap->cap);
435	<	dlinkDelete(ptr, &cap_list);
435	>	dlinkDelete(node, &cap_list);
436		MyFree(cap->name);
437		MyFree(cap);
438		}
#	Line 486 | Line 452 | delete_capability(const char *capab_name
452		unsigned int
453		find_capability(const char *capab)
454		{
455	<	const dlink_node *ptr = NULL;
455	>	const dlink_node *node = NULL;
456
457	<	DLINK_FOREACH(ptr, cap_list.head)
457	>	DLINK_FOREACH(node, cap_list.head)
458		{
459	<	const struct Capability *cap = ptr->data;
459	>	const struct Capability *cap = node->data;
460
461		if (cap->cap && !irccmp(cap->name, capab))
462		return cap->cap;
#	Line 511 | Line 477 | void
477		send_capabilities(struct Client *client_p, int cap_can_send)
478		{
479		char buf[IRCD_BUFSIZE] = "";
480	<	const dlink_node *ptr = NULL;
480	>	const dlink_node *node = NULL;
481
482	<	DLINK_FOREACH(ptr, cap_list.head)
482	>	DLINK_FOREACH(node, cap_list.head)
483		{
484	<	const struct Capability *cap = ptr->data;
484	>	const struct Capability *cap = node->data;
485
486		if (cap->cap & (cap_can_send|default_server_capabs))
487		{
488		strlcat(buf, cap->name, sizeof(buf));
489	<	if (ptr->next)
489	>	if (node->next)
490		strlcat(buf, " ", sizeof(buf));
491		}
492		}
#	Line 539 | Line 505 | const char *
505		show_capabilities(const struct Client *target_p)
506		{
507		static char msgbuf[IRCD_BUFSIZE] = "";
508	<	const dlink_node *ptr = NULL;
508	>	const dlink_node *node = NULL;
509
510		strlcpy(msgbuf, "TS", sizeof(msgbuf));
511
512	<	DLINK_FOREACH(ptr, cap_list.head)
512	>	DLINK_FOREACH(node, cap_list.head)
513		{
514	<	const struct Capability *cap = ptr->data;
514	>	const struct Capability *cap = node->data;
515
516		if (!IsCapable(target_p, cap->cap))
517		continue;
#	Line 606 | Line 572 | serv_connect(struct MaskItem *conf, stru
572		/* Make sure conf is useful */
573		assert(conf);
574
575	<	getnameinfo((struct sockaddr *)&conf->addr, conf->addr.ss_len,
575	>	getnameinfo((const struct sockaddr *)&conf->addr, conf->addr.ss_len,
576		buf, sizeof(buf), NULL, 0, NI_NUMERICHOST);
577		ilog(LOG_TYPE_IRCD, "Connect to %s[%s] @%s", conf->name, conf->host,
578		buf);
#	Line 656 | Line 622 | serv_connect(struct MaskItem *conf, stru
622		strlcpy(client_p->sockhost, buf, sizeof(client_p->sockhost));
623
624		/* create a socket for the server connection */
625	<	if (comm_open(&client_p->localClient->fd, conf->addr.ss.ss_family, SOCK_STREAM, 0, NULL) < 0)
625	>	if (comm_open(&client_p->connection->fd, conf->addr.ss.ss_family, SOCK_STREAM, 0, NULL) < 0)
626		{
627		/* Eek, failure to create the socket */
628		report_error(L_ALL, "opening stream socket to %s: %s", conf->name, errno);
#	Line 667 | Line 633 | serv_connect(struct MaskItem *conf, stru
633		}
634
635		/* servernames are always guaranteed under HOSTLEN chars */
636	<	fd_note(&client_p->localClient->fd, "Server: %s", conf->name);
636	>	fd_note(&client_p->connection->fd, "Server: %s", conf->name);
637
638		/* Attach config entries to client here rather than in
639		* serv_connect_callback(). This to avoid null pointer references.
#	Line 675 | Line 641 | serv_connect(struct MaskItem *conf, stru
641		if (!attach_connect_block(client_p, conf->name, conf->host))
642		{
643		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
644	<	"Host %s is not enabled for connecting: no connect{} block",
644	>	"Host %s is not enabled for connecting: no connect {} block",
645		conf->name);
646		if (by && IsClient(by) && !MyClient(by))
647	<	sendto_one_notice(by, &me, ":Connect to host %s failed.", client_p->name);
647	>	sendto_one_notice(by, &me, ":Connect to host %s failed: no connect {} block", client_p->name);
648
649		SetDead(client_p);
650		exit_client(client_p, "Connection failed");
#	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);
668	<	dlinkAdd(client_p, &client_p->node, &global_client_list);
703	<
704	<	client_p->localClient->aftype = conf->aftype;
668	>	client_p->connection->aftype = conf->aftype;
669
670		/* Now, initiate the connection */
671		/* XXX assume that a non 0 type means a specific bind address
#	Line 718 | Line 682 | serv_connect(struct MaskItem *conf, stru
682		ipn.ss.ss_family = AF_INET;
683		ipn.ss_port = 0;
684		memcpy(&ipn, &conf->bind, sizeof(struct irc_ssaddr));
685	<	comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port,
685	>	comm_connect_tcp(&client_p->connection->fd, conf->host, conf->port,
686		(struct sockaddr *)&ipn, ipn.ss_len,
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));
697	<	comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port,
696	>	memcpy(&ipn, &ConfigServerInfo.ip, sizeof(struct irc_ssaddr));
697	>	comm_connect_tcp(&client_p->connection->fd, conf->host, conf->port,
698		(struct sockaddr *)&ipn, ipn.ss_len,
699		serv_connect_callback, client_p, conf->aftype,
700		CONNECTTIMEOUT);
701		}
702		else
703	<	comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port,
703	>	comm_connect_tcp(&client_p->connection->fd, conf->host, conf->port,
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 756 | Line 719 | serv_connect(struct MaskItem *conf, stru
719		memcpy(&ipn, &conf->bind, sizeof(struct irc_ssaddr));
720		ipn.ss.ss_family = AF_INET6;
721		ipn.ss_port = 0;
722	<	comm_connect_tcp(&client_p->localClient->fd,
722	>	comm_connect_tcp(&client_p->connection->fd,
723		conf->host, conf->port,
724		(struct sockaddr *)&ipn, ipn.ss_len,
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,
733	>	comm_connect_tcp(&client_p->connection->fd,
734		conf->host, conf->port,
735		(struct sockaddr *)&ipn, ipn.ss_len,
736		serv_connect_callback, client_p,
737		conf->aftype, CONNECTTIMEOUT);
738		}
739		else
740	<	comm_connect_tcp(&client_p->localClient->fd,
740	>	comm_connect_tcp(&client_p->connection->fd,
741		conf->host, conf->port,
742		NULL, 0, serv_connect_callback, client_p,
743		conf->aftype, CONNECTTIMEOUT);
744		}
782	–	#endif
745		}
746	+
747		return 1;
748		}
749
#	Line 790 | Line 753 | finish_ssl_server_handshake(struct Clien
753		{
754		struct MaskItem *conf = NULL;
755
756	<	conf = find_conf_name(&client_p->localClient->confs,
756	>	conf = find_conf_name(&client_p->connection->confs,
757		client_p->name, CONF_SERVER);
758		if (conf == NULL)
759		{
#	Line 827 | Line 790 | finish_ssl_server_handshake(struct Clien
790
791		/* don't move to serv_list yet -- we haven't sent a burst! */
792		/* If we get here, we're ok, so lets start reading some data */
793	<	comm_setselect(&client_p->localClient->fd, COMM_SELECT_READ, read_packet, client_p, 0);
793	>	comm_setselect(&client_p->connection->fd, COMM_SELECT_READ, read_packet, client_p, 0);
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
803	<	if ((ret = SSL_connect(client_p->localClient->fd.ssl)) <= 0)
803	>	if ((ret = SSL_connect(client_p->connection->fd.ssl)) <= 0)
804		{
805	<	switch (SSL_get_error(client_p->localClient->fd.ssl, ret))
805	>	if ((CurrentTime - client_p->connection->firsttime) > CONNECTTIMEOUT)
806	>	{
807	>	exit_client(client_p, "Timeout during SSL handshake");
808	>	return;
809	>	}
810	>
811	>	switch (SSL_get_error(client_p->connection->fd.ssl, ret))
812		{
813		case SSL_ERROR_WANT_WRITE:
814	<	comm_setselect(&client_p->localClient->fd, COMM_SELECT_WRITE,
815	<	(PF *)ssl_server_handshake, client_p, 0);
814	>	comm_setselect(&client_p->connection->fd, COMM_SELECT_WRITE,
815	>	ssl_server_handshake, client_p, CONNECTTIMEOUT);
816		return;
817		case SSL_ERROR_WANT_READ:
818	<	comm_setselect(&client_p->localClient->fd, COMM_SELECT_READ,
819	<	(PF *)ssl_server_handshake, client_p, 0);
818	>	comm_setselect(&client_p->connection->fd, COMM_SELECT_READ,
819	>	ssl_server_handshake, client_p, CONNECTTIMEOUT);
820		return;
821		default:
822		{
#	Line 860 | Line 830 | ssl_server_handshake(fde_t *fd, struct C
830		}
831		}
832
833	<	if ((cert = SSL_get_peer_certificate(client_p->localClient->fd.ssl)))
833	>	comm_settimeout(&client_p->connection->fd, 0, NULL, NULL);
834	>
835	>	if ((cert = SSL_get_peer_certificate(client_p->connection->fd.ssl)))
836		{
837	<	int res = SSL_get_verify_result(client_p->localClient->fd.ssl);
837	>	int res = SSL_get_verify_result(client_p->connection->fd.ssl);
838		char buf[EVP_MAX_MD_SIZE * 2 + 1] = "";
839		unsigned char md[EVP_MAX_MD_SIZE] = "";
840
#	Line 872 | Line 844 | ssl_server_handshake(fde_t *fd, struct C
844		{
845		unsigned int n = 0;
846
847	<	if (X509_digest(cert, EVP_sha256(), md, &n))
847	>	if (X509_digest(cert, ConfigServerInfo.message_digest_algorithm, md, &n))
848		{
849		binary_to_hex(md, buf, n);
850		client_p->certfp = xstrdup(buf);
#	Line 890 | Line 862 | ssl_server_handshake(fde_t *fd, struct C
862		static void
863		ssl_connect_init(struct Client *client_p, struct MaskItem *conf, fde_t *fd)
864		{
865	<	if ((client_p->localClient->fd.ssl = SSL_new(ServerInfo.client_ctx)) == NULL)
865	>	if ((client_p->connection->fd.ssl = SSL_new(ConfigServerInfo.client_ctx)) == NULL)
866		{
867		ilog(LOG_TYPE_IRCD, "SSL_new() ERROR! -- %s",
868		ERR_error_string(ERR_get_error(), NULL));
#	Line 902 | Line 874 | ssl_connect_init(struct Client *client_p
874		SSL_set_fd(fd->ssl, fd->fd);
875
876		if (!EmptyString(conf->cipher_list))
877	<	SSL_set_cipher_list(client_p->localClient->fd.ssl, conf->cipher_list);
877	>	SSL_set_cipher_list(client_p->connection->fd.ssl, conf->cipher_list);
878
879		ssl_server_handshake(NULL, client_p);
880		}
#	Line 922 | Line 894 | serv_connect_callback(fde_t *fd, int sta
894		struct Client *client_p = data;
895		struct MaskItem *conf = NULL;
896
897	<	/* First, make sure its a real client! */
897	>	/* First, make sure it's a real client! */
898		assert(client_p);
899	<	assert(&client_p->localClient->fd == fd);
899	>	assert(&client_p->connection->fd == fd);
900
901		/* Next, for backward purposes, record the ip of the server */
902	<	memcpy(&client_p->localClient->ip, &fd->connect.hostaddr,
902	>	memcpy(&client_p->connection->ip, &fd->connect.hostaddr,
903		sizeof(struct irc_ssaddr));
904
905		/* Check the status */
#	Line 958 | Line 930 | serv_connect_callback(fde_t *fd, int sta
930
931		/* COMM_OK, so continue the connection procedure */
932		/* Get the C/N lines */
933	<	conf = find_conf_name(&client_p->localClient->confs,
933	>	conf = find_conf_name(&client_p->connection->confs,
934		client_p->name, CONF_SERVER);
935		if (conf == NULL)
936		{

Diff Legend

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