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 4588 by michael, Tue Aug 26 15:59:07 2014 UTC

#	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;
#	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->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 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 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	>	switch (SSL_get_error(client_p->connection->fd.ssl, ret))
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);
808	>	comm_setselect(&client_p->connection->fd, COMM_SELECT_WRITE,
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);
812	>	comm_setselect(&client_p->connection->fd, COMM_SELECT_READ,
813	>	ssl_server_handshake, client_p, 0);
814		return;
815		default:
816		{
#	Line 860 | Line 824 | ssl_server_handshake(fde_t *fd, struct C
824		}
825		}
826
827	<	if ((cert = SSL_get_peer_certificate(client_p->localClient->fd.ssl)))
827	>	if ((cert = SSL_get_peer_certificate(client_p->connection->fd.ssl)))
828		{
829	<	int res = SSL_get_verify_result(client_p->localClient->fd.ssl);
829	>	int res = SSL_get_verify_result(client_p->connection->fd.ssl);
830		char buf[EVP_MAX_MD_SIZE * 2 + 1] = "";
831		unsigned char md[EVP_MAX_MD_SIZE] = "";
832
#	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->connection->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 902 | Line 866 | ssl_connect_init(struct Client *client_p
866		SSL_set_fd(fd->ssl, fd->fd);
867
868		if (!EmptyString(conf->cipher_list))
869	<	SSL_set_cipher_list(client_p->localClient->fd.ssl, conf->cipher_list);
869	>	SSL_set_cipher_list(client_p->connection->fd.ssl, conf->cipher_list);
870
871		ssl_server_handshake(NULL, client_p);
872		}
#	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);
891	>	assert(&client_p->connection->fd == fd);
892
893		/* Next, for backward purposes, record the ip of the server */
894	<	memcpy(&client_p->localClient->ip, &fd->connect.hostaddr,
894	>	memcpy(&client_p->connection->ip, &fd->connect.hostaddr,
895		sizeof(struct irc_ssaddr));
896
897		/* Check the status */
#	Line 958 | Line 922 | serv_connect_callback(fde_t *fd, int sta
922
923		/* COMM_OK, so continue the connection procedure */
924		/* Get the C/N lines */
925	<	conf = find_conf_name(&client_p->localClient->confs,
925	>	conf = find_conf_name(&client_p->connection->confs,
926		client_p->name, CONF_SERVER);
927		if (conf == NULL)
928		{

Diff Legend

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