ViewVC Help

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

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

Comparing ircd-hybrid/trunk/src/send.c (file contents):
Revision 1734 by michael, Fri Jan 11 12:59:24 2013 UTC vs.
Revision 3103 by michael, Thu Mar 6 00:05:12 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  send.c: Functions for sending messages.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2002 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 1997-2014 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 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
20	<	*
21	<	*  $Id$
20	>	*/
21	>
22	>	/*! \file send.c
23	>	* \brief Functions for sending messages.
24	>	* \version $Id$
25		*/
26
27		#include "stdinc.h"
#	Line 34 | Line 36
36		#include "fdlist.h"
37		#include "s_bsd.h"
38		#include "s_serv.h"
37	–	#include "sprintf_irc.h"
39		#include "conf.h"
40		#include "log.h"
41		#include "memory.h"
41	–	#include "hook.h"
42		#include "packet.h"
43
44
45	–	struct Callback *iosend_cb = NULL;
45		static unsigned int current_serial = 0;
46
47
#	Line 65 | Line 64 | send_format(char *lsendbuf, int bufsize,
64		*
65		* IRC messages are always lines of characters terminated with a CR-LF
66		* (Carriage Return - Line Feed) pair, and these messages shall not
67	<	* exceed 512 characters in length,  counting all characters
67	>	* exceed 512 characters in length,  counting all characters
68		* including the trailing CR-LF.
69		* Thus, there are 510 characters maximum allowed
70		* for the command and its parameters.  There is no provision for
#	Line 82 | Line 81 | send_format(char *lsendbuf, int bufsize,
81		}
82
83		/*
85	–	* iosend_default - append a packet to the client's sendq.
86	–	*/
87	–	void *
88	–	iosend_default(va_list args)
89	–	{
90	–	struct Client *to = va_arg(args, struct Client *);
91	–	int length = va_arg(args, int);
92	–	char *buf = va_arg(args, char *);
93	–
94	–	dbuf_put(&to->localClient->buf_sendq, buf, length);
95	–	return NULL;
96	–	}
97	–
98	–	/*
84		** send_message
85		**      Internal utility which appends given buffer to the sockets
86		**      sendq.
#	Line 110 | Line 95 | send_message(struct Client *to, char *bu
95		{
96		if (IsServer(to))
97		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
98	<	"Max SendQ limit exceeded for %s: %lu > %lu",
98	>	"Max SendQ limit exceeded for %s: %lu > %u",
99		get_client_name(to, HIDE_IP),
100		(unsigned long)(dbuf_length(&to->localClient->buf_sendq) + len),
101		get_sendq(&to->localClient->confs));
#	Line 120 | Line 105 | send_message(struct Client *to, char *bu
105		return;
106		}
107
108	<	execute_callback(iosend_cb, to, len, buf);
108	>	dbuf_put(&to->localClient->buf_sendq, buf, len);
109
110		/*
111		** Update statistics. The following is slightly incorrect
#	Line 130 | Line 115 | send_message(struct Client *to, char *bu
115		++to->localClient->send.messages;
116		++me.localClient->send.messages;
117
118	<	if (dbuf_length(&to->localClient->buf_sendq) >
134	<	(IsServer(to) ? (unsigned int) 1024 : (unsigned int) 4096))
135	<	send_queued_write(to);
118	>	send_queued_write(to);
119		}
120
121		/* send_message_remote()
#	Line 144 | Line 127 | send_message(struct Client *to, char *bu
127		* output       - none
128		* side effects - Despite the function name, this only sends to directly
129		*                connected clients.
130	<	*
130	>	*
131		*/
132		static void
133		send_message_remote(struct Client *to, struct Client *from,
134		char *buf, int len)
135		{
136	+	if (to->from)
137	+	to = to->from;
138	+
139		if (!MyConnect(to))
140		{
141		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
142	<	"server send message to %s [%s] dropped from %s(Not local server)",
143	<	to->name, to->from->name, from->name);
142	>	"Server send message to %s [%s] dropped from %s(Not local server)",
143	>	to->name, to->from->name, from->name);
144		return;
145		}
146
#	Line 194 | Line 180 | send_message_remote(struct Client *to, s
180		to->host, to->from);
181
182		exit_client(to, &me, "Ghosted client");
197	–
183		return;
184	<	}
184	>	}
185
186		send_message(to, buf, len);
187		}
#	Line 208 | Line 193 | send_message_remote(struct Client *to, s
193		void
194		sendq_unblocked(fde_t *fd, struct Client *client_p)
195		{
196	<	ClearSendqBlocked(client_p);
197	<	/* let send_queued_write be executed by send_queued_all */
213	<
214	<	#ifdef HAVE_LIBCRYPTO
215	<	if (fd->flags.pending_read)
216	<	{
217	<	fd->flags.pending_read = 0;
218	<	read_packet(fd, client_p);
219	<	}
220	<	#endif
196	>	assert(fd == &client_p->localClient->fd);
197	>	send_queued_write(client_p);
198		}
199
200		/*
#	Line 229 | Line 206 | sendq_unblocked(fde_t *fd, struct Client
206		void
207		send_queued_write(struct Client *to)
208		{
209	<	int retlen;
210	<	struct dbuf_block *first;
209	>	int retlen = 0;
210	>	struct dbuf_block *first = NULL;
211
212		/*
213		** Once socket is marked dead, we cannot start writing to it,
214		** even if the error is removed...
215		*/
216	<	if (IsDead(to) || IsSendqBlocked(to))
216	>	if (IsDead(to))
217		return;  /* no use calling send() now */
218
219		/* Next, lets try to write some data */
243	–
220		if (dbuf_length(&to->localClient->buf_sendq))
221		{
222	<	do {
222	>	do
223	>	{
224		first = to->localClient->buf_sendq.blocks.head->data;
225
226		#ifdef HAVE_LIBCRYPTO
#	Line 252 | Line 229 | send_queued_write(struct Client *to)
229		retlen = SSL_write(to->localClient->fd.ssl, first->data, first->size);
230
231		/* translate openssl error codes, sigh */
232	<	if (retlen < 0)
233	<	switch (SSL_get_error(to->localClient->fd.ssl, retlen))
234	<	{
232	>	if (retlen < 0)
233	>	{
234	>	switch (SSL_get_error(to->localClient->fd.ssl, retlen))
235	>	{
236		case SSL_ERROR_WANT_READ:
237	<	return;  /* retry later, don't register for write events */
238	<
239	<	case SSL_ERROR_WANT_WRITE:
262	<	errno = EWOULDBLOCK;
237	>	return;  /* retry later, don't register for write events */
238	>	case SSL_ERROR_WANT_WRITE:
239	>	errno = EWOULDBLOCK;
240		case SSL_ERROR_SYSCALL:
241	<	break;
241	>	break;
242		case SSL_ERROR_SSL:
243		if (errno == EAGAIN)
244		break;
245		default:
246	<	retlen = errno = 0;  /* either an SSL-specific error or EOF */
247	<	}
246	>	retlen = errno = 0;  /* either an SSL-specific error or EOF */
247	>	}
248	>	}
249		}
250		else
251		#endif
#	Line 286 | Line 264 | send_queued_write(struct Client *to)
264		if ((retlen < 0) && (ignoreErrno(errno)))
265		{
266		/* we have a non-fatal error, reschedule a write */
289	–	SetSendqBlocked(to);
267		comm_setselect(&to->localClient->fd, COMM_SELECT_WRITE,
268	<	(PF *)sendq_unblocked, (void *)to, 0);
268	>	(PF *)sendq_unblocked, to, 0);
269		}
270		else if (retlen <= 0)
271		{
#	Line 313 | Line 290 | send_queued_all(void)
290		* a notice to opers, which is to be delivered by this function.
291		*/
292		DLINK_FOREACH(ptr, serv_list.head)
293	<	send_queued_write((struct Client *) ptr->data);
293	>	send_queued_write(ptr->data);
294
295		DLINK_FOREACH(ptr, unknown_list.head)
296	<	send_queued_write((struct Client *) ptr->data);
296	>	send_queued_write(ptr->data);
297
298		DLINK_FOREACH(ptr, local_client_list.head)
299	<	send_queued_write((struct Client *) ptr->data);
299	>	send_queued_write(ptr->data);
300
301		/* NOTE: This can still put clients on aborted_list; unfortunately,
302		* exit_aborted_clients takes precedence over send_queued_all,
#	Line 349 | Line 326 | sendto_one(struct Client *to, const char
326		return; /* This socket has already been marked as dead */
327
328		va_start(args, pattern);
329	<	len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
329	>	len = send_format(buffer, sizeof(buffer), pattern, args);
330		va_end(args);
331
332		send_message(to, buffer, len);
#	Line 379 | Line 356 | sendto_channel_butone(struct Client *one
356		dlink_node *ptr = NULL, *ptr_next = NULL;
357
358		if (IsServer(from))
359	<	local_len = ircsprintf(local_buf, ":%s ",
360	<	from->name);
359	>	local_len = snprintf(local_buf, sizeof(local_buf), ":%s ",
360	>	from->name);
361		else
362	<	local_len = ircsprintf(local_buf, ":%s!%s@%s ",
363	<	from->name, from->username, from->host);
364	<	remote_len = ircsprintf(remote_buf, ":%s ",
365	<	from->name);
366	<	uid_len = ircsprintf(uid_buf, ":%s ",
390	<	ID(from));
362	>	local_len = snprintf(local_buf, sizeof(local_buf), ":%s!%s@%s ",
363	>	from->name, from->username, from->host);
364	>	remote_len = snprintf(remote_buf, sizeof(remote_buf), ":%s ",
365	>	from->name);
366	>	uid_len = snprintf(uid_buf, sizeof(uid_buf), ":%s ", ID(from));
367
368		va_start(alocal, pattern);
369		va_start(aremote, pattern);
#	Line 418 | Line 394 | sendto_channel_butone(struct Client *one
394		continue;
395
396		if (MyConnect(target_p))
397	<	{
398	<	if (target_p->localClient->serial != current_serial)
399	<	{
400	<	send_message(target_p, local_buf, local_len);
425	<	target_p->localClient->serial = current_serial;
426	<	}
427	<	}
428	<	else
429	<	{
430	<	/* Now check whether a message has been sent to this
431	<	* remote link already
432	<	*/
433	<	if (target_p->from->localClient->serial != current_serial)
434	<	{
435	<	if (IsCapable(target_p->from, CAP_TS6))
436	<	send_message_remote(target_p->from, from, uid_buf, uid_len);
437	<	else
438	<	send_message_remote(target_p->from, from, remote_buf, remote_len);
439	<	target_p->from->localClient->serial = current_serial;
440	<	}
441	<	}
397	>	send_message(target_p, local_buf);
398	>	else if (target_p->from->localClient->serial != current_serial)
399	>	send_message_remote(target_p->from, from, remote_buf);
400	>	target_p->from->localClient->serial = current_serial;
401		}
402		}
403
404		/* sendto_server()
405	<	*
405	>	*
406		* inputs       - pointer to client to NOT send to
407		*              - pointer to channel
408		*              - caps or'd together which must ALL be present
#	Line 454 | Line 413 | sendto_channel_butone(struct Client *one
413		* side effects - Send a message to all connected servers, except the
414		*                client 'one' (if non-NULL), as long as the servers
415		*                support ALL capabs in 'caps', and NO capabs in 'nocaps'.
416	<	*
416	>	*
417		* This function was written in an attempt to merge together the other
418		* billion sendto_*serv*() functions, which sprung up with capabs,
419		* lazylinks, uids, etc.
420		* -davidt
421		*/
422	<	void
422	>	void
423		sendto_server(struct Client *one,
424		const unsigned int caps,
425		const unsigned int nocaps,
#	Line 472 | Line 431 | sendto_server(struct Client *one,
431		int len = 0;
432
433		va_start(args, format);
434	<	len = send_format(buffer, IRCD_BUFSIZE, format, args);
434	>	len = send_format(buffer, sizeof(buffer), format, args);
435		va_end(args);
436
437		DLINK_FOREACH(ptr, serv_list.head)
#	Line 502 | Line 461 | sendto_server(struct Client *one,
461		*              - pattern to send
462		* output       - NONE
463		* side effects - Sends a message to all people on local server who are
464	<	*                in same channel with user.
464	>	*                in same channel with user.
465		*                used by m_nick.c and exit_one_client.
466		*/
467		void
#	Line 519 | Line 478 | sendto_common_channels_local(struct Clie
478		int len;
479
480		va_start(args, pattern);
481	<	len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
481	>	len = send_format(buffer, sizeof(buffer), pattern, args);
482		va_end(args);
483
484		++current_serial;
485
486		DLINK_FOREACH(cptr, user->channel.head)
487		{
488	<	chptr = ((struct Membership *) cptr->data)->chptr;
488	>	chptr = ((struct Membership *)cptr->data)->chptr;
489		assert(chptr != NULL);
490
491		DLINK_FOREACH(uptr, chptr->members.head)
#	Line 549 | Line 508 | sendto_common_channels_local(struct Clie
508
509		if (touser && MyConnect(user) && !IsDead(user) &&
510		user->localClient->serial != current_serial)
511	<	if (HasCap(target_p, cap) == cap)
511	>	if (HasCap(user, cap) == cap)
512		send_message(user, buffer, len);
513		}
514
#	Line 564 | Line 523 | sendto_common_channels_local(struct Clie
523		*                locally connected to this server.
524		*/
525		void
526	<	sendto_channel_local(int type, int nodeaf, struct Channel *chptr,
526	>	sendto_channel_local(unsigned int type, int nodeaf, struct Channel *chptr,
527		const char *pattern, ...)
528		{
529		va_list args;
530		char buffer[IRCD_BUFSIZE];
531	<	int len;
532	<	dlink_node *ptr;
574	<	struct Membership *ms;
575	<	struct Client *target_p;
531	>	int len = 0;
532	>	dlink_node *ptr = NULL;
533
534		va_start(args, pattern);
535	<	len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
535	>	len = send_format(buffer, sizeof(buffer), pattern, args);
536		va_end(args);
537
538		DLINK_FOREACH(ptr, chptr->members.head)
539		{
540	<	ms = ptr->data;
541	<	target_p = ms->client_p;
540	>	struct Membership *ms = ptr->data;
541	>	struct Client *target_p = ms->client_p;
542
543		if (type != 0 && (ms->flags & type) == 0)
544		continue;
#	Line 606 | Line 563 | sendto_channel_local(int type, int nodea
563		*
564		* WARNING - +D clients are omitted
565		*/
609	–	void
610	–	sendto_channel_local_butone(struct Client *one, int type, unsigned int cap,
611	–	struct Channel *chptr, const char *pattern, ...)
612	–	{
613	–	va_list args;
614	–	char buffer[IRCD_BUFSIZE];
615	–	int len;
616	–	struct Client *target_p;
617	–	struct Membership *ms;
618	–	dlink_node *ptr;
619	–
620	–	va_start(args, pattern);
621	–	len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
622	–	va_end(args);
623	–
624	–	DLINK_FOREACH(ptr, chptr->members.head)
625	–	{
626	–	ms = ptr->data;
627	–	target_p = ms->client_p;
628	–
629	–	if (type != 0 && (ms->flags & type) == 0)
630	–	continue;
631	–
632	–	if (!MyConnect(target_p) || target_p == one ||
633	–	IsDefunct(target_p) || HasUMode(target_p, UMODE_DEAF))
634	–	continue;
635	–
636	–	if (HasCap(target_p, cap) != cap)
637	–	continue;
638	–	send_message(target_p, buffer, len);
639	–	}
640	–	}
641	–
642	–
643	–	/* sendto_channel_remote()
644	–	*
645	–	* inputs       - Client not to send towards
646	–	*              - Client from whom message is from
647	–	*              - member status mask, e.g. CHFL_CHANOP | CHFL_VOICE
648	–	*              - pointer to channel to send to
649	–	*              - var args pattern
650	–	* output       - NONE
651	–	* side effects - Send a message to all members of a channel that are
652	–	*                remote to this server.
653	–	*/
566		void
567	<	sendto_channel_remote(struct Client *one, struct Client *from, int type,
568	<	const unsigned int caps, const unsigned int nocaps,
657	<	struct Channel *chptr, const char *pattern, ...)
567	>	sendto_channel_local_butone(struct Client *one, unsigned int type, unsigned int cap,
568	>	struct Channel *chptr, const char *pattern, ...)
569		{
570		va_list args;
571		char buffer[IRCD_BUFSIZE];
572	<	int len;
573	<	dlink_node *ptr;
663	<	struct Client *target_p;
664	<	struct Membership *ms;
572	>	int len = 0;
573	>	dlink_node *ptr = NULL;
574
575		va_start(args, pattern);
576	<	len = send_format(buffer, IRCD_BUFSIZE, pattern, args);
576	>	len = send_format(buffer, sizeof(buffer), pattern, args);
577		va_end(args);
578
670	–	++current_serial;
671	–
579		DLINK_FOREACH(ptr, chptr->members.head)
580		{
581	<	ms = ptr->data;
582	<	target_p = ms->client_p;
581	>	struct Membership *ms = ptr->data;
582	>	struct Client *target_p = ms->client_p;
583
584		if (type != 0 && (ms->flags & type) == 0)
585		continue;
586
587	<	if (MyConnect(target_p))
587	>	if (!MyConnect(target_p) || target_p == one ||
588	>	IsDefunct(target_p) || HasUMode(target_p, UMODE_DEAF))
589		continue;
682	–	target_p = target_p->from;
590
591	<	if (target_p == one->from ||
685	<	((target_p->from->localClient->caps & caps) != caps) ||
686	<	((target_p->from->localClient->caps & nocaps) != 0))
591	>	if (HasCap(target_p, cap) != cap)
592		continue;
593	<	if (target_p->from->localClient->serial != current_serial)
594	<	{
595	<	send_message(target_p, buffer, len);
691	<	target_p->from->localClient->serial = current_serial;
692	<	}
693	<	}
593	>
594	>	send_message(target_p, buffer, len);
595	>	}
596		}
597
598		/*
#	Line 711 | Line 613 | sendto_channel_remote(struct Client *one
613		* side effects - NONE
614		*/
615		static int
616	<	match_it(const struct Client *one, const char *mask, int what)
616	>	match_it(const struct Client *one, const char *mask, unsigned int what)
617		{
618		if (what == MATCH_HOST)
619		return !match(mask, one->host);
#	Line 734 | Line 636 | sendto_match_butone(struct Client *one,
636		struct Client *client_p;
637		dlink_node *ptr, *ptr_next;
638		char local_buf[IRCD_BUFSIZE], remote_buf[IRCD_BUFSIZE];
639	<	int local_len = ircsprintf(local_buf, ":%s!%s@%s ", from->name,
640	<	from->username, from->host);
641	<	int remote_len = ircsprintf(remote_buf, ":%s ", from->name);
639	>	int local_len = snprintf(local_buf, sizeof(local_buf), ":%s!%s@%s ",
640	>	from->name, from->username, from->host);
641	>	int remote_len = snprintf(remote_buf, sizeof(remote_buf), ":%s ",
642	>	from->name);
643
644		va_start(alocal, pattern);
645		va_start(aremote, pattern);
#	Line 801 | Line 704 | sendto_match_butone(struct Client *one,
704		* side effects - data sent to servers matching with capab
705		*/
706		void
707	<	sendto_match_servs(struct Client *source_p, const char *mask, int cap,
707	>	sendto_match_servs(struct Client *source_p, const char *mask, unsigned int cap,
708		const char *pattern, ...)
709		{
710		va_list args;
711	<	struct Client *target_p;
712	<	dlink_node *ptr;
713	<	char buffer[IRCD_BUFSIZE];
714	<	int found = 0;
711	>	dlink_node *ptr = NULL;
712	>	char buff_suid[IRCD_BUFSIZE];
713	>	char buff_name[IRCD_BUFSIZE];
714	>	int len_suid = 0;
715	>	int len_name = 0;
716
717		va_start(args, pattern);
718	<	vsnprintf(buffer, sizeof(buffer), pattern, args);
718	>	len_suid  = snprintf(buff_suid, sizeof(buff_suid), ":%s ", ID(source_p));
719	>	len_suid += send_format(&buff_suid[len_suid], sizeof(buff_suid) - len_suid,
720	>	pattern, args);
721	>	va_end(args);
722	>
723	>	va_start(args, pattern);
724	>	len_name = snprintf(buff_name, sizeof(buff_name), ":%s ", source_p->name);
725	>	len_name += send_format(&buff_name[len_name], sizeof(buff_name) - len_name,
726	>	pattern, args);
727		va_end(args);
728
729		++current_serial;
730
731		DLINK_FOREACH(ptr, global_serv_list.head)
732		{
733	<	target_p = ptr->data;
733	>	struct Client *target_p = ptr->data;
734
735		/* Do not attempt to send to ourselves, or the source */
736		if (IsMe(target_p) || target_p->from == source_p->from)
#	Line 834 | Line 746 | sendto_match_servs(struct Client *source
746		* match() again, if !IsCapable()
747		*/
748		target_p->from->localClient->serial = current_serial;
837	–	found++;
749
750		if (!IsCapable(target_p->from, cap))
751		continue;
752
753	<	sendto_anywhere(target_p, source_p, "%s", buffer);
753	>	if (HasID(target_p->from))
754	>	send_message_remote(target_p->from, source_p, buff_suid, len_suid);
755	>	else
756	>	send_message_remote(target_p->from, source_p, buff_name, len_name);
757		}
758		}
759		}
#	Line 855 | Line 769 | sendto_match_servs(struct Client *source
769		*/
770		void
771		sendto_anywhere(struct Client *to, struct Client *from,
772	+	const char *command,
773		const char *pattern, ...)
774		{
775		va_list args;
776		char buffer[IRCD_BUFSIZE];
777	<	int len;
863	<	struct Client *send_to = (to->from != NULL ? to->from : to);
777	>	int len = 0;
778
779	<	if (IsDead(send_to))
779	>	if (IsDead(to->from))
780		return;
781
782		if (MyClient(to))
783		{
784		if (IsServer(from))
785	<	{
786	<	if (IsCapable(to, CAP_TS6) && HasID(from))
873	<	len = ircsprintf(buffer, ":%s ", from->id);
874	<	else
875	<	len = ircsprintf(buffer, ":%s ", from->name);
876	<	}
785	>	len = snprintf(buffer, sizeof(buffer), ":%s %s %s ",
786	>	from->name, command, to->name);
787		else
788	<	len = ircsprintf(buffer, ":%s!%s@%s ",
789	<	from->name, from->username, from->host);
788	>	len = snprintf(buffer, sizeof(buffer), ":%s!%s@%s %s %s ",
789	>	from->name, from->username, from->host, command, to->name);
790		}
791	<	else len = ircsprintf(buffer, ":%s ", ID_or_name(from, send_to));
791	>	else
792	>	len = snprintf(buffer, sizeof(buffer), ":%s %s %s ",
793	>	ID_or_name(from, to), command,
794	>	ID_or_name(to, to));
795
796		va_start(args, pattern);
797	<	len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
797	>	len += send_format(&buffer[len], sizeof(buffer) - len, pattern, args);
798		va_end(args);
799
800	<	if(MyClient(to))
801	<	send_message(send_to, buffer, len);
800	>	if (MyClient(to))
801	>	send_message(to, buffer, len);
802		else
803	<	send_message_remote(send_to, from, buffer, len);
803	>	send_message_remote(to, from, buffer, len);
804		}
805
806		/* sendto_realops_flags()
#	Line 935 | Line 848 | sendto_realops_flags(unsigned int flags,
848		* If we're sending it to admins, and they're not, skip.
849		*/
850		if (((level == L_ADMIN) && !HasUMode(client_p, UMODE_ADMIN)) ||
851	<	((level == L_OPER) && HasUMode(client_p, UMODE_ADMIN)))
851	>	((level == L_OPER) && HasUMode(client_p, UMODE_ADMIN)))
852		continue;
853
854		if (HasUMode(client_p, flags))
#	Line 962 | Line 875 | sendto_wallops_flags(unsigned int flags,
875		int len;
876
877		if (IsClient(source_p))
878	<	len = ircsprintf(buffer, ":%s!%s@%s WALLOPS :",
879	<	source_p->name, source_p->username, source_p->host);
878	>	len = snprintf(buffer, sizeof(buffer), ":%s!%s@%s WALLOPS :",
879	>	source_p->name, source_p->username,
880	>	source_p->host);
881		else
882	<	len = ircsprintf(buffer, ":%s WALLOPS :", source_p->name);
882	>	len = snprintf(buffer, sizeof(buffer), ":%s WALLOPS :",
883	>	source_p->name);
884
885		va_start(args, pattern);
886		len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
#	Line 989 | Line 904 | sendto_wallops_flags(unsigned int flags,
904		*                (at most 5 warnings every 5 seconds)
905		*/
906		void
907	<	ts_warn(const char *pattern, ...)
907	>	sendto_realops_flags_ratelimited(const char *pattern, ...)
908		{
909		va_list args;
910		char buffer[IRCD_BUFSIZE];
#	Line 1043 | Line 958 | kill_client(struct Client *client_p, str
958		if (IsDead(client_p))
959		return;
960
961	<	len = ircsprintf(buffer, ":%s KILL %s :", ID_or_name(&me, client_p->from),
962	<	ID_or_name(diedie, client_p));
961	>	len = snprintf(buffer, sizeof(buffer), ":%s KILL %s :",
962	>	ID_or_name(&me, client_p),
963	>	ID_or_name(diedie, client_p));
964
965		va_start(args, pattern);
966		len += send_format(&buffer[len], IRCD_BUFSIZE - len, pattern, args);
#	Line 1064 | Line 980 | kill_client(struct Client *client_p, str
980		*                client being unknown to leaf, as in lazylink...
981		*/
982		void
983	<	kill_client_ll_serv_butone(struct Client *one, struct Client *source_p,
984	<	const char *pattern, ...)
983	>	kill_client_serv_butone(struct Client *one, struct Client *source_p,
984	>	const char *pattern, ...)
985		{
986		va_list args;
987		int have_uid = 0;
#	Line 1077 | Line 993 | kill_client_ll_serv_butone(struct Client
993		{
994		have_uid = 1;
995		va_start(args, pattern);
996	<	len_uid = ircsprintf(buf_uid, ":%s KILL %s :", me.id, ID(source_p));
997	<	len_uid += send_format(&buf_uid[len_uid], IRCD_BUFSIZE - len_uid, pattern,
998	<	args);
996	>	len_uid = snprintf(buf_uid, sizeof(buf_uid), ":%s KILL %s :",
997	>	me.id, ID(source_p));
998	>	len_uid += send_format(&buf_uid[len_uid], IRCD_BUFSIZE - len_uid, pattern, args);
999		va_end(args);
1000		}
1001
1002		va_start(args, pattern);
1003	<	len_nick = ircsprintf(buf_nick, ":%s KILL %s :", me.name, source_p->name);
1004	<	len_nick += send_format(&buf_nick[len_nick], IRCD_BUFSIZE - len_nick, pattern,
1005	<	args);
1003	>	len_nick = snprintf(buf_nick, sizeof(buf_nick), ":%s KILL %s :",
1004	>	me.name, source_p->name);
1005	>	len_nick += send_format(&buf_nick[len_nick], IRCD_BUFSIZE - len_nick, pattern, args);
1006		va_end(args);
1007
1008		DLINK_FOREACH(ptr, serv_list.head)
#	Line 1103 | Line 1019 | kill_client_ll_serv_butone(struct Client
1019		else
1020		send_message(client_p, buf_nick, len_nick);
1021		}
1022	<	}
1022	>	}

Diff Legend

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