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.c,v 1.89 2002/03/25 17:04:02 alex Exp $
13  *
14  * irc.c: IRC-Befehle
15  */
16 
17 
18 #include "portab.h"
19 
20 #include "imp.h"
21 #include <assert.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 
27 #include "ngircd.h"
28 #include "channel.h"
29 #include "client.h"
30 #include "conf.h"
31 #include "conn.h"
32 #include "irc-write.h"
33 #include "log.h"
34 #include "messages.h"
35 #include "tool.h"
36 
37 #include "exp.h"
38 #include "irc.h"
39 
40 
41 GLOBAL BOOLEAN IRC_MOTD( CLIENT *Client, REQUEST *Req )
42 {
43 	assert( Client != NULL );
44 	assert( Req != NULL );
45 
46 	if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
47 
48 	/* Falsche Anzahl Parameter? */
49 	if( Req->argc != 0 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
50 
51 	return IRC_Show_MOTD( Client );
52 } /* IRC_MOTD */
53 
54 
55 GLOBAL BOOLEAN IRC_PRIVMSG( CLIENT *Client, REQUEST *Req )
56 {
57 	CLIENT *cl, *from;
58 	CHANNEL *chan;
59 	
60 	assert( Client != NULL );
61 	assert( Req != NULL );
62 
63 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
64 
65 	/* Falsche Anzahl Parameter? */
66 	if( Req->argc == 0 ) return IRC_WriteStrClient( Client, ERR_NORECIPIENT_MSG, Client_ID( Client ), Req->command );
67 	if( Req->argc == 1 ) return IRC_WriteStrClient( Client, ERR_NOTEXTTOSEND_MSG, Client_ID( Client ));
68 	if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
69 
70 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
71 	else from = Client;
72 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
73 
74 	cl = Client_Search( Req->argv[0] );
75 	if( cl )
76 	{
77 		/* Okay, Ziel ist ein User */
78 		if(( Client_Type( Client ) != CLIENT_SERVER ) && ( strchr( Client_Modes( cl ), 'a' )))
79 		{
80 			/* Ziel-User ist AWAY: Meldung verschicken */
81 			if( ! IRC_WriteStrClient( from, RPL_AWAY_MSG, Client_ID( from ), Client_ID( cl ), Client_Away( cl ))) return DISCONNECTED;
82 		}
83 
84 		/* Text senden */
85 		if( Client_Conn( from ) > NONE ) Conn_UpdateIdle( Client_Conn( from ));
86 		return IRC_WriteStrClientPrefix( cl, from, "PRIVMSG %s :%s", Client_ID( cl ), Req->argv[1] );
87 	}
88 
89 	chan = Channel_Search( Req->argv[0] );
90 	if( chan ) return Channel_Write( chan, from, Client, Req->argv[1] );
91 
92 	return IRC_WriteStrClient( from, ERR_NOSUCHNICK_MSG, Client_ID( from ), Req->argv[0] );
93 } /* IRC_PRIVMSG */
94 
95 
96 GLOBAL BOOLEAN IRC_NOTICE( CLIENT *Client, REQUEST *Req )
97 {
98 	CLIENT *to, *from;
99 
100 	assert( Client != NULL );
101 	assert( Req != NULL );
102 
103 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
104 
105 	/* Falsche Anzahl Parameter? */
106 	if( Req->argc != 2 ) return CONNECTED;
107 
108 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
109 	else from = Client;
110 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
111 
112 	to = Client_Search( Req->argv[0] );
113 	if( to )
114 	{
115 		/* Okay, Ziel ist ein User */
116 		return IRC_WriteStrClientPrefix( to, from, "NOTICE %s :%s", Client_ID( to ), Req->argv[1] );
117 	}
118 	else return CONNECTED;
119 } /* IRC_NOTICE */
120 
121 
122 GLOBAL BOOLEAN IRC_NAMES( CLIENT *Client, REQUEST *Req )
123 {
124 	CHAR rpl[COMMAND_LEN], *ptr;
125 	CLIENT *target, *from, *c;
126 	CHANNEL *chan;
127 	
128 	assert( Client != NULL );
129 	assert( Req != NULL );
130 
131 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
132 
133 	/* Falsche Anzahl Parameter? */
134 	if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
135 
136 	/* From aus Prefix ermitteln */
137 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
138 	else from = Client;
139 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->prefix );
140 	
141 	if( Req->argc == 2 )
142 	{
143 		/* an anderen Server forwarden */
144 		target = Client_Search( Req->argv[1] );
145 		if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
146 
147 		if( target != Client_ThisServer( ))
148 		{
149 			/* Ok, anderer Server ist das Ziel: forwarden */
150 			return IRC_WriteStrClientPrefix( target, from, "NAMES %s :%s", Req->argv[0], Req->argv[1] );
151 		}
152 	}
153 
154 	if( Req->argc > 0 )
155 	{
156 		/* bestimmte Channels durchgehen */
157 		ptr = strtok( Req->argv[0], "," );
158 		while( ptr )
159 		{
160 			chan = Channel_Search( ptr );
161 			if( chan )
162 			{
163 				/* Namen ausgeben */
164 				if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
165 			}
166 			if( ! IRC_WriteStrClient( from, RPL_ENDOFNAMES_MSG, Client_ID( from ), ptr )) return DISCONNECTED;
167 			
168 			/* naechsten Namen ermitteln */
169 			ptr = strtok( NULL, "," );
170 		}
171 		return CONNECTED;
172 	}
173 	
174 	/* alle Channels durchgehen */
175 	chan = Channel_First( );
176 	while( chan )
177 	{
178 		/* Namen ausgeben */
179 		if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
180 
181 		/* naechster Channel */
182 		chan = Channel_Next( chan );
183 	}
184 
185 	/* Nun noch alle Clients ausgeben, die in keinem Channel sind */
186 	c = Client_First( );
187 	sprintf( rpl, RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
188 	while( c )
189 	{
190 		if(( Client_Type( c ) == CLIENT_USER ) && ( Channel_FirstChannelOf( c ) == NULL ) && ( ! strchr( Client_Modes( c ), 'i' )))
191 		{
192 			/* Okay, das ist ein User: anhaengen */
193 			if( rpl[strlen( rpl ) - 1] != ':' ) strcat( rpl, " " );
194 			strcat( rpl, Client_ID( c ));
195 
196 			if( strlen( rpl ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
197 			{
198 				/* Zeile wird zu lang: senden! */
199 				if( ! IRC_WriteStrClient( from, rpl )) return DISCONNECTED;
200 				sprintf( rpl, RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
201 			}
202 		}
203 
204 		/* naechster Client */
205 		c = Client_Next( c );
206 	}
207 	if( rpl[strlen( rpl ) - 1] != ':')
208 	{
209 		/* es wurden User gefunden */
210 		if( ! IRC_WriteStrClient( from, rpl )) return DISCONNECTED;
211 	}
212 	
213 	return IRC_WriteStrClient( from, RPL_ENDOFNAMES_MSG, Client_ID( from ), "*" );
214 } /* IRC_NAMES */
215 
216 
217 GLOBAL BOOLEAN IRC_ISON( CLIENT *Client, REQUEST *Req )
218 {
219 	CHAR rpl[COMMAND_LEN];
220 	CLIENT *c;
221 	CHAR *ptr;
222 	INT i;
223 	
224 	assert( Client != NULL );
225 	assert( Req != NULL );
226 
227 	if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
228 
229 	/* Falsche Anzahl Parameter? */
230 	if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
231 
232 	strcpy( rpl, RPL_ISON_MSG );
233 	for( i = 0; i < Req->argc; i++ )
234 	{
235 		ptr = strtok( Req->argv[i], " " );
236 		while( ptr )
237 		{
238 			ngt_TrimStr( ptr );
239 			c = Client_Search( ptr );
240 			if( c && ( Client_Type( c ) == CLIENT_USER ))
241 			{
242 				/* Dieser Nick ist "online" */
243 				strcat( rpl, ptr );
244 				strcat( rpl, " " );
245 			}
246 			ptr = strtok( NULL, " " );
247 		}
248 	}
249 	if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
250 
251 	return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
252 } /* IRC_ISON */
253 
254 
255 GLOBAL BOOLEAN IRC_WHOIS( CLIENT *Client, REQUEST *Req )
256 {
257 	CLIENT *from, *target, *c;
258 	CHAR str[LINE_LEN + 1], *ptr = NULL;
259 	CL2CHAN *cl2chan;
260 	CHANNEL *chan;
261 	
262 	assert( Client != NULL );
263 	assert( Req != NULL );
264 
265 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
266 
267 	/* Falsche Anzahl Parameter? */
268 	if(( Req->argc < 1 ) || ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
269 
270 	/* Client suchen */
271 	c = Client_Search( Req->argv[Req->argc - 1] );
272 	if(( ! c ) || ( Client_Type( c ) != CLIENT_USER )) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[Req->argc - 1] );
273 
274 	/* Empfaenger des WHOIS suchen */
275 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
276 	else from = Client;
277 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
278 	
279 	/* Forwarden an anderen Server? */
280 	if( Req->argc > 1 )
281 	{
282 		/* angegebenen Ziel-Server suchen */
283 		target = Client_Search( Req->argv[1] );
284 		if( ! target ) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[1] );
285 		ptr = Req->argv[1];
286 	}
287 	else target = Client_ThisServer( );
288 
289 	assert( target != NULL );
290 	
291 	if(( Client_NextHop( target ) != Client_ThisServer( )) && ( Client_Type( Client_NextHop( target )) == CLIENT_SERVER )) return IRC_WriteStrClientPrefix( target, from, "WHOIS %s :%s", Req->argv[0], ptr );
292 	
293 	/* Nick, User und Name */
294 	if( ! IRC_WriteStrClient( from, RPL_WHOISUSER_MSG, Client_ID( from ), Client_ID( c ), Client_User( c ), Client_Hostname( c ), Client_Info( c ))) return DISCONNECTED;
295 
296 	/* Server */
297 	if( ! IRC_WriteStrClient( from, RPL_WHOISSERVER_MSG, Client_ID( from ), Client_ID( c ), Client_ID( Client_Introducer( c )), Client_Info( Client_Introducer( c )))) return DISCONNECTED;
298 
299 	/* Channels */
300 	sprintf( str, RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
301 	cl2chan = Channel_FirstChannelOf( c );
302 	while( cl2chan )
303 	{
304 		chan = Channel_GetChannel( cl2chan );
305 		assert( chan != NULL );
306 		
307 		/* Channel-Name anhaengen */
308 		if( str[strlen( str ) - 1] != ':' ) strcat( str, " " );
309 		if( strchr( Channel_UserModes( chan, c ), 'o' )) strcat( str, "@" );
310 		else if( strchr( Channel_UserModes( chan, c ), 'v' )) strcat( str, "+" );
311 		strcat( str, Channel_Name( chan ));
312 
313 		if( strlen( str ) > ( LINE_LEN - CHANNEL_NAME_LEN - 4 ))
314 		{
315 			/* Zeile wird zu lang: senden! */
316 			if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
317 			sprintf( str, RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
318 		}
319 
320 		/* naechstes Mitglied suchen */
321 		cl2chan = Channel_NextChannelOf( c, cl2chan );
322 	}
323 	if( str[strlen( str ) - 1] != ':')
324 	{
325 		/* Es sind noch Daten da, die gesendet werden muessen */
326 		if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
327 	}
328 	
329 	/* IRC-Operator? */
330 	if( Client_HasMode( c, 'o' ))
331 	{
332 		if( ! IRC_WriteStrClient( from, RPL_WHOISOPERATOR_MSG, Client_ID( from ), Client_ID( c ))) return DISCONNECTED;
333 	}
334 
335 	/* Idle (nur lokale Clients) */
336 	if( Client_Conn( c ) > NONE )
337 	{
338 		if( ! IRC_WriteStrClient( from, RPL_WHOISIDLE_MSG, Client_ID( from ), Client_ID( c ), Conn_GetIdle( Client_Conn ( c )))) return DISCONNECTED;
339 	}
340 
341 	/* Away? */
342 	if( Client_HasMode( c, 'a' ))
343 	{
344 		if( ! IRC_WriteStrClient( from, RPL_AWAY_MSG, Client_ID( from ), Client_ID( c ), Client_Away( c ))) return DISCONNECTED;
345 	}
346 
347 	/* End of Whois */
348 	return IRC_WriteStrClient( from, RPL_ENDOFWHOIS_MSG, Client_ID( from ), Client_ID( c ));
349 } /* IRC_WHOIS */
350 
351 
352 GLOBAL BOOLEAN IRC_WHO( CLIENT *Client, REQUEST *Req )
353 {
354 	BOOLEAN ok, only_ops;
355 	CHAR flags[8], *ptr;
356 	CL2CHAN *cl2chan;
357 	CHANNEL *chan;
358 	CLIENT *c;
359 	
360 	assert( Client != NULL );
361 	assert( Req != NULL );
362 
363 	if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
364 
365 	/* Falsche Anzahl Parameter? */
366 	if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
367 
368 	only_ops = FALSE;
369 	chan = NULL;
370 
371 	if( Req->argc == 2 )
372 	{
373 		/* Nur OPs anzeigen? */
374 		if( strcmp( Req->argv[1], "o" ) == 0 ) only_ops = TRUE;
375 #ifdef STRICT_RFC
376 		else return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
377 #endif
378 	}
379 	
380 	if( Req->argc >= 1 )
381 	{
382 		/* wurde ein Channel oder Nick-Mask angegeben? */
383 		chan = Channel_Search( Req->argv[0] );
384 	}
385 
386 	if( chan )
387 	{
388 		/* User eines Channels ausgeben */
389 		if( ! IRC_Send_WHO( Client, chan, only_ops )) return DISCONNECTED;
390 	}
391 
392 	c = Client_First( );
393 	while( c )
394 	{
395 		if(( Client_Type( c ) == CLIENT_USER ) && ( ! strchr( Client_Modes( c ), 'i' )))
396 		{
397 			ok = FALSE;
398 			if( Req->argc == 0 ) ok = TRUE;
399 			else
400 			{
401 				if( strcasecmp( Req->argv[0], Client_ID( c )) == 0 ) ok = TRUE;
402 				else if( strcmp( Req->argv[0], "0" ) == 0 ) ok = TRUE;
403 			}
404 				
405 			if( ok && (( ! only_ops ) || ( strchr( Client_Modes( c ), 'o' ))))
406 			{
407 				/* Flags zusammenbasteln */
408 				strcpy( flags, "H" );
409 				if( strchr( Client_Modes( c ), 'o' )) strcat( flags, "*" );
410 
411 				/* ausgeben */
412 				cl2chan = Channel_FirstChannelOf( c );
413 				if( cl2chan ) ptr = Channel_Name( Channel_GetChannel( cl2chan ));
414 				else ptr = "*";
415 				if( ! IRC_WriteStrClient( Client, RPL_WHOREPLY_MSG, Client_ID( Client ), ptr, Client_User( c ), Client_Hostname( c ), Client_ID( Client_Introducer( c )), Client_ID( c ), flags, Client_Hops( c ), Client_Info( c ))) return DISCONNECTED;
416 			}
417 		}
418 
419 		/* naechster Client */
420 		c = Client_Next( c );
421 	}
422 
423 	if( chan ) return IRC_WriteStrClient( Client, RPL_ENDOFWHO_MSG, Client_ID( Client ), Channel_Name( chan ));
424 	else if( Req->argc == 0 ) return IRC_WriteStrClient( Client, RPL_ENDOFWHO_MSG, Client_ID( Client ), "*" );
425 	else return IRC_WriteStrClient( Client, RPL_ENDOFWHO_MSG, Client_ID( Client ), Req->argv[0] );
426 } /* IRC_WHO */
427 
428 
429 GLOBAL BOOLEAN IRC_USERHOST( CLIENT *Client, REQUEST *Req )
430 {
431 	CHAR rpl[COMMAND_LEN];
432 	CLIENT *c;
433 	INT max, i;
434 
435 	assert( Client != NULL );
436 	assert( Req != NULL );
437 
438 	if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
439 
440 	/* Falsche Anzahl Parameter? */
441 	if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
442 
443 	if( Req->argc > 5 ) max = 5;
444 	else max = Req->argc;
445 	
446 	strcpy( rpl, RPL_USERHOST_MSG );
447 	for( i = 0; i < max; i++ )
448 	{
449 		c = Client_Search( Req->argv[i] );
450 		if( c && ( Client_Type( c ) == CLIENT_USER ))
451 		{
452 			/* Dieser Nick ist "online" */
453 			strcat( rpl, Client_ID( c ));
454 			if( Client_HasMode( c, 'o' )) strcat( rpl, "*" );
455 			strcat( rpl, "=" );
456 			if( Client_HasMode( c, 'a' )) strcat( rpl, "-" );
457 			else strcat( rpl, "+" );
458 			strcat( rpl, Client_User( c ));
459 			strcat( rpl, "@" );
460 			strcat( rpl, Client_Hostname( c ));
461 			strcat( rpl, " " );
462 		}
463 	}
464 	if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
465 
466 	return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
467 } /* IRC_USERHOST */
468 
469 
470 GLOBAL BOOLEAN IRC_ERROR( CLIENT *Client, REQUEST *Req )
471 {
472 	assert( Client != NULL );
473 	assert( Req != NULL );
474 
475 	if( Req->argc < 1 ) Log( LOG_NOTICE, "Got ERROR from \"%s\"!", Client_Mask( Client ));
476 	else Log( LOG_NOTICE, "Got ERROR from \"%s\": %s!", Client_Mask( Client ), Req->argv[0] );
477 
478 	return CONNECTED;
479 } /* IRC_ERROR */
480 
481 
482 GLOBAL BOOLEAN IRC_LUSERS( CLIENT *Client, REQUEST *Req )
483 {
484 	CLIENT *target, *from;
485 	
486 	assert( Client != NULL );
487 	assert( Req != NULL );
488 
489 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
490 
491 	/* Falsche Anzahl Parameter? */
492 	if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
493 
494 	/* Absender ermitteln */
495 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
496 	else from = Client;
497 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
498 
499 	/* An anderen Server forwarden? */
500 	if( Req->argc == 2 )
501 	{
502 		target = Client_Search( Req->argv[1] );
503 		if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
504 		else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LUSERS %s %s", Req->argv[0], Req->argv[1] );
505 	}
506 
507 	/* Wer ist der Absender? */
508 	if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
509 	else target = Client;
510 	if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
511 	
512 	IRC_Send_LUSERS( target );
513 
514 	return CONNECTED;
515 } /* IRC_LUSERS */
516 
517 
518 GLOBAL BOOLEAN IRC_LINKS( CLIENT *Client, REQUEST *Req )
519 {
520 	CLIENT *target, *from, *c;
521 	CHAR *mask;
522 	
523 	assert( Client != NULL );
524 	assert( Req != NULL );
525 
526 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
527 
528 	/* Falsche Anzahl Parameter? */
529 	if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
530 
531 	/* Server-Mask ermitteln */
532 	if( Req->argc > 0 ) mask = Req->argv[Req->argc - 1];
533 	else mask = "*";
534 
535 	/* Absender ermitteln */
536 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
537 	else from = Client;
538 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
539 	
540 	/* An anderen Server forwarden? */
541 	if( Req->argc == 2 )
542 	{
543 		target = Client_Search( Req->argv[0] );
544 		if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[0] );
545 		else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LINKS %s %s", Req->argv[0], Req->argv[1] );
546 	}
547 
548 	/* Wer ist der Absender? */
549 	if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
550 	else target = Client;
551 	if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
552 	
553 	c = Client_First( );
554 	while( c )
555 	{
556 		if( Client_Type( c ) == CLIENT_SERVER )
557 		{
558 			if( ! IRC_WriteStrClient( target, RPL_LINKS_MSG, Client_ID( target ), Client_ID( c ), Client_ID( Client_TopServer( c ) ? Client_TopServer( c ) : Client_ThisServer( )), Client_Hops( c ), Client_Info( c ))) return DISCONNECTED;
559 		}
560 		c = Client_Next( c );
561 	}
562 	
563 	return IRC_WriteStrClient( target, RPL_ENDOFLINKS_MSG, Client_ID( target ), mask );
564 } /* IRC_LINKS */
565 
566 
567 GLOBAL BOOLEAN IRC_VERSION( CLIENT *Client, REQUEST *Req )
568 {
569 	CLIENT *target, *prefix;
570 	
571 	assert( Client != NULL );
572 	assert( Req != NULL );
573 
574 	/* Falsche Anzahl Parameter? */
575 	if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
576 
577 	/* Ziel suchen */
578 	if( Req->argc == 1 ) target = Client_Search( Req->argv[0] );
579 	else target = Client_ThisServer( );
580 
581 	/* Prefix ermitteln */
582 	if( Client_Type( Client ) == CLIENT_SERVER ) prefix = Client_Search( Req->prefix );
583 	else prefix = Client;
584 	if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->prefix );
585 	
586 	/* An anderen Server weiterleiten? */
587 	if( target != Client_ThisServer( ))
588 	{
589 		if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[0] );
590 
591 		/* forwarden */
592 		IRC_WriteStrClientPrefix( target, prefix, "VERSION %s", Req->argv[0] );
593 		return CONNECTED;
594 	}
595 
596 	/* mit Versionsinfo antworten */
597 	return IRC_WriteStrClient( Client, RPL_VERSION_MSG, Client_ID( prefix ), NGIRCd_DebugLevel, Conf_ServerName, NGIRCd_VersionAddition( ));
598 } /* IRC_VERSION */
599 
600 
601 GLOBAL BOOLEAN IRC_KILL( CLIENT *Client, REQUEST *Req )
602 {
603 	CLIENT *prefix, *c;
604 	
605 	assert( Client != NULL );
606 	assert( Req != NULL );
607 
608 	if( Client_Type( Client ) != CLIENT_SERVER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
609 
610 	/* Falsche Anzahl Parameter? */
611 	if(( Req->argc != 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
612 
613 	prefix = Client_Search( Req->prefix );
614 	if( ! prefix )
615 	{
616 		Log( LOG_WARNING, "Got KILL with invalid prefix: \"%s\"!", Req->prefix );
617 		prefix = Client_ThisServer( );
618 	}
619 	
620 	Log( LOG_NOTICE, "Got KILL command from \"%s\" for \"%s\": %s", Client_Mask( prefix ), Req->argv[0], Req->argv[1] );
621 	
622 	/* andere Server benachrichtigen */
623 	IRC_WriteStrServersPrefix( Client, prefix, "KILL %s :%s", Req->argv[0], Req->argv[1] );
624 
625 	/* haben wir selber einen solchen Client? */
626 	c = Client_Search( Req->argv[0] );
627 	if( c && ( Client_Conn( c ) != NONE )) Conn_Close( Client_Conn( c ), NULL, Req->argv[1], TRUE );
628 	
629 	return CONNECTED;
630 } /* IRC_KILL */
631 
632 
633 GLOBAL BOOLEAN IRC_Show_MOTD( CLIENT *Client )
634 {
635 	BOOLEAN ok;
636 	CHAR line[127];
637 	FILE *fd;
638 	
639 	assert( Client != NULL );
640 
641 	fd = fopen( Conf_MotdFile, "r" );
642 	if( ! fd )
643 	{
644 		Log( LOG_WARNING, "Can't read MOTD file \"%s\": %s", Conf_MotdFile, strerror( errno ));
645 		return IRC_WriteStrClient( Client, ERR_NOMOTD_MSG, Client_ID( Client ) );
646 	}
647 	
648 	IRC_WriteStrClient( Client, RPL_MOTDSTART_MSG, Client_ID( Client ), Client_ID( Client_ThisServer( )));
649 	while( TRUE )
650 	{
651 		if( ! fgets( line, 126, fd )) break;
652 		if( line[strlen( line ) - 1] == '\n' ) line[strlen( line ) - 1] = '\0';
653 		if( ! IRC_WriteStrClient( Client, RPL_MOTD_MSG, Client_ID( Client ), line ))
654 		{
655 			fclose( fd );
656 			return FALSE;
657 		}
658 	}
659 	ok = IRC_WriteStrClient( Client, RPL_ENDOFMOTD_MSG, Client_ID( Client ) );
660 
661 	fclose( fd );
662 	
663 	return ok;
664 } /* IRC_Show_MOTD */
665 
666 
667 GLOBAL BOOLEAN IRC_Send_NAMES( CLIENT *Client, CHANNEL *Chan )
668 {
669 	BOOLEAN is_visible, is_member;
670 	CHAR str[LINE_LEN + 1];
671 	CL2CHAN *cl2chan;
672 	CLIENT *cl;
673 	
674 	assert( Client != NULL );
675 	assert( Chan != NULL );
676 
677 	if( Channel_IsMemberOf( Chan, Client )) is_member = TRUE;
678 	else is_member = FALSE;
679 			 
680 	/* Alle Mitglieder suchen */
681 	sprintf( str, RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
682 	cl2chan = Channel_FirstMember( Chan );
683 	while( cl2chan )
684 	{
685 		cl = Channel_GetClient( cl2chan );
686 
687 		if( strchr( Client_Modes( cl ), 'i' )) is_visible = FALSE;
688 		else is_visible = TRUE;
689 
690 		if( is_member || is_visible )
691 		{
692 			/* Nick anhaengen */
693 			if( str[strlen( str ) - 1] != ':' ) strcat( str, " " );
694 			if( strchr( Channel_UserModes( Chan, cl ), 'o' )) strcat( str, "@" );
695 			else if( strchr( Channel_UserModes( Chan, cl ), 'v' )) strcat( str, "+" );
696 			strcat( str, Client_ID( cl ));
697 	
698 			if( strlen( str ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
699 			{
700 				/* Zeile wird zu lang: senden! */
701 				if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
702 				sprintf( str, RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
703 			}
704 		}
705 
706 		/* naechstes Mitglied suchen */
707 		cl2chan = Channel_NextMember( Chan, cl2chan );
708 	}
709 	if( str[strlen( str ) - 1] != ':')
710 	{
711 		/* Es sind noch Daten da, die gesendet werden muessen */
712 		if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
713 	}
714 
715 	return CONNECTED;
716 } /* IRC_Send_NAMES */
717 
718 
719 GLOBAL BOOLEAN IRC_Send_WHO( CLIENT *Client, CHANNEL *Chan, BOOLEAN OnlyOps )
720 {
721 	BOOLEAN is_visible, is_member;
722 	CL2CHAN *cl2chan;
723 	CHAR flags[8];
724 	CLIENT *c;
725 
726 	assert( Client != NULL );
727 	assert( Chan != NULL );
728 
729 	if( Channel_IsMemberOf( Chan, Client )) is_member = TRUE;
730 	else is_member = FALSE;
731 
732 	/* Alle Mitglieder suchen */
733 	cl2chan = Channel_FirstMember( Chan );
734 	while( cl2chan )
735 	{
736 		c = Channel_GetClient( cl2chan );
737 
738 		if( strchr( Client_Modes( c ), 'i' )) is_visible = FALSE;
739 		else is_visible = TRUE;
740 
741 		if( is_member || is_visible )
742 		{
743 			/* Flags zusammenbasteln */
744 			strcpy( flags, "H" );
745 			if( strchr( Client_Modes( c ), 'o' )) strcat( flags, "*" );
746 			if( strchr( Channel_UserModes( Chan, c ), 'o' )) strcat( flags, "@" );
747 			else if( strchr( Channel_UserModes( Chan, c ), 'v' )) strcat( flags, "+" );
748 			
749 			/* ausgeben */
750 			if(( ! OnlyOps ) || ( strchr( Client_Modes( c ), 'o' )))
751 			{
752 				if( ! IRC_WriteStrClient( Client, RPL_WHOREPLY_MSG, Client_ID( Client ), Channel_Name( Chan ), Client_User( c ), Client_Hostname( c ), Client_ID( Client_Introducer( c )), Client_ID( c ), flags, Client_Hops( c ), Client_Info( c ))) return DISCONNECTED;
753 			}
754 		}
755 
756 		/* naechstes Mitglied suchen */
757 		cl2chan = Channel_NextMember( Chan, cl2chan );
758 	}
759 	return CONNECTED;
760 } /* IRC_Send_WHO */
761 
762 
763 GLOBAL BOOLEAN IRC_Send_LUSERS( CLIENT *Client )
764 {
765 	INT cnt;
766 
767 	assert( Client != NULL );
768 
769 	/* Users, Services und Serevr im Netz */
770 	if( ! IRC_WriteStrClient( Client, RPL_LUSERCLIENT_MSG, Client_ID( Client ), Client_UserCount( ), Client_ServiceCount( ), Client_ServerCount( ))) return DISCONNECTED;
771 
772 	/* IRC-Operatoren im Netz */
773 	cnt = Client_OperCount( );
774 	if( cnt > 0 )
775 	{
776 		if( ! IRC_WriteStrClient( Client, RPL_LUSEROP_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
777 	}
778 
779 	/* Unbekannt Verbindungen */
780 	cnt = Client_UnknownCount( );
781 	if( cnt > 0 )
782 	{
783 		if( ! IRC_WriteStrClient( Client, RPL_LUSERUNKNOWN_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
784 	}
785 
786 	/* Channels im Netz */
787 	if( ! IRC_WriteStrClient( Client, RPL_LUSERCHANNELS_MSG, Client_ID( Client ), Channel_Count( ))) return DISCONNECTED;
788 
789 	/* Channels im Netz */
790 	if( ! IRC_WriteStrClient( Client, RPL_LUSERME_MSG, Client_ID( Client ), Client_MyUserCount( ), Client_MyServiceCount( ), Client_MyServerCount( ))) return DISCONNECTED;
791 	
792 	return CONNECTED;
793 } /* IRC_Send_LUSERS */
794 
795 
796 /* -eof- */