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