- PART wird nicht mehr an den Server verschickt, von dem es empfangen wurde.
[ngircd-alex.git] / src / ngircd / channel.c
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.9 2002/01/27 22:47:11 alex Exp $
13  *
14  * channel.c: Management der Channels
15  *
16  * $Log: channel.c,v $
17  * Revision 1.9  2002/01/27 22:47:11  alex
18  * - PART wird nicht mehr an den Server verschickt, von dem es empfangen wurde.
19  *
20  * Revision 1.8  2002/01/27 21:56:54  alex
21  * - weitere Anpassungen an Chennals, v.a. ueber Server-Links.
22  *
23  * Revision 1.7  2002/01/27 17:14:33  alex
24  * - diverse Aenderungen fuer Channels ueber mehrere Server.
25  *
26  * Revision 1.6  2002/01/26 18:41:55  alex
27  * - CHANNEL- und CL2CHAN-Strukturen in Header verlegt,
28  * - einige neue Funktionen (Channel_GetChannel(), Channel_FirstMember(), ...)
29  *
30  * Revision 1.5  2002/01/21 00:12:29  alex
31  * - begonnen, Channels zu implementieren :-)
32  *
33  * Revision 1.4  2002/01/16 22:09:07  alex
34  * - neue Funktion Channel_Count().
35  *
36  * Revision 1.3  2002/01/02 02:42:58  alex
37  * - Copyright-Texte aktualisiert.
38  *
39  * Revision 1.2  2001/12/31 02:18:51  alex
40  * - viele neue Befehle (WHOIS, ISON, OPER, DIE, RESTART),
41  * - neuen Header "defines.h" mit (fast) allen Konstanten.
42  * - Code Cleanups und viele "kleine" Aenderungen & Bugfixes.
43  *
44  * Revision 1.1  2001/12/14 08:13:43  alex
45  * - neues Modul begonnen :-)
46  */
47
48
49 #define __channel_c__
50
51
52 #include <portab.h>
53 #include "global.h"
54
55 #include <imp.h>
56 #include <assert.h>
57 #include <stdlib.h>
58 #include <string.h>
59
60 #include "client.h"
61 #include "irc.h"
62 #include "log.h"
63 #include "messages.h"
64
65 #include <exp.h>
66 #include "channel.h"
67
68
69 LOCAL CHANNEL *My_Channels;
70 LOCAL CL2CHAN *My_Cl2Chan;
71
72
73 LOCAL CHANNEL *New_Chan( CHAR *Name );
74 LOCAL CL2CHAN *Get_Cl2Chan( CHANNEL *Chan, CLIENT *Client );
75 LOCAL CL2CHAN *Add_Client( CHANNEL *Chan, CLIENT *Client );
76 LOCAL BOOLEAN Remove_Client( CHANNEL *Chan, CLIENT *Client, CLIENT *Origin, CHAR *Reason, BOOLEAN ServerPART );
77 LOCAL CL2CHAN *Get_First_Cl2Chan( CLIENT *Client, CHANNEL *Chan );
78 LOCAL CL2CHAN *Get_Next_Cl2Chan( CL2CHAN *Start, CLIENT *Client, CHANNEL *Chan );
79 LOCAL BOOLEAN Delete_Channel( CHANNEL *Chan );
80
81
82 GLOBAL VOID Channel_Init( VOID )
83 {
84         My_Channels = NULL;
85         My_Cl2Chan = NULL;
86 } /* Channel_Init */
87
88
89 GLOBAL VOID Channel_Exit( VOID )
90 {
91         CHANNEL *c, *c_next;
92         CL2CHAN *cl2chan, *cl2chan_next;
93         
94         /* Channel-Strukturen freigeben */
95         c = My_Channels;
96         while( c )
97         {
98                 c_next = c->next;
99                 free( c );
100                 c = c_next;
101         }
102
103         /* Channel-Zuordnungstabelle freigeben */
104         cl2chan = My_Cl2Chan;
105         while( c )
106         {
107                 cl2chan_next = cl2chan->next;
108                 free( cl2chan );
109                 cl2chan = cl2chan_next;
110         }
111 } /* Channel_Exit */
112
113
114 GLOBAL BOOLEAN Channel_Join( CLIENT *Client, CHAR *Name )
115 {
116         CHANNEL *chan;
117         
118         assert( Client != NULL );
119         assert( Name != NULL );
120
121         /* Valider Channel-Name? */
122         if(( Name[0] != '#' ) || ( strlen( Name ) >= CHANNEL_NAME_LEN ))
123         {
124                 IRC_WriteStrClient( Client, ERR_NOSUCHCHANNEL_MSG, Client_ID( Client ), Name );
125                 return FALSE;
126         }
127
128         /* Channel suchen */
129         chan = Channel_Search( Name );
130         if( chan )
131         {
132                 /* Ist der Client bereits Mitglied? */
133                 if( Get_Cl2Chan( chan, Client )) return FALSE;
134         }
135         else
136         {
137                 /* Gibt es noch nicht? Dann neu anlegen: */
138                 chan = New_Chan( Name );
139                 if( ! chan ) return FALSE;
140
141                 /* Verketten */
142                 chan->next = My_Channels;
143                 My_Channels = chan;
144         }
145
146         /* User dem Channel hinzufuegen */
147         if( ! Add_Client( chan, Client )) return FALSE;
148         else return TRUE;
149 } /* Channel_Join */
150
151
152 GLOBAL BOOLEAN Channel_Part( CLIENT *Client, CLIENT *Origin, CHAR *Name, CHAR *Reason )
153 {
154         CHANNEL *chan;
155
156         assert( Client != NULL );
157         assert( Name != NULL );
158
159         /* Channel suchen */
160         chan = Channel_Search( Name );
161         if(( ! chan ) || ( ! Get_Cl2Chan( chan, Client )))
162         {
163                 IRC_WriteStrClient( Client, ERR_NOSUCHCHANNEL_MSG, Client_ID( Client ), Name );
164                 return FALSE;
165         }
166
167         /* User aus Channel entfernen */
168         if( ! Remove_Client( chan, Client, Origin, Reason, TRUE )) return FALSE;
169         else return TRUE;
170 } /* Channel_Part */
171
172
173 GLOBAL VOID Channel_RemoveClient( CLIENT *Client, CHAR *Reason )
174 {
175         CHANNEL *c, *next_c;
176
177         assert( Client != NULL );
178
179         c = My_Channels;
180         while( c )
181         {
182                 next_c = c->next;
183                 Remove_Client( c, Client, Client_ThisServer( ), Reason, FALSE );
184                 c = next_c;
185         }
186 } /* Channel_RemoveClient */
187
188
189 GLOBAL INT Channel_Count( VOID )
190 {
191         CHANNEL *c;
192         INT count;
193         
194         count = 0;
195         c = My_Channels;
196         while( c )
197         {
198                 count++;
199                 c = c->next;
200         }
201         return count;
202 } /* Channel_Count */
203
204
205 GLOBAL CHANNEL *Channel_Search( CHAR *Name )
206 {
207         /* Channel-Struktur suchen */
208         
209         CHANNEL *c;
210
211         assert( Name != NULL );
212         c = My_Channels;
213         while( c )
214         {
215                 if( strcasecmp( Name, c->name ) == 0 ) return c;
216                 c = c->next;
217         }
218         return NULL;
219 } /* Channel_Search */
220
221
222 GLOBAL CL2CHAN *Channel_FirstMember( CHANNEL *Chan )
223 {
224         assert( Chan != NULL );
225         return Get_First_Cl2Chan( NULL, Chan );
226 } /* Channel_IsMember */
227
228
229 GLOBAL CL2CHAN *Channel_NextMember( CHANNEL *Chan, CL2CHAN *Cl2Chan )
230 {
231         assert( Chan != NULL );
232         assert( Cl2Chan != NULL );
233         return Get_Next_Cl2Chan( Cl2Chan->next, NULL, Chan );
234 } /* Channel_NextMember */
235
236
237 GLOBAL CLIENT *Channel_GetClient( CL2CHAN *Cl2Chan )
238 {
239         assert( Cl2Chan != NULL );
240         return Cl2Chan->client;
241 } /* Channel_GetClient */
242
243
244 GLOBAL CHANNEL *Channel_GetChannel( CL2CHAN *Cl2Chan )
245 {
246         assert( Cl2Chan != NULL );
247         return Cl2Chan->channel;
248 } /* Channel_GetChannel */
249
250
251 LOCAL CHANNEL *New_Chan( CHAR *Name )
252 {
253         /* Neue Channel-Struktur anlegen */
254         
255         CHANNEL *c;
256
257         assert( Name != NULL );
258         
259         c = malloc( sizeof( CHANNEL ));
260         if( ! c )
261         {
262                 Log( LOG_EMERG, "Can't allocate memory!" );
263                 return NULL;
264         }
265         c->next = NULL;
266         strncpy( c->name, Name, CHANNEL_NAME_LEN );
267         c->name[CHANNEL_NAME_LEN - 1] = '\0';
268         strcpy( c->modes, "" );
269
270         Log( LOG_DEBUG, "Created new channel structure for \"%s\".", Name );
271         
272         return c;
273 } /* New_Chan */
274
275
276 LOCAL CL2CHAN *Get_Cl2Chan( CHANNEL *Chan, CLIENT *Client )
277 {
278         CL2CHAN *cl2chan;
279
280         assert( Chan != NULL );
281         assert( Client != NULL );
282
283         cl2chan = My_Cl2Chan;
284         while( cl2chan )
285         {
286                 if(( cl2chan->channel == Chan ) && ( cl2chan->client == Client )) return cl2chan;
287                 cl2chan = cl2chan->next;
288         }
289         return NULL;
290 } /* Get_Cl2Chan */
291
292
293 LOCAL CL2CHAN *Add_Client( CHANNEL *Chan, CLIENT *Client )
294 {
295         CL2CHAN *cl2chan;
296
297         assert( Chan != NULL );
298         assert( Client != NULL );
299
300         cl2chan = malloc( sizeof( CL2CHAN ));
301         if( ! cl2chan )
302         {
303                 Log( LOG_EMERG, "Can't allocate memory!" );
304                 return NULL;
305         }
306         cl2chan->channel = Chan;
307         cl2chan->client = Client;
308
309         /* Verketten */
310         cl2chan->next = My_Cl2Chan;
311         My_Cl2Chan = cl2chan;
312
313         Log( LOG_DEBUG, "User \"%s\" joined channel \"%s\".", Client_Mask( Client ), Chan->name );
314
315         return cl2chan;
316 } /* Add_Client */
317
318
319 LOCAL BOOLEAN Remove_Client( CHANNEL *Chan, CLIENT *Client, CLIENT *Origin, CHAR *Reason, BOOLEAN ServerPART )
320 {
321         CL2CHAN *cl2chan, *last_cl2chan;
322         CHANNEL *c;
323         
324         assert( Chan != NULL );
325         assert( Client != NULL );
326         assert( Origin != NULL );
327         assert( Reason != NULL );
328
329         last_cl2chan = NULL;
330         cl2chan = My_Cl2Chan;
331         while( cl2chan )
332         {
333                 if(( cl2chan->channel == Chan ) && ( cl2chan->client == Client )) break;
334                 last_cl2chan = cl2chan;
335                 cl2chan = cl2chan->next;
336         }
337         if( ! cl2chan ) return FALSE;
338
339         c = cl2chan->channel;
340         assert( c != NULL );
341
342         /* Aus Verkettung loesen und freigeben */
343         if( last_cl2chan ) last_cl2chan->next = cl2chan->next;
344         else My_Cl2Chan = cl2chan->next;
345         free( cl2chan );
346
347         if( ServerPART ) IRC_WriteStrServersPrefix( Origin, Client, "PART %s :%s", c->name, Reason );
348         IRC_WriteStrChannelPrefix( Origin, c, Client, FALSE, "PART %s :%s", c->name, Reason );
349         if(( Client_Conn( Origin ) > NONE ) && ( Client_Type( Origin ) == CLIENT_USER )) IRC_WriteStrClientPrefix( Origin, Client, "PART %s :%s", c->name, Reason );
350
351         Log( LOG_DEBUG, "User \"%s\" left channel \"%s\" (%s).", Client_Mask( Client ), c->name, Reason );
352
353         /* Wenn Channel nun leer: loeschen */
354         if( ! Get_First_Cl2Chan( NULL, Chan )) Delete_Channel( Chan );
355                 
356         return TRUE;
357 } /* Remove_Client */
358
359
360 LOCAL CL2CHAN *Get_First_Cl2Chan( CLIENT *Client, CHANNEL *Chan )
361 {
362         return Get_Next_Cl2Chan( My_Cl2Chan, Client, Chan );
363 } /* Get_First_Cl2Chan */
364
365
366 LOCAL CL2CHAN *Get_Next_Cl2Chan( CL2CHAN *Start, CLIENT *Client, CHANNEL *Channel )
367 {
368         CL2CHAN *cl2chan;
369
370         assert( Client != NULL || Channel != NULL );
371         
372         cl2chan = Start;
373         while( cl2chan )
374         {
375                 if(( Client ) && ( cl2chan->client == Client )) return cl2chan;
376                 if(( Channel ) && ( cl2chan->channel == Channel )) return cl2chan;
377                 cl2chan = cl2chan->next;
378         }
379         return NULL;
380 } /* Get_Next_Cl2Chan */
381
382
383 LOCAL BOOLEAN Delete_Channel( CHANNEL *Chan )
384 {
385         /* Channel-Struktur loeschen */
386         
387         CHANNEL *chan, *last_chan;
388
389         last_chan = NULL;
390         chan = My_Channels;
391         while( chan )
392         {
393                 if( chan == Chan ) break;
394                 last_chan = chan;
395                 chan = chan->next;
396         }
397         if( ! chan ) return FALSE;
398
399         Log( LOG_DEBUG, "Freed channel structure for \"%s\".", Chan->name );
400
401         /* Neu verketten und freigeben */
402         if( last_chan ) last_chan->next = chan->next;
403         else My_Channels = chan->next;
404         free( chan );
405                 
406         return TRUE;
407 } /* Delete_Channel */
408
409
410 /* -eof- */