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  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  * Please read the file COPYING, README and AUTHORS for more information.
  10  *
  11  * Management of IRC lists: ban, invite, ...
  12  */
  13
  14
  15 #include "portab.h"
  16
  17 static char UNUSED id[] = "$Id: lists.c,v 1.15 2004/04/25 15:40:19 alex Exp $";
  18
  19 #include "imp.h"
  20 #include <assert.h>
  21
  22 #include "defines.h"
  23 #include "conn.h"
  24 #include "client.h"
  25 #include "channel.h"
  26 #include "log.h"
  27 #include "match.h"
  28 #include "messages.h"
  29 #include "irc-write.h"
  30
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <strings.h>
  34
  35 #include "exp.h"
  36 #include "lists.h"
  37
  38
  39 #define MASK_LEN 2*CLIENT_HOST_LEN
  40
  41
  42 typedef struct _C2C
  43 {
  44         struct _C2C *next;
  45         CHAR mask[MASK_LEN];
  46         CHANNEL *channel;
  47         BOOLEAN onlyonce;
  48 } C2C;
  49
  50
  51 LOCAL C2C *My_Invites, *My_Bans;
  52
  53
  54 LOCAL C2C *New_C2C PARAMS(( CHAR *Mask, CHANNEL *Chan, BOOLEAN OnlyOnce ));
  55
  56 LOCAL BOOLEAN Check_List PARAMS(( C2C **Cl2Chan, CLIENT *Client, CHANNEL *Chan ));
  57 LOCAL BOOLEAN Already_Registered PARAMS(( C2C *Cl2Chan, CHAR *Mask, CHANNEL *Chan ));
  58
  59
  60
  61 GLOBAL VOID
  62 Lists_Init( VOID )
  63 {
  64         /* Modul initialisieren */
  65
  66         My_Invites = My_Bans = NULL;
  67 } /* Lists_Init */
  68
  69
  70 GLOBAL VOID
  71 Lists_Exit( VOID )
  72 {
  73         /* Modul abmelden */
  74
  75         C2C *c2c, *next;
  76
  77         /* Invite-Lists freigeben */
  78         c2c = My_Invites;
  79         while( c2c )
  80         {
  81                 next = c2c->next;
  82                 free( c2c );
  83                 c2c = next;
  84         }
  85
  86         /* Ban-Lists freigeben */
  87         c2c = My_Bans;
  88         while( c2c )
  89         {
  90                 next = c2c->next;
  91                 free( c2c );
  92                 c2c = next;
  93         }
  94 } /* Lists_Exit */
  95
  96
  97 GLOBAL BOOLEAN
  98 Lists_CheckInvited( CLIENT *Client, CHANNEL *Chan )
  99 {
 100         return Check_List( &My_Invites, Client, Chan );
 101 } /* Lists_CheckInvited */
 102
 103
 104 GLOBAL BOOLEAN
 105 Lists_IsInviteEntry( CHAR *Mask, CHANNEL *Chan )
 106 {
 107         assert( Mask != NULL );
 108         assert( Chan != NULL );
 109
 110         return Already_Registered( My_Invites, Mask, Chan );
 111 } /* Lists_IsInviteEntry */
 112
 113
 114 GLOBAL BOOLEAN
 115 Lists_AddInvited( CHAR *Mask, CHANNEL *Chan, BOOLEAN OnlyOnce )
 116 {
 117         C2C *c2c;
 118
 119         assert( Mask != NULL );
 120         assert( Chan != NULL );
 121
 122         if( Already_Registered( My_Invites, Mask, Chan )) return TRUE;
 123
 124         c2c = New_C2C( Mask, Chan, OnlyOnce );
 125         if( ! c2c )
 126         {
 127                 Log( LOG_ERR, "Can't add new invite list entry!" );
 128                 return FALSE;
 129         }
 130
 131         /* verketten */
 132         c2c->next = My_Invites;
 133         My_Invites = c2c;
 134
 135         Log( LOG_DEBUG, "Added \"%s\" to invite list for \"%s\".", Mask, Channel_Name( Chan ));
 136         return TRUE;
 137 } /* Lists_AddInvited */
 138
 139
 140 GLOBAL VOID
 141 Lists_DelInvited( CHAR *Mask, CHANNEL *Chan )
 142 {
 143         C2C *c2c, *last, *next;
 144
 145         assert( Mask != NULL );
 146         assert( Chan != NULL );
 147
 148         last = NULL;
 149         c2c = My_Invites;
 150         while( c2c )
 151         {
 152                 next = c2c->next;
 153                 if(( c2c->channel == Chan ) && ( strcasecmp( c2c->mask, Mask ) == 0 ))
 154                 {
 155                         /* dieser Eintrag muss geloescht werden */
 156                         Log( LOG_DEBUG, "Deleted \"%s\" from invite list for \"%s\"." , c2c->mask, Channel_Name( Chan ));
 157                         if( last ) last->next = next;
 158                         else My_Invites = next;
 159                         free( c2c );
 160                 }
 161                 else last = c2c;
 162                 c2c = next;
 163         }
 164 } /* Lists_DelInvited */
 165
 166
 167 GLOBAL BOOLEAN
 168 Lists_ShowInvites( CLIENT *Client, CHANNEL *Channel )
 169 {
 170         C2C *c2c;
 171
 172         assert( Client != NULL );
 173         assert( Channel != NULL );
 174
 175         c2c = My_Invites;
 176         while( c2c )
 177         {
 178                 if( c2c->channel == Channel )
 179                 {
 180                         /* Eintrag fuer Channel gefunden; ausgeben: */
 181                         if( ! IRC_WriteStrClient( Client, RPL_INVITELIST_MSG, Client_ID( Client ), Channel_Name( Channel ), c2c->mask )) return DISCONNECTED;
 182                 }
 183                 c2c = c2c->next;
 184         }
 185         return IRC_WriteStrClient( Client, RPL_ENDOFINVITELIST_MSG, Client_ID( Client ), Channel_Name( Channel ));
 186 } /* Lists_ShowInvites */
 187
 188
 189 GLOBAL BOOLEAN
 190 Lists_SendInvites( CLIENT *Client )
 191 {
 192         C2C *c2c;
 193
 194         assert( Client != NULL );
 195
 196         c2c = My_Invites;
 197         while( c2c )
 198         {
 199                 if( ! IRC_WriteStrClient( Client, "MODE %s +I %s", Channel_Name( c2c->channel ), c2c->mask )) return DISCONNECTED;
 200                 c2c = c2c->next;
 201         }
 202         return CONNECTED;
 203 } /* Lists_SendInvites */
 204
 205
 206 GLOBAL BOOLEAN
 207 Lists_SendBans( CLIENT *Client )
 208 {
 209         C2C *c2c;
 210
 211         assert( Client != NULL );
 212
 213         c2c = My_Bans;
 214         while( c2c )
 215         {
 216                 if( ! IRC_WriteStrClient( Client, "MODE %s +b %s", Channel_Name( c2c->channel ), c2c->mask )) return DISCONNECTED;
 217                 c2c = c2c->next;
 218         }
 219         return CONNECTED;
 220 } /* Lists_SendBans */
 221
 222
 223 GLOBAL BOOLEAN
 224 Lists_CheckBanned( CLIENT *Client, CHANNEL *Chan )
 225 {
 226         return Check_List( &My_Bans, Client, Chan );
 227 } /* Lists_CheckBanned */
 228
 229
 230 GLOBAL BOOLEAN
 231 Lists_IsBanEntry( CHAR *Mask, CHANNEL *Chan )
 232 {
 233         assert( Mask != NULL );
 234         assert( Chan != NULL );
 235
 236         return Already_Registered( My_Bans, Mask, Chan );
 237 } /* Lists_IsBanEntry */
 238
 239
 240 GLOBAL BOOLEAN
 241 Lists_AddBanned( CHAR *Mask, CHANNEL *Chan )
 242 {
 243         C2C *c2c;
 244
 245         assert( Mask != NULL );
 246         assert( Chan != NULL );
 247
 248         if( Already_Registered( My_Bans, Mask, Chan )) return TRUE;
 249
 250         c2c = New_C2C( Mask, Chan, FALSE );
 251         if( ! c2c )
 252         {
 253                 Log( LOG_ERR, "Can't add new ban list entry!" );
 254                 return FALSE;
 255         }
 256
 257         /* verketten */
 258         c2c->next = My_Bans;
 259         My_Bans = c2c;
 260
 261         Log( LOG_DEBUG, "Added \"%s\" to ban list for \"%s\".", Mask, Channel_Name( Chan ));
 262         return TRUE;
 263 } /* Lists_AddBanned */
 264
 265
 266 GLOBAL VOID
 267 Lists_DelBanned( CHAR *Mask, CHANNEL *Chan )
 268 {
 269         C2C *c2c, *last, *next;
 270
 271         assert( Mask != NULL );
 272         assert( Chan != NULL );
 273
 274         last = NULL;
 275         c2c = My_Bans;
 276         while( c2c )
 277         {
 278                 next = c2c->next;
 279                 if(( c2c->channel == Chan ) && ( strcasecmp( c2c->mask, Mask ) == 0 ))
 280                 {
 281                         /* dieser Eintrag muss geloescht werden */
 282                         Log( LOG_DEBUG, "Deleted \"%s\" from ban list for \"%s\"." , c2c->mask, Channel_Name( Chan ));
 283                         if( last ) last->next = next;
 284                         else My_Bans = next;
 285                         free( c2c );
 286                 }
 287                 else last = c2c;
 288                 c2c = next;
 289         }
 290 } /* Lists_DelBanned */
 291
 292
 293 GLOBAL BOOLEAN
 294 Lists_ShowBans( CLIENT *Client, CHANNEL *Channel )
 295 {
 296         C2C *c2c;
 297
 298         assert( Client != NULL );
 299         assert( Channel != NULL );
 300
 301         c2c = My_Bans;
 302         while( c2c )
 303         {
 304                 if( c2c->channel == Channel )
 305                 {
 306                         /* Eintrag fuer Channel gefunden; ausgeben: */
 307                         if( ! IRC_WriteStrClient( Client, RPL_BANLIST_MSG, Client_ID( Client ), Channel_Name( Channel ), c2c->mask )) return DISCONNECTED;
 308                 }
 309                 c2c = c2c->next;
 310         }
 311         return IRC_WriteStrClient( Client, RPL_ENDOFBANLIST_MSG, Client_ID( Client ), Channel_Name( Channel ));
 312 } /* Lists_ShowBans */
 313
 314
 315 GLOBAL VOID
 316 Lists_DeleteChannel( CHANNEL *Chan )
 317 {
 318         /* Channel wurde geloescht, Invite- und Ban-Lists aufraeumen */
 319
 320         C2C *c2c, *last, *next;
 321
 322         /* Invite-List */
 323         last = NULL;
 324         c2c = My_Invites;
 325         while( c2c )
 326         {
 327                 next = c2c->next;
 328                 if( c2c->channel == Chan )
 329                 {
 330                         /* dieser Eintrag muss geloescht werden */
 331                         Log( LOG_DEBUG, "Deleted \"%s\" from invite list for \"%s\"." , c2c->mask, Channel_Name( Chan ));
 332                         if( last ) last->next = next;
 333                         else My_Invites = next;
 334                         free( c2c );
 335                 }
 336                 else last = c2c;
 337                 c2c = next;
 338         }
 339
 340         /* Ban-List */
 341         last = NULL;
 342         c2c = My_Bans;
 343         while( c2c )
 344         {
 345                 next = c2c->next;
 346                 if( c2c->channel == Chan )
 347                 {
 348                         /* dieser Eintrag muss geloescht werden */
 349                         Log( LOG_DEBUG, "Deleted \"%s\" from ban list for \"%s\"." , c2c->mask, Channel_Name( Chan ));
 350                         if( last ) last->next = next;
 351                         else My_Bans = next;
 352                         free( c2c );
 353                 }
 354                 else last = c2c;
 355                 c2c = next;
 356         }
 357 } /* Lists_DeleteChannel */
 358
 359
 360 GLOBAL CHAR *
 361 Lists_MakeMask( CHAR *Pattern )
 362 {
 363         /* Hier wird aus einem "beliebigen" Pattern eine gueltige IRC-Mask erzeugt.
 364          * Diese ist aber nur bis zum naechsten Aufruf von Lists_MakeMask() gueltig,
 365          * da ein einziger globaler Puffer verwendet wird. ->Umkopieren!*/
 366
 367         STATIC CHAR TheMask[MASK_LEN];
 368         CHAR *excl, *at;
 369
 370         assert( Pattern != NULL );
 371
 372         excl = strchr( Pattern, '!' );
 373         at = strchr( Pattern, '@' );
 374
 375         if(( at ) && ( at < excl )) excl = NULL;
 376
 377         if(( ! at ) && ( ! excl ))
 378         {
 379                 /* weder ! noch @ vorhanden: als Nick annehmen */
 380                 strlcpy( TheMask, Pattern, sizeof( TheMask ) - 5 );
 381                 strlcat( TheMask, "!*@*", sizeof( TheMask ));
 382                 return TheMask;
 383         }
 384
 385         if(( ! at ) && ( excl ))
 386         {
 387                 /* Domain fehlt */
 388                 strlcpy( TheMask, Pattern, sizeof( TheMask ) - 3 );
 389                 strlcat( TheMask, "@*", sizeof( TheMask ));
 390                 return TheMask;
 391         }
 392
 393         if(( at ) && ( ! excl ))
 394         {
 395                 /* User fehlt */
 396                 *at = '\0'; at++;
 397                 strlcpy( TheMask, Pattern, sizeof( TheMask ) - strlen( at ) - 4 );
 398                 strlcat( TheMask, "!*@", sizeof( TheMask ));
 399                 strlcat( TheMask, at, sizeof( TheMask ));
 400                 return TheMask;
 401         }
 402
 403         /* alle Teile vorhanden */
 404         strlcpy( TheMask, Pattern, sizeof( TheMask ));
 405         return TheMask;
 406 } /* Lists_MakeMask */
 407
 408
 409 LOCAL C2C *
 410 New_C2C( CHAR *Mask, CHANNEL *Chan, BOOLEAN OnlyOnce )
 411 {
 412         C2C *c2c;
 413
 414         assert( Mask != NULL );
 415         assert( Chan != NULL );
 416
 417         /* Speicher fuer Eintrag anfordern */
 418         c2c = (C2C *)malloc( sizeof( C2C ));
 419         if( ! c2c )
 420         {
 421                 Log( LOG_EMERG, "Can't allocate memory! [New_C2C]" );
 422                 return NULL;
 423         }
 424
 425         strlcpy( c2c->mask, Mask, sizeof( c2c->mask ));
 426         c2c->channel = Chan;
 427         c2c->onlyonce = OnlyOnce;
 428
 429         return c2c;
 430 } /* New_C2C */
 431
 432
 433 LOCAL BOOLEAN
 434 Check_List( C2C **Cl2Chan, CLIENT *Client, CHANNEL *Chan )
 435 {
 436         C2C *c2c, *last;
 437
 438         assert( Cl2Chan != NULL );
 439         assert( Client != NULL );
 440         assert( Chan != NULL );
 441
 442         c2c = *Cl2Chan;
 443         last = NULL;
 444
 445         while( c2c )
 446         {
 447                 if( c2c->channel == Chan )
 448                 {
 449                         /* Ok, richtiger Channel. Passt die Maske? */
 450                         if( Match( c2c->mask, Client_Mask( Client )))
 451                         {
 452                                 /* Treffer! */
 453                                 if( c2c->onlyonce )
 454                                 {
 455                                         /* Eintrag loeschen */
 456                                         Log( LOG_DEBUG, "Deleted \"%s\" from %s list for \"%s\".", c2c->mask, *Cl2Chan == My_Invites ? "invite" : "ban", Channel_Name( Chan ));
 457                                         if( last ) last->next = c2c->next;
 458                                         else *Cl2Chan = c2c->next;
 459                                         free( c2c );
 460                                 }
 461                                 return TRUE;
 462                         }
 463                 }
 464                 last = c2c;
 465                 c2c = c2c->next;
 466         }
 467
 468         return FALSE;
 469 } /* Check_List */
 470
 471
 472 LOCAL BOOLEAN
 473 Already_Registered( C2C *List, CHAR *Mask, CHANNEL *Chan )
 474 {
 475         C2C *c2c;
 476
 477         c2c = List;
 478         while( c2c )
 479         {
 480                 if(( c2c->channel == Chan ) && ( strcasecmp( c2c->mask, Mask ) == 0 )) return TRUE;
 481                 c2c = c2c->next;
 482         }
 483         return FALSE;
 484 } /* Already_Registered */
 485
 486
 487 /* -eof- */