src/ngircd/lists.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: lists.c,v 1.5 2002/08/26 23:39:22 alex Exp $
  13  *
  14  * lists.c: Verwaltung der "IRC-Listen": Ban, Invite, ...
  15  */
  16
  17
  18 #include "portab.h"
  19
  20 #include "imp.h"
  21 #include <assert.h>
  22
  23 #include "defines.h"
  24 #include "conn.h"
  25 #include "client.h"
  26 #include "channel.h"
  27 #include "log.h"
  28 #include "match.h"
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include "exp.h"
  34 #include "lists.h"
  35
  36
  37 #define MASK_LEN CLIENT_ID_LEN+CLIENT_HOST_LEN
  38
  39
  40 typedef struct _C2C
  41 {
  42         struct _C2C *next;
  43         CHAR mask[MASK_LEN];
  44         CHANNEL *channel;
  45         BOOLEAN onlyonce;
  46 } C2C;
  47
  48
  49 LOCAL C2C *My_Invites, *My_Bans;
  50
  51
  52 LOCAL C2C *New_C2C PARAMS(( CHAR *Mask, CHANNEL *Chan, BOOLEAN OnlyOnce ));
  53
  54
  55 GLOBAL VOID
  56 Lists_Init( VOID )
  57 {
  58         /* Modul initialisieren */
  59
  60         My_Invites = My_Bans = NULL;
  61 } /* Lists_Init */
  62
  63
  64 GLOBAL VOID
  65 Lists_Exit( VOID )
  66 {
  67         /* Modul abmelden */
  68
  69         C2C *c2c, *next;
  70
  71         /* Invite-Lists freigeben */
  72         c2c = My_Invites;
  73         while( c2c )
  74         {
  75                 next = c2c->next;
  76                 free( c2c );
  77                 c2c = next;
  78         }
  79
  80         /* Ban-Lists freigeben */
  81         c2c = My_Bans;
  82         while( c2c )
  83         {
  84                 next = c2c->next;
  85                 free( c2c );
  86                 c2c = next;
  87         }
  88 } /* Lists_Exit */
  89
  90
  91 GLOBAL BOOLEAN
  92 Lists_CheckInvited( CLIENT *Client, CHANNEL *Chan )
  93 {
  94         C2C *c2c, *last;
  95
  96         assert( Client != NULL );
  97         assert( Chan != NULL );
  98
  99         last = NULL;
 100         c2c = My_Invites;
 101         while( c2c )
 102         {
 103                 if( c2c->channel == Chan )
 104                 {
 105                         /* Ok, richtiger Channel. Passt die Maske? */
 106 Log( LOG_DEBUG, "%s : %s", Client_Mask( Client ), c2c->mask );
 107                         if( Match( Client_Mask( Client ), c2c->mask ))
 108                         {
 109                                 /* Treffer! */
 110                                 if( c2c->onlyonce )
 111                                 {
 112                                         /* Eintrag loeschen */
 113                                         if( last ) last->next = c2c->next;
 114                                         else My_Invites = c2c->next;
 115                                         free( c2c );
 116                                 }
 117                                 return TRUE;
 118                         }
 119                 }
 120                 last = c2c;
 121                 c2c = c2c->next;
 122         }
 123
 124         return FALSE;
 125 } /* Lists_CheckInvited */
 126
 127
 128 GLOBAL BOOLEAN
 129 Lists_AddInvited( CHAR *Mask, CHANNEL *Chan, BOOLEAN OnlyOnce )
 130 {
 131         C2C *c2c;
 132
 133         assert( Mask != NULL );
 134         assert( Chan != NULL );
 135
 136         c2c = New_C2C( Mask, Chan, OnlyOnce );
 137         if( ! c2c )
 138         {
 139                 Log( LOG_ERR, "Can't add new invite list entry!" );
 140                 return FALSE;
 141         }
 142
 143         /* verketten */
 144         c2c->next = My_Invites;
 145         My_Invites = c2c;
 146
 147         Log( LOG_DEBUG, "Added \"%s\" to invite list for \"%s\".", Mask, Channel_Name( Chan ));
 148         return TRUE;
 149 } /* Lists_AddInvited */
 150
 151
 152 GLOBAL BOOLEAN
 153 Lists_CheckBanned( CLIENT *Client, CHANNEL *Chan )
 154 {
 155         assert( Client != NULL );
 156         assert( Chan != NULL );
 157
 158         return FALSE;
 159 } /* Lists_CheckBanned */
 160
 161
 162 GLOBAL VOID
 163 Lists_DeleteChannel( CHANNEL *Chan )
 164 {
 165         /* Channel wurde geloescht, Invite- und Ban-Lists aufraeumen */
 166
 167         C2C *c2c, *last, *next;
 168
 169         /* Invite-List */
 170         last = NULL;
 171         c2c = My_Invites;
 172         while( c2c )
 173         {
 174                 next = c2c->next;
 175                 if( c2c->channel == Chan )
 176                 {
 177                         /* dieser Eintrag muss geloescht werden */
 178                         if( last ) last->next = next;
 179                         else My_Invites = next;
 180                         free( c2c );
 181                 }
 182                 else last = c2c;
 183                 c2c = next;
 184         }
 185
 186         /* Ban-List */
 187         last = NULL;
 188         c2c = My_Bans;
 189         while( c2c )
 190         {
 191                 next = c2c->next;
 192                 if( c2c->channel == Chan )
 193                 {
 194                         /* dieser Eintrag muss geloescht werden */
 195                         if( last ) last->next = next;
 196                         else My_Bans = next;
 197                         free( c2c );
 198                 }
 199                 else last = c2c;
 200                 c2c = next;
 201         }
 202 } /* Lists_DeleteChannel */
 203
 204
 205 GLOBAL CHAR *
 206 Lists_MakeMask( CHAR *Pattern )
 207 {
 208         assert( Pattern );
 209
 210         /* Hier sollte aus einem "beliebigen" Pattern eine
 211          * gueltige IRC-Mask erzeugt werden ... */
 212
 213         return Pattern;
 214 } /* Lists_MakeMask */
 215
 216
 217 LOCAL C2C *
 218 New_C2C( CHAR *Mask, CHANNEL *Chan, BOOLEAN OnlyOnce )
 219 {
 220         C2C *c2c;
 221
 222         assert( Mask != NULL );
 223         assert( Chan != NULL );
 224
 225         /* Speicher fuer Eintrag anfordern */
 226         c2c = malloc( sizeof( C2C ));
 227         if( ! c2c )
 228         {
 229                 Log( LOG_EMERG, "Can't allocate memory! [New_C2C]" );
 230                 return NULL;
 231         }
 232
 233         strncpy( c2c->mask, Mask, MASK_LEN );
 234         c2c->channel = Chan;
 235         c2c->onlyonce = OnlyOnce;
 236
 237         return c2c;
 238 } /* New_C2C */
 239
 240
 241 /* -eof- */