Made on IRCNow

Blob

Date:: Mon Mar 25 16:54:26 2002 UTC
Message:: - New_Chan() berechnet Hash-Werte ueber den Namen. - Channel_Search() verwendet nun Hash-Werte. - Neue Funktion Channel_Write().
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: channel.c,v 1.20 2002/03/25 16:54:26 alex Exp $
13  *
14  * channel.c: Management der Channels
15  */
16 
17 
18 #define __channel_c__
19 
20 
21 #include "portab.h"
22 
23 #include "imp.h"
24 #include <assert.h>
25 #include <stdlib.h>
26 #include <string.h>
27 
28 #include "client.h"
29 #include "hash.h"
30 #include "irc-write.h"
31 #include "log.h"
32 #include "messages.h"
33 
34 #include "exp.h"
35 #include "channel.h"
36 
37 
38 LOCAL CHANNEL *My_Channels;
39 LOCAL CL2CHAN *My_Cl2Chan;
40 
41 
42 LOCAL CHANNEL *New_Chan( CHAR *Name );
43 LOCAL CL2CHAN *Get_Cl2Chan( CHANNEL *Chan, CLIENT *Client );
44 LOCAL CL2CHAN *Add_Client( CHANNEL *Chan, CLIENT *Client );
45 LOCAL BOOLEAN Remove_Client( CHANNEL *Chan, CLIENT *Client, CLIENT *Origin, CHAR *Reason, BOOLEAN ServerPART );
46 LOCAL CL2CHAN *Get_First_Cl2Chan( CLIENT *Client, CHANNEL *Chan );
47 LOCAL CL2CHAN *Get_Next_Cl2Chan( CL2CHAN *Start, CLIENT *Client, CHANNEL *Chan );
48 LOCAL BOOLEAN Delete_Channel( CHANNEL *Chan );
49 
50 
51 GLOBAL VOID Channel_Init( VOID )
52 {
53 	My_Channels = NULL;
54 	My_Cl2Chan = NULL;
55 } /* Channel_Init */
56 
57 
58 GLOBAL VOID Channel_Exit( VOID )
59 {
60 	CHANNEL *c, *c_next;
61 	CL2CHAN *cl2chan, *cl2chan_next;
62 	
63 	/* Channel-Strukturen freigeben */
64 	c = My_Channels;
65 	while( c )
66 	{
67 		c_next = c->next;
68 		free( c );
69 		c = c_next;
70 	}
71 
72 	/* Channel-Zuordnungstabelle freigeben */
73 	cl2chan = My_Cl2Chan;
74 	while( c )
75 	{
76 		cl2chan_next = cl2chan->next;
77 		free( cl2chan );
78 		cl2chan = cl2chan_next;
79 	}
80 } /* Channel_Exit */
81 
82 
83 GLOBAL BOOLEAN Channel_Join( CLIENT *Client, CHAR *Name )
84 {
85 	CHANNEL *chan;
86 	
87 	assert( Client != NULL );
88 	assert( Name != NULL );
89 
90 	/* Valider Channel-Name? */
91 	if( ! Channel_IsValidName( Name ))
92 	{
93 		IRC_WriteStrClient( Client, ERR_NOSUCHCHANNEL_MSG, Client_ID( Client ), Name );
94 		return FALSE;
95 	}
96 
97 	/* Channel suchen */
98 	chan = Channel_Search( Name );
99 	if( chan )
100 	{
101 		/* Ist der Client bereits Mitglied? */
102 		if( Get_Cl2Chan( chan, Client )) return FALSE;
103 	}
104 	else
105 	{
106 		/* Gibt es noch nicht? Dann neu anlegen: */
107 		chan = New_Chan( Name );
108 		if( ! chan ) return FALSE;
109 
110 		/* Verketten */
111 		chan->next = My_Channels;
112 		My_Channels = chan;
113 	}
114 
115 	/* User dem Channel hinzufuegen */
116 	if( ! Add_Client( chan, Client )) return FALSE;
117 	else return TRUE;
118 } /* Channel_Join */
119 
120 
121 GLOBAL BOOLEAN Channel_Part( CLIENT *Client, CLIENT *Origin, CHAR *Name, CHAR *Reason )
122 {
123 	CHANNEL *chan;
124 
125 	assert( Client != NULL );
126 	assert( Name != NULL );
127 
128 	/* Channel suchen */
129 	chan = Channel_Search( Name );
130 	if(( ! chan ) || ( ! Get_Cl2Chan( chan, Client )))
131 	{
132 		IRC_WriteStrClient( Client, ERR_NOSUCHCHANNEL_MSG, Client_ID( Client ), Name );
133 		return FALSE;
134 	}
135 
136 	/* User aus Channel entfernen */
137 	if( ! Remove_Client( chan, Client, Origin, Reason, TRUE )) return FALSE;
138 	else return TRUE;
139 } /* Channel_Part */
140 
141 
142 GLOBAL VOID Channel_RemoveClient( CLIENT *Client, CHAR *Reason )
143 {
144 	CHANNEL *c, *next_c;
145 
146 	assert( Client != NULL );
147 
148 	c = My_Channels;
149 	while( c )
150 	{
151 		next_c = c->next;
152 		Remove_Client( c, Client, Client_ThisServer( ), Reason, FALSE );
153 		c = next_c;
154 	}
155 } /* Channel_RemoveClient */
156 
157 
158 GLOBAL INT Channel_Count( VOID )
159 {
160 	CHANNEL *c;
161 	INT count;
162 	
163 	count = 0;
164 	c = My_Channels;
165 	while( c )
166 	{
167 		count++;
168 		c = c->next;
169 	}
170 	return count;
171 } /* Channel_Count */
172 
173 
174 GLOBAL CHAR *Channel_Name( CHANNEL *Chan )
175 {
176 	assert( Chan != NULL );
177 	return Chan->name;
178 } /* Channel_Name */
179 
180 
181 GLOBAL CHAR *Channel_Modes( CHANNEL *Chan )
182 {
183 	assert( Chan != NULL );
184 	return Chan->modes;
185 } /* Channel_Modes */
186 
187 
188 GLOBAL CHANNEL *Channel_First( VOID )
189 {
190 	return My_Channels;
191 } /* Channel_First */
192 
193 
194 GLOBAL CHANNEL *Channel_Next( CHANNEL *Chan )
195 {
196 	assert( Chan != NULL );
197 	return Chan->next;
198 } /* Channel_Next */
199 
200 
201 GLOBAL CHANNEL *Channel_Search( CHAR *Name )
202 {
203 	/* Channel-Struktur suchen */
204 	
205 	CHANNEL *c;
206 	UINT32 search_hash;
207 
208 	assert( Name != NULL );
209 
210 	search_hash = Hash( Name );
211 	c = My_Channels;
212 	while( c )
213 	{
214 		if( search_hash == c->hash )
215 		{
216 			/* lt. Hash-Wert: Treffer! */
217 			if( strcasecmp( Name, c->name ) == 0 ) return c;
218 		}
219 		c = c->next;
220 	}
221 	return NULL;
222 } /* Channel_Search */
223 
224 
225 GLOBAL CL2CHAN *Channel_FirstMember( CHANNEL *Chan )
226 {
227 	assert( Chan != NULL );
228 	return Get_First_Cl2Chan( NULL, Chan );
229 } /* Channel_FirstMember */
230 
231 
232 GLOBAL CL2CHAN *Channel_NextMember( CHANNEL *Chan, CL2CHAN *Cl2Chan )
233 {
234 	assert( Chan != NULL );
235 	assert( Cl2Chan != NULL );
236 	return Get_Next_Cl2Chan( Cl2Chan->next, NULL, Chan );
237 } /* Channel_NextMember */
238 
239 
240 GLOBAL CL2CHAN *Channel_FirstChannelOf( CLIENT *Client )
241 {
242 	assert( Client != NULL );
243 	return Get_First_Cl2Chan( Client, NULL );
244 } /* Channel_FirstChannelOf */
245 
246 
247 GLOBAL CL2CHAN *Channel_NextChannelOf( CLIENT *Client, CL2CHAN *Cl2Chan )
248 {
249 	assert( Client != NULL );
250 	assert( Cl2Chan != NULL );
251 	return Get_Next_Cl2Chan( Cl2Chan->next, Client, NULL );
252 } /* Channel_NextChannelOf */
253 
254 
255 GLOBAL CLIENT *Channel_GetClient( CL2CHAN *Cl2Chan )
256 {
257 	assert( Cl2Chan != NULL );
258 	return Cl2Chan->client;
259 } /* Channel_GetClient */
260 
261 
262 GLOBAL CHANNEL *Channel_GetChannel( CL2CHAN *Cl2Chan )
263 {
264 	assert( Cl2Chan != NULL );
265 	return Cl2Chan->channel;
266 } /* Channel_GetChannel */
267 
268 
269 GLOBAL BOOLEAN Channel_IsValidName( CHAR *Name )
270 {
271 	/* Pr�fen, ob Name als Channelname gueltig */
272 
273 	CHAR *ptr, badchars[] = " ,:\x07";
274 	
275 	assert( Name != NULL );
276 
277 	if(( Name[0] != '#' ) || ( strlen( Name ) >= CHANNEL_NAME_LEN )) return FALSE;
278 
279 	ptr = Name;
280 	while( *ptr )
281 	{
282 		if( strchr( badchars, *ptr )) return FALSE;
283 		ptr++;
284 	}
285 	
286 	return TRUE;
287 } /* Channel_IsValidName */
288 
289 
290 GLOBAL BOOLEAN Channel_ModeAdd( CHANNEL *Chan, CHAR Mode )
291 {
292 	/* Mode soll gesetzt werden. TRUE wird geliefert, wenn der
293 	 * Mode neu gesetzt wurde, FALSE, wenn der Channel den Mode
294 	 * bereits hatte. */
295 
296 	CHAR x[2];
297 
298 	assert( Chan != NULL );
299 
300 	x[0] = Mode; x[1] = '\0';
301 	if( ! strchr( Chan->modes, x[0] ))
302 	{
303 		/* Client hat den Mode noch nicht -> setzen */
304 		strcat( Chan->modes, x );
305 		return TRUE;
306 	}
307 	else return FALSE;
308 } /* Channel_ModeAdd */
309 
310 
311 GLOBAL BOOLEAN Channel_ModeDel( CHANNEL *Chan, CHAR Mode )
312 {
313 	/* Mode soll geloescht werden. TRUE wird geliefert, wenn der
314 	 * Mode entfernt wurde, FALSE, wenn der Channel den Mode
315 	 * ueberhaupt nicht hatte. */
316 
317 	CHAR x[2], *p;
318 
319 	assert( Chan != NULL );
320 
321 	x[0] = Mode; x[1] = '\0';
322 
323 	p = strchr( Chan->modes, x[0] );
324 	if( ! p ) return FALSE;
325 
326 	/* Client hat den Mode -> loeschen */
327 	while( *p )
328 	{
329 		*p = *(p + 1);
330 		p++;
331 	}
332 	return TRUE;
333 } /* Channel_ModeDel */
334 
335 
336 GLOBAL BOOLEAN Channel_UserModeAdd( CHANNEL *Chan, CLIENT *Client, CHAR Mode )
337 {
338 	/* Channel-User-Mode soll gesetzt werden. TRUE wird geliefert,
339 	 * wenn der Mode neu gesetzt wurde, FALSE, wenn der User den
340 	 * Channel-Mode bereits hatte. */
341 
342 	CL2CHAN *cl2chan;
343 	CHAR x[2];
344 
345 	assert( Chan != NULL );
346 	assert( Client != NULL );
347 
348 	cl2chan = Get_Cl2Chan( Chan, Client );
349 	assert( cl2chan != NULL );
350 	
351 	x[0] = Mode; x[1] = '\0';
352 	if( ! strchr( cl2chan->modes, x[0] ))
353 	{
354 		/* Client hat den Mode noch nicht -> setzen */
355 		strcat( cl2chan->modes, x );
356 		return TRUE;
357 	}
358 	else return FALSE;
359 } /* Channel_UserModeAdd */
360 
361 
362 GLOBAL BOOLEAN Channel_UserModeDel( CHANNEL *Chan, CLIENT *Client, CHAR Mode )
363 {
364 	/* Channel-User-Mode soll geloescht werden. TRUE wird geliefert,
365 	 * wenn der Mode entfernt wurde, FALSE, wenn der User den Channel-Mode
366 	 * ueberhaupt nicht hatte. */
367 
368 	CL2CHAN *cl2chan;
369 	CHAR x[2], *p;
370 
371 	assert( Chan != NULL );
372 	assert( Client != NULL );
373 
374 	cl2chan = Get_Cl2Chan( Chan, Client );
375 	assert( cl2chan != NULL );
376 
377 	x[0] = Mode; x[1] = '\0';
378 
379 	p = strchr( cl2chan->modes, x[0] );
380 	if( ! p ) return FALSE;
381 
382 	/* Client hat den Mode -> loeschen */
383 	while( *p )
384 	{
385 		*p = *(p + 1);
386 		p++;
387 	}
388 	return TRUE;
389 } /* Channel_UserModeDel */
390 
391 
392 GLOBAL CHAR *Channel_UserModes( CHANNEL *Chan, CLIENT *Client )
393 {
394 	/* Channel-Modes eines Users liefern */
395 	
396 	CL2CHAN *cl2chan;
397 
398 	assert( Chan != NULL );
399 	assert( Client != NULL );
400 
401 	cl2chan = Get_Cl2Chan( Chan, Client );
402 	assert( cl2chan != NULL );
403 
404 	return cl2chan->modes;
405 } /* Channel_UserModes */
406 
407 
408 GLOBAL BOOLEAN Channel_IsMemberOf( CHANNEL *Chan, CLIENT *Client )
409 {
410 	/* Pruefen, ob Client Mitglied in Channel ist */
411 
412 	assert( Chan != NULL );
413 	assert( Client != NULL );
414 
415 	if( Get_Cl2Chan( Chan, Client )) return TRUE;
416 	else return FALSE;
417 } /* Channel_IsMemberOf */
418 
419 
420 GLOBAL CHAR *Channel_Topic( CHANNEL *Chan )
421 {
422 	assert( Chan != NULL );
423 	return Chan->topic;
424 } /* Channel_Topic */
425 
426 
427 GLOBAL VOID Channel_SetTopic( CHANNEL *Chan, CHAR *Topic )
428 {
429 	assert( Chan != NULL );
430 	assert( Topic != NULL );
431 	
432 	strncpy( Chan->topic, Topic, CHANNEL_TOPIC_LEN - 1 );
433 	Chan->topic[CHANNEL_TOPIC_LEN - 1] = '\0';
434 } /* Channel_SetTopic */
435 
436 
437 GLOBAL BOOLEAN Channel_Write( CHANNEL *Chan, CLIENT *From, CLIENT *Client, CHAR *Text )
438 {
439 	BOOLEAN is_member, has_voice, is_op, ok;
440 
441 	/* Okay, Ziel ist ein Channel */
442 	is_member = has_voice = is_op = FALSE;
443 	if( Channel_IsMemberOf( Chan, From ))
444 	{
445 		is_member = TRUE;
446 		if( strchr( Channel_UserModes( Chan, From ), 'v' )) has_voice = TRUE;
447 		if( strchr( Channel_UserModes( Chan, From ), 'o' )) is_op = TRUE;
448 	}
449 
450 	/* pruefen, ob Client in Channel schreiben darf */
451 	ok = TRUE;
452 	if( strchr( Channel_Modes( Chan ), 'n' ) && ( ! is_member )) ok = FALSE;
453 	if( strchr( Channel_Modes( Chan ), 'm' ) && ( ! is_op ) && ( ! has_voice )) ok = FALSE;
454 
455 	if( ! ok ) return IRC_WriteStrClient( From, ERR_CANNOTSENDTOCHAN_MSG, Client_ID( From ), Channel_Name( Chan ));
456 
457 	/* Text senden */
458 	if( Client_Conn( From ) > NONE ) Conn_UpdateIdle( Client_Conn( From ));
459 	return IRC_WriteStrChannelPrefix( Client, Chan, From, TRUE, "PRIVMSG %s :%s", Channel_Name( Chan ), Text );
460 } /* Channel_Write */
461 
462 
463 
464 LOCAL CHANNEL *New_Chan( CHAR *Name )
465 {
466 	/* Neue Channel-Struktur anlegen */
467 
468 	CHANNEL *c;
469 
470 	assert( Name != NULL );
471 	
472 	c = malloc( sizeof( CHANNEL ));
473 	if( ! c )
474 	{
475 		Log( LOG_EMERG, "Can't allocate memory!" );
476 		return NULL;
477 	}
478 	c->next = NULL;
479 	strncpy( c->name, Name, CHANNEL_NAME_LEN - 1 );
480 	c->name[CHANNEL_NAME_LEN - 1] = '\0';
481 	strcpy( c->modes, "" );
482 	strcpy( c->topic, "" );
483 	c->hash = Hash( c->name );
484 
485 	Log( LOG_DEBUG, "Created new channel structure for \"%s\".", Name );
486 	
487 	return c;
488 } /* New_Chan */
489 
490 
491 LOCAL CL2CHAN *Get_Cl2Chan( CHANNEL *Chan, CLIENT *Client )
492 {
493 	CL2CHAN *cl2chan;
494 
495 	assert( Chan != NULL );
496 	assert( Client != NULL );
497 
498 	cl2chan = My_Cl2Chan;
499 	while( cl2chan )
500 	{
501 		if(( cl2chan->channel == Chan ) && ( cl2chan->client == Client )) return cl2chan;
502 		cl2chan = cl2chan->next;
503 	}
504 	return NULL;
505 } /* Get_Cl2Chan */
506 
507 
508 LOCAL CL2CHAN *Add_Client( CHANNEL *Chan, CLIENT *Client )
509 {
510 	CL2CHAN *cl2chan;
511 
512 	assert( Chan != NULL );
513 	assert( Client != NULL );
514 
515 	/* neue CL2CHAN-Struktur anlegen */
516 	cl2chan = malloc( sizeof( CL2CHAN ));
517 	if( ! cl2chan )
518 	{
519 		Log( LOG_EMERG, "Can't allocate memory!" );
520 		return NULL;
521 	}
522 	cl2chan->channel = Chan;
523 	cl2chan->client = Client;
524 	strcpy( cl2chan->modes, "" );
525 
526 	/* Verketten */
527 	cl2chan->next = My_Cl2Chan;
528 	My_Cl2Chan = cl2chan;
529 
530 	Log( LOG_DEBUG, "User \"%s\" joined channel \"%s\".", Client_Mask( Client ), Chan->name );
531 
532 	return cl2chan;
533 } /* Add_Client */
534 
535 
536 LOCAL BOOLEAN Remove_Client( CHANNEL *Chan, CLIENT *Client, CLIENT *Origin, CHAR *Reason, BOOLEAN ServerPART )
537 {
538 	CL2CHAN *cl2chan, *last_cl2chan;
539 	CHANNEL *c;
540 	
541 	assert( Chan != NULL );
542 	assert( Client != NULL );
543 	assert( Origin != NULL );
544 	assert( Reason != NULL );
545 
546 	last_cl2chan = NULL;
547 	cl2chan = My_Cl2Chan;
548 	while( cl2chan )
549 	{
550 		if(( cl2chan->channel == Chan ) && ( cl2chan->client == Client )) break;
551 		last_cl2chan = cl2chan;
552 		cl2chan = cl2chan->next;
553 	}
554 	if( ! cl2chan ) return FALSE;
555 
556 	c = cl2chan->channel;
557 	assert( c != NULL );
558 
559 	/* Aus Verkettung loesen und freigeben */
560 	if( last_cl2chan ) last_cl2chan->next = cl2chan->next;
561 	else My_Cl2Chan = cl2chan->next;
562 	free( cl2chan );
563 
564 	if( ServerPART ) IRC_WriteStrServersPrefix( Origin, Client, "PART %s :%s", c->name, Reason );
565 	IRC_WriteStrChannelPrefix( Origin, c, Client, FALSE, "PART %s :%s", c->name, Reason );
566 	if(( Client_Conn( Origin ) > NONE ) && ( Client_Type( Origin ) == CLIENT_USER )) IRC_WriteStrClientPrefix( Origin, Client, "PART %s :%s", c->name, Reason );
567 
568 	Log( LOG_DEBUG, "User \"%s\" left channel \"%s\" (%s).", Client_Mask( Client ), c->name, Reason );
569 
570 	/* Wenn Channel nun leer: loeschen */
571 	if( ! Get_First_Cl2Chan( NULL, Chan )) Delete_Channel( Chan );
572 		
573 	return TRUE;
574 } /* Remove_Client */
575 
576 
577 LOCAL CL2CHAN *Get_First_Cl2Chan( CLIENT *Client, CHANNEL *Chan )
578 {
579 	return Get_Next_Cl2Chan( My_Cl2Chan, Client, Chan );
580 } /* Get_First_Cl2Chan */
581 
582 
583 LOCAL CL2CHAN *Get_Next_Cl2Chan( CL2CHAN *Start, CLIENT *Client, CHANNEL *Channel )
584 {
585 	CL2CHAN *cl2chan;
586 
587 	assert( Client != NULL || Channel != NULL );
588 	
589 	cl2chan = Start;
590 	while( cl2chan )
591 	{
592 		if(( Client ) && ( cl2chan->client == Client )) return cl2chan;
593 		if(( Channel ) && ( cl2chan->channel == Channel )) return cl2chan;
594 		cl2chan = cl2chan->next;
595 	}
596 	return NULL;
597 } /* Get_Next_Cl2Chan */
598 
599 
600 LOCAL BOOLEAN Delete_Channel( CHANNEL *Chan )
601 {
602 	/* Channel-Struktur loeschen */
603 	
604 	CHANNEL *chan, *last_chan;
605 
606 	last_chan = NULL;
607 	chan = My_Channels;
608 	while( chan )
609 	{
610 		if( chan == Chan ) break;
611 		last_chan = chan;
612 		chan = chan->next;
613 	}
614 	if( ! chan ) return FALSE;
615 
616 	Log( LOG_DEBUG, "Freed channel structure for \"%s\".", Chan->name );
617 
618 	/* Neu verketten und freigeben */
619 	if( last_chan ) last_chan->next = chan->next;
620 	else My_Channels = chan->next;
621 	free( chan );
622 		
623 	return TRUE;
624 } /* Delete_Channel */
625 
626 
627 /* -eof- */