src/ngircd/irc-mode.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-mode.c,v 1.3 2002/03/12 14:37:52 alex Exp $
  13  *
  14  * irc-mode.c: IRC-Befehle zur Mode-Aenderung (MODE, AWAY, ...)
  15  */
  16
  17
  18 #include "portab.h"
  19
  20 #include "imp.h"
  21 #include <assert.h>
  22 #include <string.h>
  23
  24 #include "channel.h"
  25 #include "defines.h"
  26 #include "irc-write.h"
  27 #include "log.h"
  28 #include "messages.h"
  29
  30 #include "exp.h"
  31 #include "irc-mode.h"
  32
  33
  34 GLOBAL BOOLEAN IRC_MODE( CLIENT *Client, REQUEST *Req )
  35 {
  36         CHAR *mode_ptr, the_modes[CLIENT_MODE_LEN], x[2];
  37         CLIENT *cl, *chan_cl, *prefix;
  38         BOOLEAN set, ok;
  39         CHANNEL *chan;
  40
  41         assert( Client != NULL );
  42         assert( Req != NULL );
  43
  44         cl = chan_cl = prefix = NULL;
  45         chan = NULL;
  46
  47         /* Valider Client? */
  48         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
  49
  50         /* Keine Parameter? */
  51         if( Req->argc < 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
  52
  53         /* Ziel suchen: Client bzw. Channel */
  54         if( Client_IsValidNick( Req->argv[0] )) cl = Client_Search( Req->argv[0] );
  55         if( Channel_IsValidName( Req->argv[0] )) chan = Channel_Search( Req->argv[0] );
  56
  57         /* Kein Ziel gefunden? */
  58         if(( ! cl ) && ( ! chan )) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[0] );
  59
  60         assert(( cl && chan ) != TRUE );
  61
  62         /* Falsche Anzahl Parameter? */
  63         if(( cl ) && ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
  64         if(( chan ) && ( Req->argc > 3 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
  65
  66         /* Client ermitteln, wenn bei Channel-Modes mit 3 Parametern */
  67         if(( chan ) && (Req->argc == 3 ))
  68         {
  69                 chan_cl = Client_Search( Req->argv[2] );
  70                 if( ! chan_cl ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[0] );
  71         }
  72
  73         /* Wenn Anfragender ein User ist: Zugriff erlaubt? */
  74         if( Client_Type( Client ) == CLIENT_USER )
  75         {
  76                 if( cl )
  77                 {
  78                         /* MODE ist nur fuer sich selber zulaessig! */
  79                         if( cl != Client ) return IRC_WriteStrClient( Client, ERR_USERSDONTMATCH_MSG, Client_ID( Client ));
  80                 }
  81                 if( chan )
  82                 {
  83                         /* Darf der User die Channel-Modes ermitteln? */
  84                 }
  85         }
  86
  87         /* Werden die Modes "nur" erfragt? */
  88         if(( cl ) && ( Req->argc == 1 )) return IRC_WriteStrClient( Client, RPL_UMODEIS_MSG, Client_ID( Client ), Client_Modes( cl ));
  89         if(( chan ) && ( Req->argc == 1 )) return IRC_WriteStrClient( Client, RPL_CHANNELMODEIS_MSG, Client_ID( Client ), Channel_Name( chan ), Channel_Modes( chan ));
  90
  91         mode_ptr = Req->argv[1];
  92
  93         /* Sollen Modes gesetzt oder geloescht werden? */
  94         if( cl )
  95         {
  96                 if( *mode_ptr == '+' ) set = TRUE;
  97                 else if( *mode_ptr == '-' ) set = FALSE;
  98                 else return IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client ));
  99                 mode_ptr++;
 100         }
 101         else
 102         {
 103                 if( *mode_ptr == '-' ) set = FALSE;
 104                 else set = TRUE;
 105                 if(( *mode_ptr == '-' ) || ( *mode_ptr == '+' )) mode_ptr++;
 106         }
 107
 108         /* Prefix fuer Antworten etc. ermitteln */
 109         if( Client_Type( Client ) == CLIENT_SERVER )
 110         {
 111                 prefix = Client_GetFromID( Req->prefix );
 112                 if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 113         }
 114         else prefix = Client;
 115
 116         /* Reply-String mit Aenderungen vorbereiten */
 117         if( set ) strcpy( the_modes, "+" );
 118         else strcpy( the_modes, "-" );
 119
 120         ok = TRUE;
 121         x[1] = '\0';
 122         while( *mode_ptr )
 123         {
 124                 x[0] = '\0';
 125                 if( Client_Type( Client ) == CLIENT_SERVER )
 126                 {
 127                         /* Befehl kommt von einem Server, daher
 128                          * trauen wir ihm "unbesehen" ... */
 129                         x[0] = *mode_ptr;
 130                 }
 131                 else
 132                 {
 133                         /* Modes validieren */
 134                         if( cl )
 135                         {
 136                                 /* User-Modes */
 137                                 switch( *mode_ptr )
 138                                 {
 139                                         case 'i':
 140                                                 /* invisible */
 141                                                 x[0] = 'i';
 142                                                 break;
 143                                         case 'r':
 144                                                 /* restricted (kann nur gesetzt werden) */
 145                                                 if( set ) x[0] = 'r';
 146                                                 else ok = IRC_WriteStrClient( Client, ERR_RESTRICTED_MSG, Client_ID( Client ));
 147                                                 break;
 148                                         case 'o':
 149                                                 /* operator (kann nur geloescht werden) */
 150                                                 if( ! set )
 151                                                 {
 152                                                         Client_SetOperByMe( Client, FALSE );
 153                                                         x[0] = 'o';
 154                                                 }
 155                                                 else ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client ));
 156                                                 break;
 157                                         default:
 158                                                 Log( LOG_DEBUG, "Unknown mode \"%c%c\" from \"%s\"!?", set ? '+' : '-', *mode_ptr, Client_ID( Client ));
 159                                                 ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG2_MSG, Client_ID( Client ), set ? '+' : '-', *mode_ptr );
 160                                                 x[0] = '\0';
 161                                 }
 162                         }
 163                         if( chan )
 164                         {
 165                                 /* Ist der User ein Channel Operator? */
 166                                 if( ! strchr( Channel_UserModes( chan, Client ), 'o' ))
 167                                 {
 168                                         Log( LOG_DEBUG, "Can't change modes: \"%s\" is not operator on %s!", Client_ID( Client ), Channel_Name( chan ));
 169                                         ok = IRC_WriteStrClient( Client, ERR_CHANOPRIVSNEEDED_MSG, Client_ID( Client ), Channel_Name( chan ));
 170                                         break;
 171                                 }
 172
 173                                 /* Channel-Modes oder Channel-User-Modes */
 174                                 if( chan_cl )
 175                                 {
 176                                         /* Channel-User-Modes */
 177                                         switch( *mode_ptr )
 178                                         {
 179                                                 case 'o':
 180                                                         /* Channel Operator */
 181                                                         x[0] = 'o';
 182                                                         break;
 183                                                 case 'v':
 184                                                         /* Voice */
 185                                                         x[0] = 'v';
 186                                                         break;
 187                                                 default:
 188                                                         Log( LOG_DEBUG, "Unknown channel-user-mode \"%c%c\" from \"%s\" on \"%s\" at %s!?", set ? '+' : '-', *mode_ptr, Client_ID( Client ), Client_ID( chan_cl ), Channel_Name( chan ));
 189                                                         ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG2_MSG, Client_ID( Client ), set ? '+' : '-', *mode_ptr );
 190                                                         x[0] = '\0';
 191                                         }
 192                                 }
 193                                 else
 194                                 {
 195                                         /* Channel-Modes */
 196                                         switch( *mode_ptr )
 197                                         {
 198                                                 case 'a':
 199                                                         /* Anonymous */
 200                                                         x[0] = 'a';
 201                                                         break;
 202                                                 case 'm':
 203                                                         /* Moderated */
 204                                                         x[0] = 'm';
 205                                                         break;
 206                                                 case 'n':
 207                                                         /* kein Schreiben in den Channel von aussen */
 208                                                         x[0] = 'n';
 209                                                         break;
 210                                                 case 'p':
 211                                                         /* Private */
 212                                                         x[0] = 'p';
 213                                                         break;
 214                                                 case 'q':
 215                                                         /* Quiet */
 216                                                         x[0] = 'q';
 217                                                         break;
 218                                                 case 's':
 219                                                         /* Secret */
 220                                                         x[0] = 's';
 221                                                         break;
 222                                                 case 't':
 223                                                         /* Topic Lock */
 224                                                         x[0] = 't';
 225                                                         break;
 226                                                 default:
 227                                                         Log( LOG_DEBUG, "Unknown channel-mode \"%c%c\" from \"%s\" at %s!?", set ? '+' : '-', *mode_ptr, Client_ID( Client ), Channel_Name( chan ));
 228                                                         ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG2_MSG, Client_ID( Client ), set ? '+' : '-', *mode_ptr );
 229                                                         x[0] = '\0';
 230                                         }
 231                                 }
 232                         }
 233                 }
 234                 if( ! ok ) break;
 235
 236                 mode_ptr++;
 237                 if( ! x[0] ) continue;
 238
 239                 /* Okay, gueltigen Mode gefunden */
 240                 if( cl )
 241                 {
 242                         /* Es geht um User-Modes */
 243                         if( set )
 244                         {
 245                                 /* Mode setzen. Wenn der Client ihn noch nicht hatte: merken */
 246                                 if( Client_ModeAdd( cl, x[0] )) strcat( the_modes, x );
 247
 248                         }
 249                         else
 250                         {
 251                                 /* Modes geloescht. Wenn der Client ihn hatte: merken */
 252                                 if( Client_ModeDel( cl, x[0] )) strcat( the_modes, x );
 253                         }
 254
 255                         /* "nachbearbeiten" */
 256                         if( x[0] == 'a' )
 257                         {
 258                                 /* away */
 259                                 if( set ) Client_SetAway( cl, DEFAULT_AWAY_MSG );
 260                                 else Client_SetAway( cl, NULL );
 261                         }
 262                 }
 263                 if( chan )
 264                 {
 265                         /* Es geht um Channel-Modes oder Channel-User-Modes */
 266                         if( chan_cl )
 267                         {
 268                                 /* Channel-User-Modes */
 269                                 if( set )
 270                                 {
 271                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
 272                                         if( Channel_UserModeAdd( chan, chan_cl, x[0] )) strcat( the_modes, x );
 273                                 }
 274                                 else
 275                                 {
 276                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
 277                                         if( Channel_UserModeDel( chan, chan_cl, x[0] )) strcat( the_modes, x );
 278                                 }
 279                         }
 280                         else
 281                         {
 282                                 /* Channel-Mode */
 283                                 if( set )
 284                                 {
 285                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
 286                                         if( Channel_ModeAdd( chan, x[0] )) strcat( the_modes, x );
 287                                 }
 288                                 else
 289                                 {
 290                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
 291                                         if( Channel_ModeDel( chan, x[0] )) strcat( the_modes, x );
 292                                 }
 293                         }
 294                 }
 295         }
 296
 297         /* Wurden Modes geaendert? */
 298         if( the_modes[1] )
 299         {
 300                 if( cl )
 301                 {
 302                         /* Client-Mode */
 303                         if( Client_Type( Client ) == CLIENT_SERVER )
 304                         {
 305                                 /* Modes an andere Server forwarden */
 306                                 IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Client_ID( cl ), the_modes );
 307                         }
 308                         else
 309                         {
 310                                 /* Bestaetigung an Client schicken & andere Server informieren */
 311                                 ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s", Client_ID( cl ), the_modes );
 312                                 IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Client_ID( cl ), the_modes );
 313                         }
 314                         Log( LOG_DEBUG, "User \"%s\": Mode change, now \"%s\".", Client_Mask( cl ), Client_Modes( cl ));
 315                 }
 316                 if( chan )
 317                 {
 318                         /* Channel-Modes oder Channel-User-Mode */
 319                         if( chan_cl )
 320                         {
 321                                 /* Channel-User-Mode */
 322                                 if( Client_Type( Client ) == CLIENT_SERVER )
 323                                 {
 324                                         /* Modes an andere Server und Channel-User forwarden */
 325                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s %s :%s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
 326                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
 327                                 }
 328                                 else
 329                                 {
 330                                         /* Bestaetigung an Client schicken & andere Server sowie Channel-User informieren */
 331                                         ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
 332                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s %s :%s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
 333                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
 334                                 }
 335                                 Log( LOG_DEBUG, "User \"%s\" on %s: Mode change, now \"%s\".", Client_Mask( chan_cl), Channel_Name( chan ), Channel_UserModes( chan, chan_cl ));
 336                         }
 337                         else
 338                         {
 339                                 /* Channel-Mode */
 340                                 if( Client_Type( Client ) == CLIENT_SERVER )
 341                                 {
 342                                         /* Modes an andere Server und Channel-User forwarden */
 343                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Channel_Name( chan ), the_modes );
 344                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s", Channel_Name( chan ), the_modes );
 345                                 }
 346                                 else
 347                                 {
 348                                         /* Bestaetigung an Client schicken & andere Server sowie Channel-User informieren */
 349                                         ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s", Channel_Name( chan ), the_modes );
 350                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Channel_Name( chan ), the_modes );
 351                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s", Channel_Name( chan ), the_modes );
 352                                 }
 353                                 Log( LOG_DEBUG, "Channel \"%s\": Mode change, now \"%s\".", Channel_Name( chan ), Channel_Modes( chan ));
 354                         }
 355                 }
 356         }
 357
 358         return ok;
 359 } /* IRC_MODE */
 360
 361
 362 GLOBAL BOOLEAN IRC_AWAY( CLIENT *Client, REQUEST *Req )
 363 {
 364         assert( Client != NULL );
 365         assert( Req != NULL );
 366
 367         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 368
 369         /* Falsche Anzahl Parameter? */
 370         if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 371
 372         if(( Req->argc == 1 ) && (Req->argv[0][0] ))
 373         {
 374                 /* AWAY setzen */
 375                 Client_SetAway( Client, Req->argv[0] );
 376                 IRC_WriteStrServersPrefix( Client, Client, "MODE %s :+a", Client_ID( Client ));
 377                 return IRC_WriteStrClient( Client, RPL_NOWAWAY_MSG, Client_ID( Client ));
 378         }
 379         else
 380         {
 381                 /* AWAY loeschen */
 382                 Client_SetAway( Client, NULL );
 383                 IRC_WriteStrServersPrefix( Client, Client, "MODE %s :-a", Client_ID( Client ));
 384                 return IRC_WriteStrClient( Client, RPL_UNAWAY_MSG, Client_ID( Client ));
 385         }
 386 } /* IRC_AWAY */
 387
 388
 389 /* -eof- */