1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
4  *
5  * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
6  * der GNU General Public License (GPL), wie von der Free Software Foundation
7  * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
8  * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
9  * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
10  * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
11  *
12  * $Id: irc-write.c,v 1.3 2002/03/25 17:13:07 alex Exp $
13  *
14  * irc-write.c: IRC-Texte und Befehle ueber Netzwerk versenden
15  */
16 
17 
18 #include "portab.h"
19 
20 #include "imp.h"
21 #include <assert.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 
25 #include "defines.h"
26 
27 #include "exp.h"
28 #include "irc-write.h"
29 
30 
31 LOCAL CHAR *Get_Prefix( CLIENT *Target, CLIENT *Client );
32 
33 
34 GLOBAL BOOLEAN IRC_WriteStrClient( CLIENT *Client, CHAR *Format, ... )
35 {
36 	CHAR buffer[1000];
37 	BOOLEAN ok = CONNECTED;
38 	va_list ap;
39 
40 	assert( Client != NULL );
41 	assert( Format != NULL );
42 
43 	va_start( ap, Format );
44 	vsnprintf( buffer, 1000, Format, ap );
45 	va_end( ap );
46 
47 	/* an den Client selber */
48 	ok = IRC_WriteStrClientPrefix( Client, Client_ThisServer( ), buffer );
49 
50 	return ok;
51 } /* IRC_WriteStrClient */
52 
53 
54 GLOBAL BOOLEAN IRC_WriteStrClientPrefix( CLIENT *Client, CLIENT *Prefix, CHAR *Format, ... )
55 {
56 	/* Text an Clients, lokal bzw. remote, senden. */
57 
58 	CHAR buffer[1000];
59 	va_list ap;
60 
61 	assert( Client != NULL );
62 	assert( Format != NULL );
63 	assert( Prefix != NULL );
64 
65 	va_start( ap, Format );
66 	vsnprintf( buffer, 1000, Format, ap );
67 	va_end( ap );
68 
69 	return Conn_WriteStr( Client_Conn( Client_NextHop( Client )), ":%s %s", Get_Prefix( Client_NextHop( Client ), Prefix ), buffer );
70 } /* IRC_WriteStrClientPrefix */
71 
72 
73 GLOBAL BOOLEAN IRC_WriteStrChannel( CLIENT *Client, CHANNEL *Chan, BOOLEAN Remote, CHAR *Format, ... )
74 {
75 	CHAR buffer[1000];
76 	va_list ap;
77 
78 	assert( Client != NULL );
79 	assert( Format != NULL );
80 
81 	va_start( ap, Format );
82 	vsnprintf( buffer, 1000, Format, ap );
83 	va_end( ap );
84 
85 	return IRC_WriteStrChannelPrefix( Client, Chan, Client_ThisServer( ), Remote, buffer );
86 } /* IRC_WriteStrChannel */
87 
88 
89 GLOBAL BOOLEAN IRC_WriteStrChannelPrefix( CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
90 {
91 	BOOLEAN sock[MAX_CONNECTIONS], is_server[MAX_CONNECTIONS], ok = CONNECTED;
92 	CHAR buffer[1000];
93 	CL2CHAN *cl2chan;
94 	CLIENT *c;
95 	INT s, i;
96 	va_list ap;
97 
98 	assert( Client != NULL );
99 	assert( Chan != NULL );
100 	assert( Prefix != NULL );
101 	assert( Format != NULL );
102 
103 	va_start( ap, Format );
104 	vsnprintf( buffer, 1000, Format, ap );
105 	va_end( ap );
106 
107 	for( i = 0; i < MAX_CONNECTIONS; i++ ) sock[i] = FALSE;
108 
109 	/* An alle Clients, die in den selben Channels sind.
110 	 * Dabei aber nur einmal je Remote-Server */
111 	cl2chan = Channel_FirstMember( Chan );
112 	while( cl2chan )
113 	{
114 		c = Channel_GetClient( cl2chan );
115 		if( ! Remote )
116 		{
117 			if( Client_Conn( c ) <= NONE ) c = NULL;
118 			else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
119 		}
120 		if( c ) c = Client_NextHop( c );
121 			
122 		if( c && ( c != Client ))
123 		{
124 			/* Ok, anderer Client */
125 			s = Client_Conn( c );
126 			assert( s >= 0 );
127 			assert( s < MAX_CONNECTIONS );
128 			sock[s] = TRUE;
129 			if( Client_Type( c ) == CLIENT_SERVER ) is_server[s] = TRUE;
130 			else is_server[s] = FALSE;
131 		}
132 		cl2chan = Channel_NextMember( Chan, cl2chan );
133 	}
134 
135 	/* Senden ... */
136 	for( i = 0; i < MAX_CONNECTIONS; i++ )
137 	{
138 		if( sock[i] )
139 		{
140 			if( is_server[i] ) ok = Conn_WriteStr( i, ":%s %s", Client_ID( Prefix ), buffer );
141 			else ok = Conn_WriteStr( i, ":%s %s", Client_Mask( Prefix ), buffer );
142 			if( ! ok ) break;
143 		}
144 	}
145 	return ok;
146 } /* IRC_WriteStrChannelPrefix */
147 
148 
149 GLOBAL VOID IRC_WriteStrServers( CLIENT *ExceptOf, CHAR *Format, ... )
150 {
151 	CHAR buffer[1000];
152 	va_list ap;
153 
154 	assert( Format != NULL );
155 
156 	va_start( ap, Format );
157 	vsnprintf( buffer, 1000, Format, ap );
158 	va_end( ap );
159 
160 	/* an den Client selber */
161 	return IRC_WriteStrServersPrefix( ExceptOf, Client_ThisServer( ), buffer );
162 } /* IRC_WriteStrServers */
163 
164 
165 GLOBAL VOID IRC_WriteStrServersPrefix( CLIENT *ExceptOf, CLIENT *Prefix, CHAR *Format, ... )
166 {
167 	CHAR buffer[1000];
168 	CLIENT *c;
169 	va_list ap;
170 	
171 	assert( Format != NULL );
172 	assert( Prefix != NULL );
173 
174 	va_start( ap, Format );
175 	vsnprintf( buffer, 1000, Format, ap );
176 	va_end( ap );
177 	
178 	c = Client_First( );
179 	while( c )
180 	{
181 		if(( Client_Type( c ) == CLIENT_SERVER ) && ( Client_Conn( c ) > NONE ) && ( c != Client_ThisServer( )) && ( c != ExceptOf ))
182 		{
183 			/* Ziel-Server gefunden */
184 			IRC_WriteStrClientPrefix( c, Prefix, buffer );
185 		}
186 		c = Client_Next( c );
187 	}
188 } /* IRC_WriteStrServersPrefix */
189 
190 
191 GLOBAL BOOLEAN IRC_WriteStrRelatedPrefix( CLIENT *Client, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
192 {
193 	BOOLEAN sock[MAX_CONNECTIONS], is_server[MAX_CONNECTIONS], ok = CONNECTED;
194 	CL2CHAN *chan_cl2chan, *cl2chan;
195 	CHAR buffer[1000];
196 	CHANNEL *chan;
197 	va_list ap;
198 	CLIENT *c;
199 	INT i, s;
200 
201 	assert( Client != NULL );
202 	assert( Prefix != NULL );
203 	assert( Format != NULL );
204 
205 	va_start( ap, Format );
206 	vsnprintf( buffer, 1000, Format, ap );
207 	va_end( ap );
208 
209 	/* initialisieren */
210 	for( i = 0; i < MAX_CONNECTIONS; i++ ) sock[i] = FALSE;
211 
212 	/* An alle Clients, die in einem Channel mit dem "Ausloeser" sind,
213 	 * den Text schicken. An Remote-Server aber jeweils nur einmal. */
214 	chan_cl2chan = Channel_FirstChannelOf( Client );
215 	while( chan_cl2chan )
216 	{
217 		/* Channel des Users durchsuchen */
218 		chan = Channel_GetChannel( chan_cl2chan );
219 		cl2chan = Channel_FirstMember( chan );
220 		while( cl2chan )
221 		{
222 			c = Channel_GetClient( cl2chan );
223 			if( ! Remote )
224 			{
225 				if( Client_Conn( c ) <= NONE ) c = NULL;
226 				else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
227 			}
228 			if( c ) c = Client_NextHop( c );
229 
230 			if( c && ( c != Client ))
231 			{
232 				/* Ok, anderer Client */
233 				s = Client_Conn( c );
234 				assert( s >= 0 );
235 				assert( s < MAX_CONNECTIONS );
236 				sock[s] = TRUE;
237 				if( Client_Type( c ) == CLIENT_SERVER ) is_server[s] = TRUE;
238 				else is_server[s] = FALSE;
239 			}
240 			cl2chan = Channel_NextMember( chan, cl2chan );
241 		}
242 		
243 		/* naechsten Channel */
244 		chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
245 	}
246 
247 	/* Senden ... */
248 	for( i = 0; i < MAX_CONNECTIONS; i++ )
249 	{
250 		if( sock[i] )
251 		{
252 			if( is_server[i] ) ok = Conn_WriteStr( i, ":%s %s", Client_ID( Prefix ), buffer );
253 			else ok = Conn_WriteStr( i, ":%s %s", Client_Mask( Prefix ), buffer );
254 			if( ! ok ) break;
255 		}
256 	}
257 	return ok;
258 } /* IRC_WriteStrRelatedPrefix */
259 
260 
261 LOCAL CHAR *Get_Prefix( CLIENT *Target, CLIENT *Client )
262 {
263 	assert( Target != NULL );
264 	assert( Client != NULL );
265 
266 	if( Client_Type( Target ) == CLIENT_SERVER ) return Client_ID( Client );
267 	else return Client_Mask( Client );
268 } /* Get_Prefix */
269 
270 
271 /* -eof- */