src/ngircd/irc-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: irc-channel.c,v 1.8 2002/06/02 14:51:14 alex Exp $
  13  *
  14  * irc-channel.c: IRC-Channel-Befehle
  15  */
  16
  17
  18 #include "portab.h"
  19
  20 #include "imp.h"
  21 #include <assert.h>
  22 #include <string.h>
  23
  24 #include "defines.h"
  25 #include "conn.h"
  26 #include "client.h"
  27 #include "channel.h"
  28 #include "lists.h"
  29 #include "log.h"
  30 #include "messages.h"
  31 #include "parse.h"
  32 #include "irc.h"
  33 #include "irc-write.h"
  34
  35 #include "exp.h"
  36 #include "irc-channel.h"
  37
  38
  39 GLOBAL BOOLEAN
  40 IRC_JOIN( CLIENT *Client, REQUEST *Req )
  41 {
  42         CHAR *channame, *flags, *topic, modes[8];
  43         BOOLEAN is_new_chan;
  44         CLIENT *target;
  45         CHANNEL *chan;
  46
  47         assert( Client != NULL );
  48         assert( Req != NULL );
  49
  50         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
  51
  52         /* Falsche Anzahl Parameter? */
  53         if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
  54
  55         /* Wer ist der Absender? */
  56         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
  57         else target = Client;
  58         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
  59
  60         /* Channel-Namen durchgehen */
  61         chan = NULL;
  62         channame = strtok( Req->argv[0], "," );
  63         while( channame )
  64         {
  65                 chan = flags = NULL;
  66
  67                 /* wird der Channel neu angelegt? */
  68                 if( Channel_Search( channame )) is_new_chan = FALSE;
  69                 else is_new_chan = TRUE;
  70
  71                 /* Hat ein Server Channel-User-Modes uebergeben? */
  72                 if( Client_Type( Client ) == CLIENT_SERVER )
  73                 {
  74                         /* Channel-Flags extrahieren */
  75                         flags = strchr( channame, 0x7 );
  76                         if( flags ) *flags++ = '\0';
  77                 }
  78
  79                 /* Lokaler Client? */
  80                 if( Client_Type( Client ) == CLIENT_USER )
  81                 {
  82                         /* Existiert der Channel bereits, oder wird er im Moment neu erzeugt? */
  83                         if( is_new_chan )
  84                         {
  85                                 /* Erster User im Channel: Operator-Flag setzen */
  86                                 flags = "o";
  87                         }
  88                         else
  89                         {
  90                                 /* Existierenden Channel suchen */
  91                                 chan = Channel_Search( channame );
  92                                 assert( chan != NULL );
  93
  94                                 /* Testen, ob Client gebanned ist */
  95                                 if( Lists_CheckBanned( target, chan ))
  96                                 {
  97                                         /* Client ist gebanned: */
  98                                         IRC_WriteStrClient( Client, ERR_BANNEDFROMCHAN_MSG, Client_ID( Client ), channame );
  99
 100                                         /* naechsten Namen ermitteln */
 101                                         channame = strtok( NULL, "," );
 102                                         continue;
 103                                 }
 104
 105                                 /* Ist der Channel "invite-only"? */
 106                                 if( strchr( Channel_Modes( chan ), 'i' ))
 107                                 {
 108                                         /* Wurde der Client invited? */
 109                                         if( ! Lists_CheckInvited( target, chan ))
 110                                         {
 111                                                 /* Client wurde nicht invited: */
 112                                                 IRC_WriteStrClient( Client, ERR_INVITEONLYCHAN_MSG, Client_ID( Client ), channame );
 113
 114                                                 /* naechsten Namen ermitteln */
 115                                                 channame = strtok( NULL, "," );
 116                                                 continue;
 117                                         }
 118                                 }
 119                         }
 120                 }
 121
 122                 /* Channel joinen (und ggf. anlegen) */
 123                 if( ! Channel_Join( target, channame ))
 124                 {
 125                         /* naechsten Namen ermitteln */
 126                         channame = strtok( NULL, "," );
 127                         continue;
 128                 }
 129                 if( ! chan ) chan = Channel_Search( channame );
 130                 assert( chan != NULL );
 131
 132                 /* Modes setzen (wenn vorhanden) */
 133                 while( flags && *flags )
 134                 {
 135                         Channel_UserModeAdd( chan, target, *flags );
 136                         flags++;
 137                 }
 138
 139                 /* Wenn persistenter Channel und IRC-Operator: zum Channel-OP machen */
 140                 if(( strchr( Channel_Modes( chan ), 'P' )) && ( strchr( Client_Modes( target ), 'o' ))) Channel_UserModeAdd( chan, target, 'o' );
 141
 142                 /* Muessen Modes an andere Server gemeldet werden? */
 143                 strcpy( &modes[1], Channel_UserModes( chan, target ));
 144                 if( modes[1] ) modes[0] = 0x7;
 145                 else modes[0] = '\0';
 146
 147                 /* An andere Server weiterleiten */
 148                 IRC_WriteStrServersPrefix( Client, target, "JOIN :%s%s", channame, modes );
 149
 150                 /* im Channel bekannt machen */
 151                 IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "JOIN :%s", channame );
 152                 if( modes[1] )
 153                 {
 154                         /* Modes im Channel bekannt machen */
 155                         IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "MODE %s %s :%s", channame, modes, Client_ID( target ));
 156                 }
 157
 158                 if( Client_Type( Client ) == CLIENT_USER )
 159                 {
 160                         /* an Client bestaetigen */
 161                         IRC_WriteStrClientPrefix( Client, target, "JOIN :%s", channame );
 162
 163                         /* Topic an Client schicken */
 164                         topic = Channel_Topic( chan );
 165                         if( *topic ) IRC_WriteStrClient( Client, RPL_TOPIC_MSG, Client_ID( Client ), channame, topic );
 166
 167                         /* Mitglieder an Client Melden */
 168                         IRC_Send_NAMES( Client, chan );
 169                         IRC_WriteStrClient( Client, RPL_ENDOFNAMES_MSG, Client_ID( Client ), Channel_Name( chan ));
 170                 }
 171
 172                 /* naechsten Namen ermitteln */
 173                 channame = strtok( NULL, "," );
 174         }
 175         return CONNECTED;
 176 } /* IRC_JOIN */
 177
 178
 179 GLOBAL BOOLEAN
 180 IRC_PART( CLIENT *Client, REQUEST *Req )
 181 {
 182         CLIENT *target;
 183         CHAR *chan;
 184
 185         assert( Client != NULL );
 186         assert( Req != NULL );
 187
 188         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 189
 190         /* Falsche Anzahl Parameter? */
 191         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 192
 193         /* Wer ist der Absender? */
 194         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
 195         else target = Client;
 196         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 197
 198         /* Channel-Namen durchgehen */
 199         chan = strtok( Req->argv[0], "," );
 200         while( chan )
 201         {
 202                 if( ! Channel_Part( target, Client, chan, Req->argc > 1 ? Req->argv[1] : Client_ID( target )))
 203                 {
 204                         /* naechsten Namen ermitteln */
 205                         chan = strtok( NULL, "," );
 206                         continue;
 207                 }
 208
 209                 /* naechsten Namen ermitteln */
 210                 chan = strtok( NULL, "," );
 211         }
 212         return CONNECTED;
 213 } /* IRC_PART */
 214
 215
 216 GLOBAL BOOLEAN
 217 IRC_TOPIC( CLIENT *Client, REQUEST *Req )
 218 {
 219         CHANNEL *chan;
 220         CLIENT *from;
 221         CHAR *topic;
 222
 223         assert( Client != NULL );
 224         assert( Req != NULL );
 225
 226         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 227
 228         /* Falsche Anzahl Parameter? */
 229         if(( Req->argc < 1 ) || ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 230
 231         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
 232         else from = Client;
 233         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 234
 235         /* Welcher Channel? */
 236         chan = Channel_Search( Req->argv[0] );
 237         if( ! chan ) return IRC_WriteStrClient( from, ERR_NOSUCHCHANNEL_MSG, Client_ID( from ), Req->argv[0] );
 238
 239         /* Ist der User Mitglied in dem Channel? */
 240         if( ! Channel_IsMemberOf( chan, from )) return IRC_WriteStrClient( from, ERR_NOTONCHANNEL_MSG, Client_ID( from ), Req->argv[0] );
 241
 242         if( Req->argc == 1 )
 243         {
 244                 /* Topic erfragen */
 245                 topic = Channel_Topic( chan );
 246                 if( *topic ) return IRC_WriteStrClient( from, RPL_TOPIC_MSG, Client_ID( from ), Channel_Name( chan ), topic );
 247                 else return IRC_WriteStrClient( from, RPL_NOTOPIC_MSG, Client_ID( from ), Channel_Name( chan ));
 248         }
 249
 250         if( strchr( Channel_Modes( chan ), 't' ))
 251         {
 252                 /* Topic Lock. Ist der User ein Channel Operator? */
 253                 if( ! strchr( Channel_UserModes( chan, from ), 'o' )) return IRC_WriteStrClient( from, ERR_CHANOPRIVSNEEDED_MSG, Client_ID( from ), Channel_Name( chan ));
 254         }
 255
 256         /* Topic setzen */
 257         Channel_SetTopic( chan, Req->argv[1] );
 258         Log( LOG_DEBUG, "User \"%s\" set topic on \"%s\": %s", Client_Mask( from ), Channel_Name( chan ), Req->argv[1][0] ? Req->argv[1] : "<none>" );
 259
 260         /* im Channel bekannt machen und an Server weiterleiten */
 261         IRC_WriteStrServersPrefix( Client, from, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
 262         IRC_WriteStrChannelPrefix( Client, chan, from, FALSE, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
 263
 264         if( Client_Type( Client ) == CLIENT_USER ) return IRC_WriteStrClientPrefix( Client, Client, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
 265         else return CONNECTED;
 266 } /* IRC_TOPIC */
 267
 268
 269 GLOBAL BOOLEAN
 270 IRC_LIST( CLIENT *Client, REQUEST *Req )
 271 {
 272         CHAR *pattern;
 273         CHANNEL *chan;
 274
 275         assert( Client != NULL );
 276         assert( Req != NULL );
 277
 278         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 279
 280         /* Falsche Anzahl Parameter? */
 281         if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 282
 283         if( Req->argc > 0 ) pattern = strtok( Req->argv[0], "," );
 284         else pattern = "*";
 285
 286         while( pattern )
 287         {
 288                 /* alle Channel durchgehen */
 289                 chan = Channel_First( );
 290                 while( chan )
 291                 {
 292                         /* Passt die Suchmaske auf diesen Channel? Bisher werden hier
 293                          * "regular expressions" aber noch nicht unterstuetzt ... */
 294                         if(( strcasecmp( pattern, Channel_Name( chan )) == 0 ) || ( strcmp( pattern, "*" ) == 0 ))
 295                         {
 296                                 /* Treffer! */
 297                                 if( ! IRC_WriteStrClient( Client, RPL_LIST_MSG, Client_ID( Client), Channel_Name( chan ), Channel_MemberCount( chan ), Channel_Topic( chan ))) return DISCONNECTED;
 298                         }
 299                         chan = Channel_Next( chan );
 300                 }
 301
 302                 /* naechsten Namen ermitteln */
 303                 if( Req->argc > 0 ) pattern = strtok( NULL, "," );
 304                 else pattern = NULL;
 305         }
 306
 307         return IRC_WriteStrClient( Client, RPL_LISTEND_MSG, Client_ID( Client ));
 308 } /* IRC_LIST */
 309
 310
 311 /* -eof- */