ViewVC Help

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

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

Comparing ircd-hybrid-8/src/send.c (file contents):
Revision 1206 by michael, Wed Aug 24 21:41:23 2011 UTC vs.
Revision 1474 by michael, Sun Jul 22 14:44:07 2012 UTC

#	Line 27 | Line 27
27		#include "send.h"
28		#include "channel.h"
29		#include "client.h"
30	–	#include "common.h"
30		#include "dbuf.h"
31		#include "irc_string.h"
32		#include "ircd.h"
34	–	#include "handlers.h"
33		#include "numeric.h"
34		#include "fdlist.h"
35		#include "s_bsd.h"
36		#include "s_serv.h"
37		#include "sprintf_irc.h"
38	<	#include "s_conf.h"
39	<	#include "s_log.h"
38	>	#include "conf.h"
39	>	#include "log.h"
40		#include "memory.h"
41		#include "hook.h"
42		#include "packet.h"
43
44
45		struct Callback *iosend_cb = NULL;
48	–	struct Callback *iosendctrl_cb = NULL;
46		static unsigned int current_serial = 0;
47
48
#	Line 180 | Line 177 | send_message_remote(struct Client *to, s
177		from->name, from->username, from->host,
178		to->from->name);
179
180	<	sendto_server(NULL, NULL, CAP_TS6, NOCAPS,
180	>	sendto_server(NULL, CAP_TS6, NOCAPS,
181		":%s KILL %s :%s (%s[%s@%s] Ghosted %s)",
182		me.id, to->name, me.name, to->name,
183		to->username, to->host, to->from->name);
184	<	sendto_server(NULL, NULL, NOCAPS, CAP_TS6,
184	>	sendto_server(NULL, NOCAPS, CAP_TS6,
185		":%s KILL %s :%s (%s[%s@%s] Ghosted %s)",
186		me.name, to->name, me.name, to->name,
187		to->username, to->host, to->from->name);
188
189	<	SetKilled(to);
189	>	AddFlag(to, FLAGS_KILLED);
190
191		if (IsClient(from))
192		sendto_one(from, form_str(ERR_GHOSTEDCLIENT),
#	Line 224 | Line 221 | sendq_unblocked(fde_t *fd, struct Client
221		}
222
223		/*
227	–	** slinkq_unblocked
228	–	**      Called when a server control socket is ready for writing.
229	–	*/
230	–	static void
231	–	slinkq_unblocked(fde_t *fd, struct Client *client_p)
232	–	{
233	–	ClearSlinkqBlocked(client_p);
234	–	send_queued_slink_write(client_p);
235	–	}
236	–
237	–	/*
224		** send_queued_write
225		**      This is called when there is a chance that some output would
226		**      be possible. This attempts to empty the send queue as far as
#	Line 312 | Line 298 | send_queued_write(struct Client *to)
298		}
299		}
300
315	–	/*
316	–	** send_queued_slink_write
317	–	**      This is called when there is a chance the some output would
318	–	**      be possible. This attempts to empty the send queue as far as
319	–	**      possible, and then if any data is left, a write is rescheduled.
320	–	*/
321	–	void
322	–	send_queued_slink_write(struct Client *to)
323	–	{
324	–	int retlen;
325	–
326	–	/*
327	–	** Once socket is marked dead, we cannot start writing to it,
328	–	** even if the error is removed...
329	–	*/
330	–	if (IsDead(to) || IsSlinkqBlocked(to))
331	–	return;  /* no use calling send() now */
332	–
333	–	/* Next, lets try to write some data */
334	–	if (to->localClient->slinkq != NULL)
335	–	{
336	–	retlen = send(to->localClient->ctrlfd.fd,
337	–	to->localClient->slinkq + to->localClient->slinkq_ofs,
338	–	to->localClient->slinkq_len, 0);
339	–	if (retlen < 0)
340	–	{
341	–	/* If we have a fatal error */
342	–	if (!ignoreErrno(errno))
343	–	{
344	–	dead_link_on_write(to, errno);
345	–	return;
346	–	}
347	–	}
348	–	else if (retlen == 0)
349	–	{
350	–	/* 0 bytes is an EOF .. */
351	–	dead_link_on_write(to, 0);
352	–	return;
353	–	}
354	–	else
355	–	{
356	–	execute_callback(iosendctrl_cb, to, retlen,
357	–	to->localClient->slinkq + to->localClient->slinkq_ofs);
358	–	to->localClient->slinkq_len -= retlen;
359	–
360	–	assert(to->localClient->slinkq_len >= 0);
361	–	if (to->localClient->slinkq_len)
362	–	to->localClient->slinkq_ofs += retlen;
363	–	else
364	–	{
365	–	to->localClient->slinkq_ofs = 0;
366	–	MyFree(to->localClient->slinkq);
367	–	to->localClient->slinkq = NULL;
368	–	}
369	–	}
370	–
371	–	/* Finally, if we have any more data, reschedule a write */
372	–	if (to->localClient->slinkq_len)
373	–	{
374	–	SetSlinkqBlocked(to);
375	–	comm_setselect(&to->localClient->ctrlfd, COMM_SELECT_WRITE,
376	–	(PF *)slinkq_unblocked, (void *)to, 0);
377	–	}
378	–	}
379	–	}
380	–
301		/* send_queued_all()
302		*
303		* input        - NONE
#	Line 491 | Line 411 | sendto_channel_butone(struct Client *one
411
412		assert(IsClient(target_p));
413
414	<	if (IsDefunct(target_p) || IsDeaf(target_p) || target_p->from == one)
414	>	if (IsDefunct(target_p) || HasUMode(target_p, UMODE_DEAF) || target_p->from == one)
415		continue;
416
417		if (MyConnect(target_p))
#	Line 538 | Line 458 | sendto_channel_butone(struct Client *one
458		* -davidt
459		*/
460		void
461	<	sendto_server(struct Client *one, const struct Channel *chptr,
461	>	sendto_server(struct Client *one,
462		const unsigned int caps,
463		const unsigned int nocaps,
464		const char *format, ...)
#	Line 548 | Line 468 | sendto_server(struct Client *one, const
468		char buffer[IRCD_BUFSIZE];
469		int len = 0;
470
551	–	if (chptr && chptr->chname[0] != '#')
552	–	return;
553	–
471		va_start(args, format);
472		len = send_format(buffer, IRCD_BUFSIZE, format, args);
473		va_end(args);
#	Line 663 | Line 580 | sendto_channel_local(int type, int nodea
580		continue;
581
582		if (!MyConnect(target_p) || IsDefunct(target_p) ||
583	<	(nodeaf && IsDeaf(target_p)))
583	>	(nodeaf && HasUMode(target_p, UMODE_DEAF)))
584		continue;
585
586		send_message(target_p, buffer, len);
#	Line 706 | Line 623 | sendto_channel_local_butone(struct Clien
623		continue;
624
625		if (!MyConnect(target_p) || target_p == one ||
626	<	IsDefunct(target_p) || IsDeaf(target_p))
626	>	IsDefunct(target_p) || HasUMode(target_p, UMODE_DEAF))
627		continue;
628		send_message(target_p, buffer, len);
629		}
#	Line 985 | Line 902 | sendto_realops_flags(unsigned int flags,
902		DLINK_FOREACH(ptr, oper_list.head)
903		{
904		struct Client *client_p = ptr->data;
905	<	assert(client_p->umodes & UMODE_OPER);
905	>	assert(HasUMode(client_p, UMODE_OPER));
906
907		/* If we're sending it to opers and theyre an admin, skip.
908		* If we're sending it to admins, and theyre not, skip.
909		*/
910	<	if (((level == L_ADMIN) && !IsAdmin(client_p)) ||
911	<	((level == L_OPER) && IsAdmin(client_p)))
910	>	if (((level == L_ADMIN) && !HasUMode(client_p, UMODE_ADMIN)) ||
911	>	((level == L_OPER) && HasUMode(client_p, UMODE_ADMIN)))
912		continue;
913
914	<	if (client_p->umodes & flags)
914	>	if (HasUMode(client_p, flags))
915		sendto_one(client_p, ":%s NOTICE %s :*** Notice -- %s",
916		me.name, client_p->name, nbuf);
917		}
#	Line 1019 | Line 936 | sendto_globops_flags(unsigned int flags,
936		/* If we're sending it to opers and theyre an admin, skip.
937		* If we're sending it to admins, and theyre not, skip.
938		*/
939	<	if (((level == L_ADMIN) && !IsAdmin(client_p)) ||
940	<	((level == L_OPER) && IsAdmin(client_p)))
939	>	if (((level == L_ADMIN) && !HasUMode(client_p, UMODE_ADMIN)) ||
940	>	((level == L_OPER) && HasUMode(client_p, UMODE_ADMIN)))
941		continue;
942
943	<	if (client_p->umodes & flags)
943	>	if (HasUMode(client_p, flags))
944		sendto_one(client_p, ":%s NOTICE %s :*** Global -- %s",
945		me.name, client_p->name, nbuf);
946		}
#	Line 1061 | Line 978 | sendto_wallops_flags(unsigned int flags,
978		struct Client *client_p = ptr->data;
979		assert(client_p->umodes & UMODE_OPER);
980
981	<	if ((client_p->umodes & flags) && !IsDefunct(client_p))
981	>	if (HasUMode(client_p, flags) && !IsDefunct(client_p))
982		send_message(client_p, buffer, len);
983		}
984		}
#	Line 1104 | Line 1021 | ts_warn(const char *pattern, ...)
1021		va_end(args);
1022
1023		sendto_realops_flags(UMODE_ALL, L_ALL, "%s", buffer);
1024	<	ilog(L_CRIT, "%s", buffer);
1024	>	ilog(LOG_TYPE_IRCD, "%s", buffer);
1025		}
1026
1027		/* kill_client()

Diff Legend

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