Made on IRCNow

Blob

Date:: Mon Sep 16 09:16:17 2002 UTC
Message:: - LIST kann nun auch an andere Server geforwarded werden.
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-channel.c,v 1.15 2002/09/16 09:16:17 alex Exp $
13  *
14  * irc-channel.c: IRC-Channel-Befehle
15  */
16 
17 
18 #include "portab.h"
19 
20 #include "imp.h"
21 #include <assert.h>
22 #include <string.h>
23 
24 #include "defines.h"
25 #include "conn.h"
26 #include "client.h"
27 #include "channel.h"
28 #include "lists.h"
29 #include "log.h"
30 #include "match.h"
31 #include "messages.h"
32 #include "parse.h"
33 #include "irc.h"
34 #include "irc-write.h"
35 
36 #include "exp.h"
37 #include "irc-channel.h"
38 
39 
40 GLOBAL BOOLEAN
41 IRC_JOIN( CLIENT *Client, REQUEST *Req )
42 {
43 	CHAR *channame, *flags, *topic, modes[8];
44 	BOOLEAN is_new_chan, is_invited, is_banned;
45 	CLIENT *target;
46 	CHANNEL *chan;
47 
48 	assert( Client != NULL );
49 	assert( Req != NULL );
50 
51 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
52 
53 	/* Falsche Anzahl Parameter? */
54 	if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
55 
56 	/* Wer ist der Absender? */
57 	if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
58 	else target = Client;
59 	if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
60 
61 	/* Channel-Namen durchgehen */
62 	chan = NULL;
63 	channame = strtok( Req->argv[0], "," );
64 	while( channame )
65 	{
66 		chan = flags = NULL;
67 
68 		/* wird der Channel neu angelegt? */
69 		if( Channel_Search( channame )) is_new_chan = FALSE;
70 		else is_new_chan = TRUE;
71 
72 		/* Hat ein Server Channel-User-Modes uebergeben? */
73 		if( Client_Type( Client ) == CLIENT_SERVER )
74 		{
75 			/* Channel-Flags extrahieren */
76 			flags = strchr( channame, 0x7 );
77 			if( flags )
78 			{
79 				*flags = '\0';
80 				flags++;
81 			}
82 		}
83 
84 		/* Lokaler Client? */
85 		if( Client_Type( Client ) == CLIENT_USER )
86 		{
87 			/* Existiert der Channel bereits, oder wird er im Moment neu erzeugt? */
88 			if( is_new_chan )
89 			{
90 				/* Erster User im Channel: Operator-Flag setzen */
91 				flags = "o";
92 			}
93 			else
94 			{
95 				/* Existierenden Channel suchen */
96 				chan = Channel_Search( channame );
97 				assert( chan != NULL );
98 
99 				is_banned = Lists_CheckBanned( target, chan );
100 				is_invited = Lists_CheckInvited( target, chan );
101 
102 				/* Testen, ob Client gebanned ist */
103 				if(( is_banned == TRUE ) &&  ( is_invited == FALSE ))
104 				{
105 					/* Client ist gebanned (und nicht invited): */
106 					IRC_WriteStrClient( Client, ERR_BANNEDFROMCHAN_MSG, Client_ID( Client ), channame );
107 
108 					/* naechsten Namen ermitteln */
109 					channame = strtok( NULL, "," );
110 					continue;
111 				}
112 
113 				/* Ist der Channel "invite-only"? */
114 				if(( strchr( Channel_Modes( chan ), 'i' ) != NULL ) && ( is_invited == FALSE ))
115 				{
116 					/* Channel ist "invite-only" und Client wurde nicht invited: */
117 					IRC_WriteStrClient( Client, ERR_INVITEONLYCHAN_MSG, Client_ID( Client ), channame );
118 
119 					/* naechsten Namen ermitteln */
120 					channame = strtok( NULL, "," );
121 					continue;
122 				}
123 			}
124 		}
125 
126 		/* Channel joinen (und ggf. anlegen) */
127 		if( ! Channel_Join( target, channame ))
128 		{
129 			/* naechsten Namen ermitteln */
130 			channame = strtok( NULL, "," );
131 			continue;
132 		}
133 		if( ! chan ) chan = Channel_Search( channame );
134 		assert( chan != NULL );
135 
136 		/* Modes setzen (wenn vorhanden) */
137 		while( flags && *flags )
138 		{
139 			Channel_UserModeAdd( chan, target, *flags );
140 			flags++;
141 		}
142 
143 		/* Wenn persistenter Channel und IRC-Operator: zum Channel-OP machen */
144 		if(( strchr( Channel_Modes( chan ), 'P' )) && ( strchr( Client_Modes( target ), 'o' ))) Channel_UserModeAdd( chan, target, 'o' );
145 
146 		/* Muessen Modes an andere Server gemeldet werden? */
147 		strcpy( &modes[1], Channel_UserModes( chan, target ));
148 		if( modes[1] ) modes[0] = 0x7;
149 		else modes[0] = '\0';
150 
151 		/* An andere Server weiterleiten */
152 		IRC_WriteStrServersPrefix( Client, target, "JOIN :%s%s", channame, modes );
153 
154 		/* im Channel bekannt machen */
155 		IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "JOIN :%s", channame );
156 		if( modes[1] )
157 		{
158 			/* Modes im Channel bekannt machen */
159 			IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "MODE %s +%s %s", channame, &modes[1], Client_ID( target ));
160 		}
161 
162 		if( Client_Type( Client ) == CLIENT_USER )
163 		{
164 			/* an Client bestaetigen */
165 			IRC_WriteStrClientPrefix( Client, target, "JOIN :%s", channame );
166 
167 			/* Topic an Client schicken */
168 			topic = Channel_Topic( chan );
169 			if( *topic ) IRC_WriteStrClient( Client, RPL_TOPIC_MSG, Client_ID( Client ), channame, topic );
170 
171 			/* Mitglieder an Client Melden */
172 			IRC_Send_NAMES( Client, chan );
173 			IRC_WriteStrClient( Client, RPL_ENDOFNAMES_MSG, Client_ID( Client ), Channel_Name( chan ));
174 		}
175 
176 		/* naechsten Namen ermitteln */
177 		channame = strtok( NULL, "," );
178 	}
179 	return CONNECTED;
180 } /* IRC_JOIN */
181 
182 
183 GLOBAL BOOLEAN
184 IRC_PART( CLIENT *Client, REQUEST *Req )
185 {
186 	CLIENT *target;
187 	CHAR *chan;
188 
189 	assert( Client != NULL );
190 	assert( Req != NULL );
191 
192 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
193 
194 	/* Falsche Anzahl Parameter? */
195 	if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
196 
197 	/* Wer ist der Absender? */
198 	if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
199 	else target = Client;
200 	if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
201 
202 	/* Channel-Namen durchgehen */
203 	chan = strtok( Req->argv[0], "," );
204 	while( chan )
205 	{
206 		if( ! Channel_Part( target, Client, chan, Req->argc > 1 ? Req->argv[1] : Client_ID( target )))
207 		{
208 			/* naechsten Namen ermitteln */
209 			chan = strtok( NULL, "," );
210 			continue;
211 		}
212 
213 		/* naechsten Namen ermitteln */
214 		chan = strtok( NULL, "," );
215 	}
216 	return CONNECTED;
217 } /* IRC_PART */
218 
219 
220 GLOBAL BOOLEAN
221 IRC_TOPIC( CLIENT *Client, REQUEST *Req )
222 {
223 	CHANNEL *chan;
224 	CLIENT *from;
225 	CHAR *topic;
226 
227 	assert( Client != NULL );
228 	assert( Req != NULL );
229 
230 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
231 
232 	/* Falsche Anzahl Parameter? */
233 	if(( Req->argc < 1 ) || ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
234 
235 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
236 	else from = Client;
237 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
238 
239 	/* Welcher Channel? */
240 	chan = Channel_Search( Req->argv[0] );
241 	if( ! chan ) return IRC_WriteStrClient( from, ERR_NOSUCHCHANNEL_MSG, Client_ID( from ), Req->argv[0] );
242 
243 	/* Ist der User Mitglied in dem Channel? */
244 	if( ! Channel_IsMemberOf( chan, from )) return IRC_WriteStrClient( from, ERR_NOTONCHANNEL_MSG, Client_ID( from ), Req->argv[0] );
245 
246 	if( Req->argc == 1 )
247 	{
248 		/* Topic erfragen */
249 		topic = Channel_Topic( chan );
250 		if( *topic ) return IRC_WriteStrClient( from, RPL_TOPIC_MSG, Client_ID( from ), Channel_Name( chan ), topic );
251 		else return IRC_WriteStrClient( from, RPL_NOTOPIC_MSG, Client_ID( from ), Channel_Name( chan ));
252 	}
253 
254 	if( strchr( Channel_Modes( chan ), 't' ))
255 	{
256 		/* Topic Lock. Ist der User ein Channel Operator? */
257 		if( ! strchr( Channel_UserModes( chan, from ), 'o' )) return IRC_WriteStrClient( from, ERR_CHANOPRIVSNEEDED_MSG, Client_ID( from ), Channel_Name( chan ));
258 	}
259 
260 	/* Topic setzen */
261 	Channel_SetTopic( chan, Req->argv[1] );
262 	Log( LOG_DEBUG, "User \"%s\" set topic on \"%s\": %s", Client_Mask( from ), Channel_Name( chan ), Req->argv[1][0] ? Req->argv[1] : "<none>" );
263 
264 	/* im Channel bekannt machen und an Server weiterleiten */
265 	IRC_WriteStrServersPrefix( Client, from, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
266 	IRC_WriteStrChannelPrefix( Client, chan, from, FALSE, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
267 
268 	if( Client_Type( Client ) == CLIENT_USER ) return IRC_WriteStrClientPrefix( Client, Client, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
269 	else return CONNECTED;
270 } /* IRC_TOPIC */
271 
272 
273 GLOBAL BOOLEAN
274 IRC_LIST( CLIENT *Client, REQUEST *Req )
275 {
276 	CHAR *pattern;
277 	CHANNEL *chan;
278 	CLIENT *from, *target;
279 
280 	assert( Client != NULL );
281 	assert( Req != NULL );
282 
283 	if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
284 
285 	/* Falsche Anzahl Parameter? */
286 	if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
287 
288 	if( Req->argc > 0 ) pattern = strtok( Req->argv[0], "," );
289 	else pattern = "*";
290 
291 	/* From aus Prefix ermitteln */
292 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
293 	else from = Client;
294 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->prefix );
295 
296 	if( Req->argc == 2 )
297 	{
298 		/* an anderen Server forwarden */
299 		target = Client_Search( Req->argv[1] );
300 		if( ! target ) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
301 
302 		if( target != Client_ThisServer( ))
303 		{
304 			/* Ok, anderer Server ist das Ziel: forwarden */
305 			return IRC_WriteStrClientPrefix( target, from, "LIST %s :%s", from, Req->argv[1] );
306 		}
307 	}
308 	
309 	while( pattern )
310 	{
311 		/* alle Channel durchgehen */
312 		chan = Channel_First( );
313 		while( chan )
314 		{
315 			/* Passt die Suchmaske auf diesen Channel? */
316 			if( Match( pattern, Channel_Name( chan )))
317 			{
318 				/* Treffer! */
319 				if( ! IRC_WriteStrClient( from, RPL_LIST_MSG, from, Channel_Name( chan ), Channel_MemberCount( chan ), Channel_Topic( chan ))) return DISCONNECTED;
320 			}
321 			chan = Channel_Next( chan );
322 		}
323 		
324 		/* naechsten Namen ermitteln */
325 		if( Req->argc > 0 ) pattern = strtok( NULL, "," );
326 		else pattern = NULL;
327 	}
328 	
329 	return IRC_WriteStrClient( from, RPL_LISTEND_MSG, from );
330 } /* IRC_LIST */
331 
332 
333 GLOBAL BOOLEAN
334 IRC_CHANINFO( CLIENT *Client, REQUEST *Req )
335 {
336 	CLIENT *from;
337 	CHANNEL *chan;
338 	CHAR *ptr;
339 
340 	assert( Client != NULL );
341 	assert( Req != NULL );
342 
343 	if( Client_Type( Client ) != CLIENT_SERVER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
344 
345 	/* Falsche Anzahl Parameter? */
346 	if(( Req->argc < 1 ) || ( Req->argc > 3 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
347 
348 	/* From-Server suchen */
349 	from = Client_Search( Req->prefix );
350 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
351 
352 	/* Channel suchen bzw. erzeugen */
353 	chan = Channel_Search( Req->argv[0] );
354 	if( ! chan ) chan = Channel_Create( Req->argv[0] );
355 	if( ! chan ) return CONNECTED;
356 
357 	if( Req->argv[1][0] == '+' )
358 	{
359 		ptr = Channel_Modes( chan );
360 		if( ! *ptr )
361 		{
362 			/* OK, es sind noch keine Modes gesetzt */
363 			Channel_SetModes( chan, &Req->argv[1][1] );
364 			IRC_WriteStrChannelPrefix( Client, chan, from, FALSE, "MODE %s +%s", Req->argv[0], &Req->argv[1][1] );
365 		}
366 	}
367 	else Log( LOG_WARNING, "CHANNELINFO: invalid MODE format ignored!" );
368 
369 	if( Req->argc == 3 )
370 	{
371 		/* Es wurde auch ein Topic mit uebermittelt */
372 		ptr = Channel_Topic( chan );
373 		if( ! *ptr )
374 		{
375 			/* OK, es ist bisher kein Topic gesetzt */
376 			Channel_SetTopic( chan, Req->argv[2] );
377 			IRC_WriteStrChannelPrefix( Client, chan, from, FALSE, "TOPIC %s :%s", Req->argv[0], Req->argv[2] );
378 		}
379 	}
380 
381 	/* an andere Server forwarden */
382 	IRC_WriteStrServersPrefixFlag( Client, from, 'C', "CHANINFO %s %s :%s", Req->argv[0], Req->argv[1], Req->argv[2] );
383 	return CONNECTED;
384 } /* IRC_CHANINFO */
385 
386 
387 /* -eof- */