ViewVC Help

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

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

Comparing:
ircd-hybrid-7.2/src/client.c (file contents), Revision 889 by michael, Thu Nov 1 12:59:05 2007 UTC vs.
ircd-hybrid-7.3/src/client.c (file contents), Revision 1143 by michael, Mon Jul 25 18:58:51 2011 UTC

#	Line 23 | Line 23
23		*/
24
25		#include "stdinc.h"
26	<	#include "tools.h"
26	>	#include "list.h"
27		#include "client.h"
28		#include "channel_mode.h"
29		#include "common.h"
#	Line 31 | Line 31
31		#include "fdlist.h"
32		#include "hash.h"
33		#include "irc_string.h"
34	–	#include "sprintf_irc.h"
34		#include "ircd.h"
36	–	#include "list.h"
35		#include "s_gline.h"
36		#include "numeric.h"
37		#include "packet.h"
#	Line 77 | Line 75 | static dlink_node *eac_next;  /* next ab
75
76		static void check_pings_list(dlink_list *);
77		static void check_unknowns_list(void);
78	<	static void ban_them(struct Client *client_p, struct ConfItem *conf);
78	>	static void ban_them(struct Client *, struct ConfItem *);
79
80
81		/* init_client()
#	Line 125 | Line 123 | make_client(struct Client *from)
123		client_p->localClient = BlockHeapAlloc(lclient_heap);
124		client_p->localClient->registration = REG_INIT;
125		/* as good a place as any... */
126	<	dlinkAdd(client_p, make_dlink_node(), &unknown_list);
126	>	dlinkAdd(client_p, &client_p->localClient->lclient_node, &unknown_list);
127		}
128		else
129		client_p->from = from; /* 'from' of local client is self! */
#	Line 264 | Line 262 | check_pings_list(dlink_list *list)
262		struct AccessItem *aconf;
263
264		conf = make_conf_item(KLINE_TYPE);
265	<	aconf = (struct AccessItem *)map_to_conf(conf);
265	>	aconf = map_to_conf(conf);
266
267		DupString(aconf->host, client_p->host);
268		DupString(aconf->reason, "idle exceeder");
#	Line 319 | Line 317 | check_pings_list(dlink_list *list)
317		get_client_name(client_p, HIDE_IP));
318		}
319
320	<	ircsprintf(scratch, "Ping timeout: %d seconds",
321	<	(int)(CurrentTime - client_p->lasttime));
320	>	snprintf(scratch, sizeof(scratch), "Ping timeout: %d seconds",
321	>	(int)(CurrentTime - client_p->lasttime));
322		exit_client(client_p, &me, scratch);
323		}
324		else if (!IsPingWarning(client_p) && pingwarn > 0 &&
#	Line 555 | Line 553 | ban_them(struct Client *client_p, struct
553		static void
554		update_client_exit_stats(struct Client *client_p)
555		{
556	<	if (IsServer(client_p))
559	<	{
560	<	sendto_realops_flags(UMODE_EXTERNAL, L_ALL,
561	<	"Server %s split from %s",
562	<	client_p->name, client_p->servptr->name);
563	<	}
564	<	else if (IsClient(client_p))
556	>	if (IsClient(client_p))
557		{
558	+	assert(Count.total > 0);
559		--Count.total;
560		if (IsOper(client_p))
561		--Count.oper;
562		if (IsInvisible(client_p))
563		--Count.invisi;
564		}
565	+	else if (IsServer(client_p))
566	+	sendto_realops_flags(UMODE_EXTERNAL, L_ALL, "Server %s split from %s",
567	+	client_p->name, client_p->servptr->name);
568
569		if (splitchecking && !splitmode)
570		check_splitmode(NULL);
#	Line 655 | Line 651 | find_chasing(struct Client *client_p, st
651		*        to modify what it points!!!
652		*/
653		const char *
654	<	get_client_name(struct Client *client, int showip)
654	>	get_client_name(const struct Client *client, int showip)
655		{
656		static char nbuf[HOSTLEN * 2 + USERLEN + 5];
657
658		assert(client != NULL);
659
660		if (irccmp(client->name, client->host) == 0)
661	<	return(client->name);
661	>	return client->name;
662
663		if (ConfigServerHide.hide_server_ips)
664		if (IsServer(client) || IsConnecting(client) || IsHandshake(client))
#	Line 678 | Line 674 | get_client_name(struct Client *client, i
674		case SHOW_IP:
675		if (MyConnect(client))
676		{
677	<	ircsprintf(nbuf, "%s[%s@%s]", client->name, client->username,
678	<	client->sockhost);
677	>	snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]",
678	>	client->name,
679	>	client->username, client->sockhost);
680		break;
681		}
682		case MASK_IP:
683	<	ircsprintf(nbuf, "%s[%s@255.255.255.255]", client->name,
684	<	client->username);
683	>	snprintf(nbuf, sizeof(nbuf), "%s[%s@255.255.255.255]",
684	>	client->name, client->username);
685		break;
686		default:
687	<	ircsprintf(nbuf, "%s[%s@%s]", client->name, client->username,
688	<	client->host);
687	>	snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]",
688	>	client->name,
689	>	client->username, client->host);
690		}
691
692	<	return(nbuf);
692	>	return nbuf;
693		}
694
695		void
#	Line 720 | Line 718 | exit_one_client(struct Client *source_p,
718
719		assert(!IsMe(source_p));
720
721	<	if (IsServer(source_p))
724	<	{
725	<	dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
726	<
727	<	if ((lp = dlinkFindDelete(&global_serv_list, source_p)) != NULL)
728	<	free_dlink_node(lp);
729	<	}
730	<	else if (IsClient(source_p))
721	>	if (IsClient(source_p))
722		{
723		if (source_p->servptr->serv != NULL)
724		dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
725
726	<	/* If a person is on a channel, send a QUIT notice
727	<	** to every client (person) on the same channel (so
728	<	** that the client can show the "**signoff" message).
729	<	** (Note: The notice is to the local clients *only*)
730	<	*/
726	>	/*
727	>	* If a person is on a channel, send a QUIT notice
728	>	* to every client (person) on the same channel (so
729	>	* that the client can show the "**signoff" message).
730	>	* (Note: The notice is to the local clients *only*)
731	>	*/
732		sendto_common_channels_local(source_p, 0, ":%s!%s@%s QUIT :%s",
733		source_p->name, source_p->username,
734		source_p->host, quitmsg);
#	Line 757 | Line 749 | exit_one_client(struct Client *source_p,
749		del_all_accepts(source_p);
750		}
751		}
752	+	else if (IsServer(source_p))
753	+	{
754	+	dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
755	+
756	+	if ((lp = dlinkFindDelete(&global_serv_list, source_p)) != NULL)
757	+	free_dlink_node(lp);
758	+	}
759
760		/* Remove source_p from the client lists */
761		if (HasID(source_p))
#	Line 796 | Line 795 | exit_one_client(struct Client *source_p,
795		static void
796		recurse_send_quits(struct Client *original_source_p, struct Client *source_p,
797		struct Client *from, struct Client *to, const char *comment,
798	<	const char *splitstr, const char *myname)
798	>	const char *splitstr)
799		{
800		dlink_node *ptr, *next;
801		struct Client *target_p;
802	<	int hidden = match(myname, source_p->name);
802	>	int hidden = match(me.name, source_p->name); /* XXX */
803
804		assert(to != source_p);  /* should be already removed from serv_list */
805
#	Line 819 | Line 818 | recurse_send_quits(struct Client *origin
818
819		DLINK_FOREACH_SAFE(ptr, next, source_p->serv->server_list.head)
820		recurse_send_quits(original_source_p, ptr->data, from, to,
821	<	comment, splitstr, myname);
821	>	comment, splitstr);
822
823		if (!hidden && ((source_p == original_source_p && to != from) ||
824		!IsCapable(to, CAP_QS)))
#	Line 860 | Line 859 | static void
859		remove_dependents(struct Client *source_p, struct Client *from,
860		const char *comment, const char *splitstr)
861		{
862	<	struct Client *to;
864	<	struct ConfItem *conf;
865	<	static char myname[HOSTLEN+1];
866	<	dlink_node *ptr;
862	>	dlink_node *ptr = NULL;
863
864		DLINK_FOREACH(ptr, serv_list.head)
865	<	{
866	<	to = ptr->data;
871	<
872	<	if ((conf = to->serv->sconf) != NULL)
873	<	strlcpy(myname, my_name_for_link(conf), sizeof(myname));
874	<	else
875	<	strlcpy(myname, me.name, sizeof(myname));
876	<	recurse_send_quits(source_p, source_p, from, to,
877	<	comment, splitstr, myname);
878	<	}
865	>	recurse_send_quits(source_p, source_p, from, ptr->data,
866	>	comment, splitstr);
867
868		recurse_remove_clients(source_p, splitstr);
869		}
#	Line 901 | Line 889 | remove_dependents(struct Client *source_
889		void
890		exit_client(struct Client *source_p, struct Client *from, const char *comment)
891		{
892	<	dlink_node *m;
892	>	dlink_node *m = NULL;
893
894		if (MyConnect(source_p))
895		{
#	Line 916 | Line 904 | exit_client(struct Client *source_p, str
904		if (IsIpHash(source_p))
905		remove_one_ip(&source_p->localClient->ip);
906
907	<	delete_auth(source_p);
907	>	if (source_p->localClient->auth)
908	>	{
909	>	delete_auth(source_p->localClient->auth);
910	>	source_p->localClient->auth = NULL;
911	>	}
912
913		/* This source_p could have status of one of STAT_UNKNOWN, STAT_CONNECTING
914		* STAT_HANDSHAKE or STAT_UNKNOWN
#	Line 926 | Line 918 | exit_client(struct Client *source_p, str
918		*/
919		if (!IsRegistered(source_p))
920		{
921	<	if ((m = dlinkFindDelete(&unknown_list, source_p)) != NULL)
922	<	free_dlink_node(m);
921	>	assert(dlinkFind(&unknown_list, source_p));
922	>
923	>	dlinkDelete(&source_p->localClient->lclient_node, &unknown_list);
924		}
925		else if (IsClient(source_p))
926		{
927	+	assert(Count.local > 0);
928		Count.local--;
929
930		if (IsOper(source_p))
#	Line 939 | Line 933 | exit_client(struct Client *source_p, str
933		free_dlink_node(m);
934		}
935
936	+	assert(dlinkFind(&local_client_list, source_p));
937		dlinkDelete(&source_p->localClient->lclient_node, &local_client_list);
938	+
939		if (source_p->localClient->list_task != NULL)
940		free_list_task(source_p->localClient->list_task, source_p);
941
#	Line 1136 | Line 1132 | dead_link_on_read(struct Client *client_
1132		strlcpy(errmsg, "Remote host closed the connection",
1133		sizeof(errmsg));
1134		else
1135	<	ircsprintf(errmsg, "Read error: %s",
1136	<	strerror(current_error));
1135	>	snprintf(errmsg, sizeof(errmsg), "Read error: %s",
1136	>	strerror(current_error));
1137
1138		exit_client(client_p, &me, errmsg);
1139		}
#	Line 1257 | Line 1253 | del_all_accepts(struct Client *client_p)
1253		del_accept(ptr->data, client_p);
1254		}
1255
1260	–	/* set_initial_nick()
1261	–	*
1262	–	* inputs
1263	–	* output
1264	–	* side effects -
1265	–	*
1266	–	* This function is only called to set up an initially registering
1267	–	* client.
1268	–	*/
1269	–	void
1270	–	set_initial_nick(struct Client *client_p, struct Client *source_p,
1271	–	const char *nick)
1272	–	{
1273	–	char buf[USERLEN + 1];
1274	–
1275	–	/* Client setting NICK the first time */
1276	–
1277	–	/* This had to be copied here to avoid problems.. */
1278	–	source_p->tsinfo = CurrentTime;
1279	–	source_p->localClient->registration &= ~REG_NEED_NICK;
1280	–
1281	–	if (source_p->name[0])
1282	–	hash_del_client(source_p);
1283	–
1284	–	strlcpy(source_p->name, nick, sizeof(source_p->name));
1285	–	hash_add_client(source_p);
1286	–
1287	–	/* fd_desc is long enough */
1288	–	fd_note(&client_p->localClient->fd, "Nick: %s", nick);
1289	–
1290	–	if (!source_p->localClient->registration)
1291	–	{
1292	–	strlcpy(buf, source_p->username, sizeof(buf));
1293	–
1294	–	/*
1295	–	* USER already received, now we have NICK.
1296	–	* *NOTE* For servers "NICK" *must* precede the
1297	–	* user message (giving USER before NICK is possible
1298	–	* only for local client connection!). register_user
1299	–	* may reject the client and call exit_client for it
1300	–	* --must test this and exit m_nick too!!!
1301	–	*/
1302	–	register_local_user(client_p, source_p, nick, buf);
1303	–	}
1304	–	}
1305	–
1256		/* change_local_nick()
1257		*
1258		* inputs       - pointer to server

Diff Legend

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