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- */