Made on IRCNow

Blob

Date:: Mon Nov 4 13:26:00 2002 UTC
Message:: - falsche Konstante korrigiert ... *argl*!
Actions:: History | Blame | Raw File
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.12 2002/11/04 13:26:00 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 #include <string.h>
25 
26 #include "conn.h"
27 #include "client.h"
28 #include "channel.h"
29 #include "defines.h"
30 
31 #include "exp.h"
32 #include "irc-write.h"
33 
34 
35 #define SEND_TO_USER 1
36 #define SEND_TO_SERVER 2
37 
38 
39 LOCAL CHAR *Get_Prefix PARAMS(( CLIENT *Target, CLIENT *Client ));
40 
41 
42 #ifdef PROTOTYPES
43 GLOBAL BOOLEAN
44 IRC_WriteStrClient( CLIENT *Client, CHAR *Format, ... )
45 #else
46 GLOBAL BOOLEAN
47 IRC_WriteStrClient( Client, Format, va_alist )
48 CLIENT *Client;
49 CHAR *Format;
50 va_dcl
51 #endif
52 {
53 	CHAR buffer[1000];
54 	BOOLEAN ok = CONNECTED;
55 	va_list ap;
56 
57 	assert( Client != NULL );
58 	assert( Format != NULL );
59 
60 #ifdef PROTOTYPES
61 	va_start( ap, Format );
62 #else
63 	va_start( ap );
64 #endif
65 	vsnprintf( buffer, 1000, Format, ap );
66 	va_end( ap );
67 
68 	/* an den Client selber */
69 	ok = IRC_WriteStrClientPrefix( Client, Client_ThisServer( ), "%s", buffer );
70 
71 	return ok;
72 } /* IRC_WriteStrClient */
73 
74 
75 #ifdef PROTOTYPES
76 GLOBAL BOOLEAN
77 IRC_WriteStrClientPrefix( CLIENT *Client, CLIENT *Prefix, CHAR *Format, ... )
78 #else
79 GLOBAL BOOLEAN
80 IRC_WriteStrClientPrefix( Client, Prefix, Format, va_alist )
81 CLIENT *Client;
82 CLIENT *Prefix;
83 CHAR *Format;
84 va_dcl
85 #endif
86 {
87 	/* Text an Clients, lokal bzw. remote, senden. */
88 
89 	CHAR buffer[1000];
90 	va_list ap;
91 
92 	assert( Client != NULL );
93 	assert( Format != NULL );
94 	assert( Prefix != NULL );
95 
96 #ifdef PROTOTYPES
97 	va_start( ap, Format );
98 #else
99 	va_start( ap );
100 #endif
101 	vsnprintf( buffer, 1000, Format, ap );
102 	va_end( ap );
103 
104 	return Conn_WriteStr( Client_Conn( Client_NextHop( Client )), ":%s %s", Get_Prefix( Client_NextHop( Client ), Prefix ), buffer );
105 } /* IRC_WriteStrClientPrefix */
106 
107 
108 #ifdef PROTOTYPES
109 GLOBAL BOOLEAN
110 IRC_WriteStrChannel( CLIENT *Client, CHANNEL *Chan, BOOLEAN Remote, CHAR *Format, ... )
111 #else
112 GLOBAL BOOLEAN
113 IRC_WriteStrChannel( Client, Chan, Remote, Format, va_alist )
114 CLIENT *Client;
115 CHANNEL *Chan;
116 BOOLEAN Remote;
117 CHAR *Format;
118 va_dcl
119 #endif
120 {
121 	CHAR buffer[1000];
122 	va_list ap;
123 
124 	assert( Client != NULL );
125 	assert( Format != NULL );
126 
127 #ifdef PROTOTYPES
128 	va_start( ap, Format );
129 #else
130 	va_start( ap );
131 #endif
132 	vsnprintf( buffer, 1000, Format, ap );
133 	va_end( ap );
134 
135 	return IRC_WriteStrChannelPrefix( Client, Chan, Client_ThisServer( ), Remote, "%s", buffer );
136 } /* IRC_WriteStrChannel */
137 
138 
139 #ifdef PROTOTYPES
140 GLOBAL BOOLEAN
141 IRC_WriteStrChannelPrefix( CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
142 #else
143 GLOBAL BOOLEAN
144 IRC_WriteStrChannelPrefix( Client, Chan, Prefix, Remote, Format, va_alist )
145 CLIENT *Client;
146 CHANNEL *Chan;
147 CLIENT *Prefix;
148 BOOLEAN Remote;
149 CHAR *Format;
150 va_dcl
151 #endif
152 {
153 	BOOLEAN ok = CONNECTED;
154 	CHAR buffer[1000];
155 	CL2CHAN *cl2chan;
156 	CONN_ID conn;
157 	CLIENT *c;
158 	va_list ap;
159 
160 	assert( Client != NULL );
161 	assert( Chan != NULL );
162 	assert( Prefix != NULL );
163 	assert( Format != NULL );
164 
165 #ifdef PROTOTYPES
166 	va_start( ap, Format );
167 #else
168 	va_start( ap  );
169 #endif
170 	vsnprintf( buffer, 1000, Format, ap );
171 	va_end( ap );
172 
173 	Conn_ClearFlags( );
174 
175 	/* An alle Clients, die in den selben Channels sind.
176 	 * Dabei aber nur einmal je Remote-Server */
177 	cl2chan = Channel_FirstMember( Chan );
178 	while( cl2chan )
179 	{
180 		c = Channel_GetClient( cl2chan );
181 		if( ! Remote )
182 		{
183 			if( Client_Conn( c ) <= NONE ) c = NULL;
184 			else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
185 		}
186 		if( c ) c = Client_NextHop( c );
187 			
188 		if( c && ( c != Client ))
189 		{
190 			/* Ok, anderer Client */
191 			conn = Client_Conn( c );
192 			if( Client_Type( c ) == CLIENT_SERVER )	Conn_SetFlag( conn, SEND_TO_SERVER );
193 			else Conn_SetFlag( conn, SEND_TO_USER );
194 		}
195 		cl2chan = Channel_NextMember( Chan, cl2chan );
196 	}
197 
198 	/* Senden: alle Verbindungen durchgehen ... */
199 	conn = Conn_First( );
200 	while( conn != NONE )
201 	{
202 		/* muessen Daten ueber diese Verbindung verschickt werden? */
203 		if( Conn_Flag( conn ) == SEND_TO_SERVER) ok = Conn_WriteStr( conn, ":%s %s", Client_ID( Prefix ), buffer );
204 		else if( Conn_Flag( conn ) == SEND_TO_USER ) ok = Conn_WriteStr( conn, ":%s %s", Client_Mask( Prefix ), buffer );
205 		if( ! ok ) break;
206 
207 		/* naechste Verbindung testen */
208 		conn = Conn_Next( conn );
209 	}
210 
211 	return ok;
212 } /* IRC_WriteStrChannelPrefix */
213 
214 
215 #ifdef PROTOTYPES
216 GLOBAL VOID
217 IRC_WriteStrServers( CLIENT *ExceptOf, CHAR *Format, ... )
218 #else
219 GLOBAL VOID
220 IRC_WriteStrServers( ExceptOf, Format, va_alist )
221 CLIENT *ExceptOf;
222 CHAR *Format;
223 va_dcl
224 #endif
225 {
226 	CHAR buffer[1000];
227 	va_list ap;
228 
229 	assert( Format != NULL );
230 
231 #ifdef PROTOTYPES
232 	va_start( ap, Format );
233 #else
234 	va_start( ap );
235 #endif
236 	vsnprintf( buffer, 1000, Format, ap );
237 	va_end( ap );
238 
239 	/* an den Client selber */
240 	IRC_WriteStrServersPrefix( ExceptOf, Client_ThisServer( ), "%s", buffer );
241 } /* IRC_WriteStrServers */
242 
243 
244 #ifdef PROTOTYPES
245 GLOBAL VOID
246 IRC_WriteStrServersPrefix( CLIENT *ExceptOf, CLIENT *Prefix, CHAR *Format, ... )
247 #else
248 GLOBAL VOID
249 IRC_WriteStrServersPrefix( ExceptOf, Prefix, Format, va_alist )
250 CLIENT *ExceptOf;
251 CLIENT *Prefix;
252 CHAR *Format;
253 va_dcl
254 #endif
255 {
256 	CHAR buffer[1000];
257 	va_list ap;
258 
259 	assert( Format != NULL );
260 	assert( Prefix != NULL );
261 
262 #ifdef PROTOTYPES
263 	va_start( ap, Format );
264 #else
265 	va_start( ap );
266 #endif
267 	vsnprintf( buffer, 1000, Format, ap );
268 	va_end( ap );
269 
270 	IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, '\0', "%s", buffer );
271 } /* IRC_WriteStrServersPrefix */
272 	
273 
274 #ifdef PROTOTYPES
275 GLOBAL VOID
276 IRC_WriteStrServersPrefixFlag( CLIENT *ExceptOf, CLIENT *Prefix, CHAR Flag, CHAR *Format, ... )
277 #else
278 GLOBAL VOID
279 IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, Flag, Format, va_alist )
280 CLIENT *ExceptOf;
281 CLIENT *Prefix;
282 CHAR Flag;
283 CHAR *Format;
284 va_dcl
285 #endif
286 {
287 	CHAR buffer[1000];
288 	CLIENT *c;
289 	va_list ap;
290 	
291 	assert( Format != NULL );
292 	assert( Prefix != NULL );
293 
294 #ifdef PROTOTYPES
295 	va_start( ap, Format );
296 #else
297 	va_start( ap );
298 #endif
299 	vsnprintf( buffer, 1000, Format, ap );
300 	va_end( ap );
301 	
302 	c = Client_First( );
303 	while( c )
304 	{
305 		if(( Client_Type( c ) == CLIENT_SERVER ) && ( Client_Conn( c ) > NONE ) && ( c != Client_ThisServer( )) && ( c != ExceptOf ))
306 		{
307 			/* Ziel-Server gefunden. Nun noch pruefen, ob Flags stimmen */
308 			if(( Flag == '\0' ) || ( strchr( Client_Flags( c ), Flag ) != NULL )) IRC_WriteStrClientPrefix( c, Prefix, "%s", buffer );
309 		}
310 		c = Client_Next( c );
311 	}
312 } /* IRC_WriteStrServersPrefixFlag */
313 
314 
315 #ifdef PROTOTYPES
316 GLOBAL BOOLEAN
317 IRC_WriteStrRelatedPrefix( CLIENT *Client, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
318 #else
319 GLOBAL BOOLEAN
320 IRC_WriteStrRelatedPrefix( Client, Prefix, Remote, Format, va_alist )
321 CLIENT *Client;
322 CLIENT *Prefix;
323 BOOLEAN Remote;
324 CHAR *Format;
325 va_dcl
326 #endif
327 {
328 	BOOLEAN ok = CONNECTED;
329 	CL2CHAN *chan_cl2chan, *cl2chan;
330 	CHAR buffer[1000];
331 	CHANNEL *chan;
332 	CONN_ID conn;
333 	va_list ap;
334 	CLIENT *c;
335 
336 	assert( Client != NULL );
337 	assert( Prefix != NULL );
338 	assert( Format != NULL );
339 
340 #ifdef PROTOTYPES
341 	va_start( ap, Format );
342 #else
343 	va_start( ap );
344 #endif
345 	vsnprintf( buffer, 1000, Format, ap );
346 	va_end( ap );
347 
348 	/* initialisieren */
349 	Conn_ClearFlags( );
350 
351 	/* An alle Clients, die in einem Channel mit dem "Ausloeser" sind,
352 	 * den Text schicken. An Remote-Server aber jeweils nur einmal. */
353 	chan_cl2chan = Channel_FirstChannelOf( Client );
354 	while( chan_cl2chan )
355 	{
356 		/* Channel des Users durchsuchen */
357 		chan = Channel_GetChannel( chan_cl2chan );
358 		cl2chan = Channel_FirstMember( chan );
359 		while( cl2chan )
360 		{
361 			c = Channel_GetClient( cl2chan );
362 			if( ! Remote )
363 			{
364 				if( Client_Conn( c ) <= NONE ) c = NULL;
365 				else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
366 			}
367 			if( c ) c = Client_NextHop( c );
368 
369 			if( c && ( c != Client ))
370 			{
371 				/* Ok, anderer Client */
372 				conn = Client_Conn( c );
373 				if( Client_Type( c ) == CLIENT_SERVER ) Conn_SetFlag( conn, SEND_TO_SERVER );
374 				else Conn_SetFlag( conn, SEND_TO_USER );
375 			}
376 			cl2chan = Channel_NextMember( chan, cl2chan );
377 		}
378 		
379 		/* naechsten Channel */
380 		chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
381 	}
382 
383 	/* Senden: alle Verbindungen durchgehen ... */
384 	conn = Conn_First( );
385 	while( conn != NONE )
386 	{
387 		/* muessen ueber diese Verbindung Daten gesendet werden? */
388 		if( Conn_Flag( conn ) == SEND_TO_SERVER ) ok = Conn_WriteStr( conn, ":%s %s", Client_ID( Prefix ), buffer );
389 		else if( Conn_Flag( conn ) == SEND_TO_USER ) ok = Conn_WriteStr( conn, ":%s %s", Client_Mask( Prefix ), buffer );
390 		if( ! ok ) break;
391 
392 		/* naechste Verbindung testen */
393 		conn = Conn_Next( conn );
394 	}
395 	return ok;
396 } /* IRC_WriteStrRelatedPrefix */
397 
398 
399 LOCAL CHAR *
400 Get_Prefix( CLIENT *Target, CLIENT *Client )
401 {
402 	assert( Target != NULL );
403 	assert( Client != NULL );
404 
405 	if( Client_Type( Target ) == CLIENT_SERVER ) return Client_ID( Client );
406 	else return Client_Mask( Client );
407 } /* Get_Prefix */
408 
409 
410 /* -eof- */