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