X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?p=ngircd-alex.git;a=blobdiff_plain;f=src%2Fngircd%2Firc-mode.c;h=a3205b50f346f610bfca6917f19fd59aff32383f;hp=7d7fe45a944b0742f76e11c47b50923d2adb7382;hb=08f9d31d60220e8a389a2d24f42625be7749f090;hpb=296ddebed11c0ded9d5ccc0257485a0ffae9265d diff --git a/src/ngircd/irc-mode.c b/src/ngircd/irc-mode.c index 7d7fe45a..38fec0d0 100644 --- a/src/ngircd/irc-mode.c +++ b/src/ngircd/irc-mode.c @@ -1,525 +1,1109 @@ /* * ngIRCd -- The Next Generation IRC Daemon - * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de) + * Copyright (c)2001-2013 Alexander Barton (alex@barton.de) and Contributors. * - * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen - * der GNU General Public License (GPL), wie von der Free Software Foundation - * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2 - * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version. - * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste - * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS. - * - * $Id: irc-mode.c,v 1.12 2002/09/08 01:16:58 alex Exp $ - * - * irc-mode.c: IRC-Befehle zur Mode-Aenderung (MODE, AWAY, ...) + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * Please read the file COPYING, README and AUTHORS for more information. */ - #include "portab.h" +/** + * @file + * IRC commands for mode changes (like MODE, AWAY, etc.) + */ + #include "imp.h" #include +#include +#include #include +#include "defines.h" #include "conn.h" -#include "client.h" #include "channel.h" -#include "defines.h" +#include "irc-macros.h" #include "irc-write.h" #include "lists.h" #include "log.h" #include "parse.h" #include "messages.h" -#include "resolve.h" #include "conf.h" #include "exp.h" #include "irc-mode.h" +static bool Client_Mode PARAMS((CLIENT *Client, REQUEST *Req, CLIENT *Origin, + CLIENT *Target)); +static bool Channel_Mode PARAMS((CLIENT *Client, REQUEST *Req, CLIENT *Origin, + CHANNEL *Channel)); -LOCAL BOOLEAN Add_Invite PARAMS(( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern )); -LOCAL BOOLEAN Add_Ban PARAMS(( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern )); - -LOCAL BOOLEAN Del_Invite PARAMS(( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern )); -LOCAL BOOLEAN Del_Ban PARAMS(( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern )); +static bool Add_To_List PARAMS((char what, CLIENT *Prefix, CLIENT *Client, + CHANNEL *Channel, const char *Pattern)); +static bool Del_From_List PARAMS((char what, CLIENT *Prefix, CLIENT *Client, + CHANNEL *Channel, const char *Pattern)); -LOCAL BOOLEAN Send_ListChange PARAMS(( CHAR *Mode, CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Mask )); +static bool Send_ListChange PARAMS((const bool IsAdd, const char ModeChar, + CLIENT *Prefix, CLIENT *Client, + CHANNEL *Channel, const char *Mask)); - -GLOBAL BOOLEAN +/** + * Handler for the IRC "MODE" command. + * + * This function detects whether user or channel modes should be modified + * and calls the appropriate sub-functions. + * + * @param Client The client from which this command has been received. + * @param Req Request structure with prefix and all parameters. + * @return CONNECTED or DISCONNECTED. + */ +GLOBAL bool IRC_MODE( CLIENT *Client, REQUEST *Req ) { - CHAR *mode_ptr, the_modes[CLIENT_MODE_LEN], x[2]; - CLIENT *cl, *chan_cl, *prefix; - BOOLEAN set, ok, modeok; + CLIENT *cl, *origin; CHANNEL *chan; - - assert( Client != NULL ); - assert( Req != NULL ); - cl = chan_cl = prefix = NULL; - chan = NULL; + assert(Client != NULL); + assert(Req != NULL); - /* Valider Client? */ - if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client )); + _IRC_GET_SENDER_OR_RETURN_(origin, Req, Client) - /* Keine Parameter? */ - if( Req->argc < 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command ); + /* Channel or user mode? */ + cl = NULL; chan = NULL; + if (Client_IsValidNick(Req->argv[0])) + cl = Client_Search(Req->argv[0]); + if (Channel_IsValidName(Req->argv[0])) + chan = Channel_Search(Req->argv[0]); - /* Ziel suchen: Client bzw. Channel */ - if( Client_IsValidNick( Req->argv[0] )) cl = Client_Search( Req->argv[0] ); - if( Channel_IsValidName( Req->argv[0] )) chan = Channel_Search( Req->argv[0] ); + if (cl) + return Client_Mode(Client, Req, origin, cl); + if (chan) + return Channel_Mode(Client, Req, origin, chan); - /* Kein Ziel gefunden? */ - if(( ! cl ) && ( ! chan )) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[0] ); + /* No target found! */ + return IRC_WriteErrClient(Client, ERR_NOSUCHNICK_MSG, + Client_ID(Client), Req->argv[0]); +} /* IRC_MODE */ - assert(( cl && chan ) != TRUE ); +/** + * Check if the "mode limit" for a client has been reached. + * + * This limit doesn't apply for servers or services! + * + * @param Client The client to check. + * @param Count The number of modes already handled. + * @return true if the limit has been reached. + */ +static bool +Mode_Limit_Reached(CLIENT *Client, int Count) +{ + if (Client_Type(Client) == CLIENT_SERVER + || Client_Type(Client) == CLIENT_SERVICE) + return false; + if (Count < MAX_HNDL_MODES_ARG) + return false; + return true; +} - /* Falsche Anzahl Parameter? */ - if(( cl ) && ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command ); - if(( chan ) && ( Req->argc > 3 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command ); +/** + * Handle client mode requests + * + * @param Client The client from which this command has been received. + * @param Req Request structure with prefix and all parameters. + * @param Origin The originator of the MODE command (prefix). + * @param Target The target (client) of this MODE command. + * @return CONNECTED or DISCONNECTED. + */ +static bool +Client_Mode( CLIENT *Client, REQUEST *Req, CLIENT *Origin, CLIENT *Target ) +{ + char the_modes[COMMAND_LEN], x[2], *mode_ptr; + bool ok, set; + bool send_RPL_HOSTHIDDEN_MSG = false; + int mode_arg; + size_t len; - /* Prefix fuer Antworten etc. ermitteln */ - if( Client_Type( Client ) == CLIENT_SERVER ) - { - prefix = Client_Search( Req->prefix ); - if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix ); + /* Is the client allowed to request or change the modes? */ + if (Client_Type(Client) == CLIENT_USER) { + /* Users are only allowed to manipulate their own modes! */ + if (Target != Client) + return IRC_WriteErrClient(Client, + ERR_USERSDONTMATCH_MSG, + Client_ID(Client)); } - else prefix = Client; - - if(( chan ) && (( Req->argc == 2 ) || ( Req->argc == 3 ))) - { - /* pruefen, ob "Listen-Operation": Invite, Ban */ - if(( Req->argv[1][0] == '-' ) || ( Req->argv[1][0] == '+' )) mode_ptr = &Req->argv[1][1]; - else mode_ptr = &Req->argv[1][0]; - - if( Req->argc == 2 ) - { - /* Liste anzeigen */ - if( *mode_ptr == 'I' ) return Lists_ShowInvites( prefix, chan ); - if( *mode_ptr == 'b' ) return Lists_ShowBans( prefix, chan ); + + /* Mode request: let's answer it :-) */ + if (Req->argc == 1) + return IRC_WriteStrClient(Origin, RPL_UMODEIS_MSG, + Client_ID(Target), + Client_Modes(Target)); + + mode_arg = 1; + mode_ptr = Req->argv[mode_arg]; + + /* Initial state: set or unset modes? */ + if (*mode_ptr == '+') { + set = true; + strcpy(the_modes, "+"); + } else if (*mode_ptr == '-') { + set = false; + strcpy(the_modes, "-"); + } else + return IRC_WriteErrClient(Origin, ERR_UMODEUNKNOWNFLAG_MSG, + Client_ID(Origin)); + + x[1] = '\0'; + ok = CONNECTED; + while (mode_ptr) { + mode_ptr++; + if (!*mode_ptr) { + /* Try next argument if there's any */ + mode_arg++; + if (mode_arg < Req->argc) + mode_ptr = Req->argv[mode_arg]; + else + break; } - else - { - if( Req->argv[1][0] == '+' ) - { - /* Listen-Eintrag hinzufuegen */ - if( *mode_ptr == 'I' ) return Add_Invite( prefix, Client, chan, Req->argv[2] ); - if( *mode_ptr == 'b' ) return Add_Ban( prefix, Client, chan, Req->argv[2] ); + + switch(*mode_ptr) { + case '+': + case '-': + if ((*mode_ptr == '+' && !set) + || (*mode_ptr == '-' && set)) { + /* Action modifier ("+"/"-") must be changed */ + len = strlen(the_modes) - 1; + if (the_modes[len] == '+' + || the_modes[len] == '-') { + /* Last character in the "result + * string" was an "action", so just + * overwrite it with the new action */ + the_modes[len] = *mode_ptr; + } else { + /* Append new modifier character to + * the resulting mode string */ + x[0] = *mode_ptr; + strlcat(the_modes, x, + sizeof(the_modes)); + } + if (*mode_ptr == '+') + set = true; + else + set = false; } - else if( Req->argv[1][0] == '-' ) - { - /* Listen-Eintrag loeschen */ - if( *mode_ptr == 'I' ) return Del_Invite( prefix, Client, chan, Req->argv[2] ); - if( *mode_ptr == 'b' ) return Del_Ban( prefix, Client, chan, Req->argv[2] ); + continue; + } + + /* Validate modes */ + x[0] = '\0'; + switch (*mode_ptr) { + case 'b': /* Block private msgs */ + case 'C': /* Only messages from clients sharing a channel */ + case 'i': /* Invisible */ + case 's': /* Server messages */ + case 'w': /* Wallops messages */ + x[0] = *mode_ptr; + break; + case 'a': /* Away */ + if (Client_Type(Client) == CLIENT_SERVER) { + x[0] = 'a'; + Client_SetAway(Origin, DEFAULT_AWAY_MSG); + } else + ok = IRC_WriteErrClient(Origin, + ERR_NOPRIVILEGES_MSG, + Client_ID(Origin)); + break; + case 'B': /* Bot */ + if (Client_HasMode(Client, 'r')) + ok = IRC_WriteErrClient(Origin, + ERR_RESTRICTED_MSG, + Client_ID(Origin)); + else + x[0] = 'B'; + break; + case 'c': /* Receive connect notices + * (only settable by IRC operators!) */ + if (!set || Client_Type(Client) == CLIENT_SERVER + || Client_OperByMe(Origin)) + x[0] = 'c'; + else + ok = IRC_WriteErrClient(Origin, + ERR_NOPRIVILEGES_MSG, + Client_ID(Origin)); + break; + case 'o': /* IRC operator (only unsettable!) */ + if (!set || Client_Type(Client) == CLIENT_SERVER) { + Client_SetOperByMe(Target, false); + x[0] = 'o'; + } else + ok = IRC_WriteErrClient(Origin, + ERR_NOPRIVILEGES_MSG, + Client_ID(Origin)); + break; + case 'q': /* KICK-protected user */ + if (!set || Client_Type(Client) == CLIENT_SERVER + || Client_OperByMe(Origin)) + x[0] = 'q'; + else + ok = IRC_WriteErrClient(Origin, + ERR_NOPRIVILEGES_MSG, + Client_ID(Origin)); + break; + case 'r': /* Restricted (only settable) */ + if (set || Client_Type(Client) == CLIENT_SERVER) + x[0] = 'r'; + else + ok = IRC_WriteErrClient(Origin, + ERR_RESTRICTED_MSG, + Client_ID(Origin)); + break; + case 'R': /* Registered (not [un]settable by clients) */ + if (Client_Type(Client) == CLIENT_SERVER) + x[0] = 'R'; + else + ok = IRC_WriteErrClient(Origin, + ERR_NICKREGISTER_MSG, + Client_ID(Origin)); + break; + case 'x': /* Cloak hostname */ + if (Client_HasMode(Client, 'r')) + ok = IRC_WriteErrClient(Origin, + ERR_RESTRICTED_MSG, + Client_ID(Origin)); + else if (!set || Conf_CloakHostModeX[0] + || Client_Type(Client) == CLIENT_SERVER + || Client_OperByMe(Client)) { + x[0] = 'x'; + send_RPL_HOSTHIDDEN_MSG = true; + } else + ok = IRC_WriteErrClient(Origin, + ERR_NOPRIVILEGES_MSG, + Client_ID(Origin)); + break; + default: + if (Client_Type(Client) != CLIENT_SERVER) { + Log(LOG_DEBUG, + "Unknown mode \"%c%c\" from \"%s\"!?", + set ? '+' : '-', *mode_ptr, + Client_ID(Origin)); + ok = IRC_WriteErrClient(Origin, + ERR_UMODEUNKNOWNFLAG2_MSG, + Client_ID(Origin), + set ? '+' : '-', + *mode_ptr); + x[0] = '\0'; + } else { + Log(LOG_DEBUG, + "Handling unknown mode \"%c%c\" from \"%s\" for \"%s\" ...", + set ? '+' : '-', *mode_ptr, + Client_ID(Origin), Client_ID(Target)); + x[0] = *mode_ptr; } } - } - /* Client ermitteln, wenn bei Channel-Modes mit 3 Parametern */ - if(( chan ) && (Req->argc == 3 )) - { - chan_cl = Client_Search( Req->argv[2] ); - if( ! chan_cl ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[0] ); + if (!ok) + break; + + /* Is there a valid mode change? */ + if (!x[0]) + continue; + + if (set) { + if (Client_ModeAdd(Target, x[0])) + strlcat(the_modes, x, sizeof(the_modes)); + } else { + if (Client_ModeDel(Target, x[0])) + strlcat(the_modes, x, sizeof(the_modes)); + } } - - /* Wenn Anfragender ein User ist: Zugriff erlaubt? */ - if( Client_Type( Client ) == CLIENT_USER ) - { - if( cl ) - { - /* MODE ist nur fuer sich selber zulaessig! */ - if( cl != Client ) return IRC_WriteStrClient( Client, ERR_USERSDONTMATCH_MSG, Client_ID( Client )); + + /* Are there changed modes? */ + if (the_modes[1]) { + /* Remove needless action modifier characters */ + len = strlen(the_modes) - 1; + if (the_modes[len] == '+' || the_modes[len] == '-') + the_modes[len] = '\0'; + + if (Client_Type(Client) == CLIENT_SERVER) { + /* Forward modes to other servers */ + if (Client_Conn(Target) != NONE) { + /* Remote server (service?) changed modes + * for one of our clients. Inform it! */ + IRC_WriteStrClientPrefix(Target, Origin, + "MODE %s :%s", + Client_ID(Target), + the_modes); + } + IRC_WriteStrServersPrefix(Client, Origin, + "MODE %s :%s", + Client_ID(Target), + the_modes); + } else { + /* Send reply to client and inform other servers */ + ok = IRC_WriteStrClientPrefix(Client, Origin, + "MODE %s :%s", + Client_ID(Target), + the_modes); + IRC_WriteStrServersPrefix(Client, Origin, + "MODE %s :%s", + Client_ID(Target), + the_modes); } - if( chan ) - { - /* Darf der User die Channel-Modes ermitteln? */ + + if (send_RPL_HOSTHIDDEN_MSG && Client_Conn(Target) > NONE) { + /* A new (cloaked) hostname must be announced */ + IRC_WriteStrClientPrefix(Target, Origin, + RPL_HOSTHIDDEN_MSG, + Client_ID(Target), + Client_HostnameDisplayed(Target)); + } + + LogDebug("%s \"%s\": Mode change, now \"%s\".", + Client_TypeText(Target), Client_Mask(Target), + Client_Modes(Target)); } - /* Werden die Modes "nur" erfragt? */ - if(( cl ) && ( Req->argc == 1 )) return IRC_WriteStrClient( Client, RPL_UMODEIS_MSG, Client_ID( Client ), Client_Modes( cl )); - if(( chan ) && ( Req->argc == 1 )) return IRC_WriteStrClient( Client, RPL_CHANNELMODEIS_MSG, Client_ID( Client ), Channel_Name( chan ), Channel_Modes( chan )); + IRC_SetPenalty(Client, 1); + return ok; +} /* Client_Mode */ + +/* + * Reply to a channel mode request. + * + * @param Origin The originator of the MODE command (prefix). + * @param Channel The channel of which the modes should be sent. + * @return CONNECTED or DISCONNECTED. + */ +static bool +Channel_Mode_Answer_Request(CLIENT *Origin, CHANNEL *Channel) +{ + char the_modes[COMMAND_LEN], the_args[COMMAND_LEN], argadd[CLIENT_PASS_LEN]; + const char *mode_ptr; + + /* Member or not? -- That's the question! */ + if (!Channel_IsMemberOf(Channel, Origin)) + return IRC_WriteStrClient(Origin, RPL_CHANNELMODEIS_MSG, + Client_ID(Origin), Channel_Name(Channel), Channel_Modes(Channel)); - mode_ptr = Req->argv[1]; + /* The sender is a member: generate extended reply */ + strlcpy(the_modes, Channel_Modes(Channel), sizeof(the_modes)); + mode_ptr = the_modes; + the_args[0] = '\0'; - /* Sollen Modes gesetzt oder geloescht werden? */ - if( cl ) - { - if( *mode_ptr == '+' ) set = TRUE; - else if( *mode_ptr == '-' ) set = FALSE; - else return IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client )); + while(*mode_ptr) { + switch(*mode_ptr) { + case 'l': + snprintf(argadd, sizeof(argadd), " %lu", Channel_MaxUsers(Channel)); + strlcat(the_args, argadd, sizeof(the_args)); + break; + case 'k': + strlcat(the_args, " ", sizeof(the_args)); + strlcat(the_args, Channel_Key(Channel), sizeof(the_args)); + break; + } mode_ptr++; } + if (the_args[0]) + strlcat(the_modes, the_args, sizeof(the_modes)); + + if (!IRC_WriteStrClient(Origin, RPL_CHANNELMODEIS_MSG, + Client_ID(Origin), Channel_Name(Channel), + the_modes)) + return DISCONNECTED; +#ifndef STRICT_RFC + if (!IRC_WriteStrClient(Origin, RPL_CREATIONTIME_MSG, + Client_ID(Origin), Channel_Name(Channel), + Channel_CreationTime(Channel))) + return DISCONNECTED; +#endif + return CONNECTED; +} + +/** + * Handle channel mode and channel-user mode changes + * + * @param Client The client from which this command has been received. + * @param Req Request structure with prefix and all parameters. + * @param Origin The originator of the MODE command (prefix). + * @param Channel The target channel of this MODE command. + * @return CONNECTED or DISCONNECTED. + */ +static bool +Channel_Mode(CLIENT *Client, REQUEST *Req, CLIENT *Origin, CHANNEL *Channel) +{ + char the_modes[COMMAND_LEN], the_args[COMMAND_LEN], x[2], + argadd[CLIENT_PASS_LEN], *mode_ptr; + bool connected, set, skiponce, retval, use_servermode, + is_halfop, is_op, is_admin, is_owner, is_machine, is_oper; + int mode_arg, arg_arg, mode_arg_count = 0; + CLIENT *client; + long l; + size_t len; + + is_halfop = is_op = is_admin = is_owner = is_machine = is_oper = false; + + if (Channel_IsModeless(Channel)) + return IRC_WriteErrClient(Client, ERR_NOCHANMODES_MSG, + Client_ID(Client), Channel_Name(Channel)); + + /* Mode request: let's answer it :-) */ + if (Req->argc <= 1) + return Channel_Mode_Answer_Request(Origin, Channel); + + /* Check if origin is oper and opers can use mode */ + use_servermode = Conf_OperServerMode; + if(Client_OperByMe(Client) && Conf_OperCanMode) { + is_oper = true; + } + + /* Check if client is a server/service */ + if(Client_Type(Client) == CLIENT_SERVER || + Client_Type(Client) == CLIENT_SERVICE) { + is_machine = true; + } + + /* Check if client is member of channel or an oper or an server/service */ + if(!Channel_IsMemberOf(Channel, Client) && !is_oper && !is_machine) + return IRC_WriteErrClient(Origin, ERR_NOTONCHANNEL_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + + mode_arg = 1; + mode_ptr = Req->argv[mode_arg]; + if (Req->argc > mode_arg + 1) + arg_arg = mode_arg + 1; else - { - if( *mode_ptr == '-' ) set = FALSE; - else set = TRUE; - if(( *mode_ptr == '-' ) || ( *mode_ptr == '+' )) mode_ptr++; + arg_arg = -1; + + /* Initial state: set or unset modes? */ + skiponce = false; + switch (*mode_ptr) { + case '-': + set = false; + break; + case '+': + set = true; + break; + default: + set = true; + skiponce = true; } - /* Reply-String mit Aenderungen vorbereiten */ - if( set ) strcpy( the_modes, "+" ); - else strcpy( the_modes, "-" ); + /* Prepare reply string */ + strcpy(the_modes, set ? "+" : "-"); + the_args[0] = '\0'; - ok = TRUE; x[1] = '\0'; - while( *mode_ptr ) - { - x[0] = '\0'; - if( Client_Type( Client ) == CLIENT_SERVER ) - { - /* Befehl kommt von einem Server, daher - * trauen wir ihm "unbesehen" ... */ - x[0] = *mode_ptr; + connected = CONNECTED; + while (mode_ptr) { + if (!skiponce) + mode_ptr++; + if (!*mode_ptr) { + /* Try next argument if there's any */ + if (arg_arg < 0) + break; + if (arg_arg > mode_arg) + mode_arg = arg_arg; + else + mode_arg++; + + if (mode_arg >= Req->argc) + break; + mode_ptr = Req->argv[mode_arg]; + + if (Req->argc > mode_arg + 1) + arg_arg = mode_arg + 1; + else + arg_arg = -1; } - else - { - /* Modes validieren */ - if( cl ) - { - /* User-Modes */ - switch( *mode_ptr ) - { - case 'i': - /* invisible */ - x[0] = 'i'; - break; - case 'o': - /* operator (kann nur geloescht werden) */ - if( ! set ) - { - Client_SetOperByMe( Client, FALSE ); - x[0] = 'o'; - } - else ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client )); - break; - case 'r': - /* restricted (kann nur gesetzt werden) */ - if( set ) x[0] = 'r'; - else ok = IRC_WriteStrClient( Client, ERR_RESTRICTED_MSG, Client_ID( Client )); - break; - case 's': - /* server messages */ - x[0] = 's'; - break; - default: - Log( LOG_DEBUG, "Unknown mode \"%c%c\" from \"%s\"!?", set ? '+' : '-', *mode_ptr, Client_ID( Client )); - ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG2_MSG, Client_ID( Client ), set ? '+' : '-', *mode_ptr ); - x[0] = '\0'; - } - } - if( chan ) - { - /* Ist der User ein Channel Operator? */ - modeok = FALSE; - if( strchr( Channel_UserModes( chan, Client ), 'o' )) modeok = TRUE; - if( Conf_OperCanMode ) - { - /* auch IRC-Operatoren duerfen MODE verwenden */ - if( Client_OperByMe( Client )) modeok = TRUE; - } + skiponce = false; - if( ! modeok ) - { - Log( LOG_DEBUG, "Can't change modes: \"%s\" is not operator on %s!", Client_ID( Client ), Channel_Name( chan )); - ok = IRC_WriteStrClient( Client, ERR_CHANOPRIVSNEEDED_MSG, Client_ID( Client ), Channel_Name( chan )); - break; - } - - /* Channel-Modes oder Channel-User-Modes */ - if( chan_cl ) - { - /* Channel-User-Modes */ - switch( *mode_ptr ) - { - case 'o': - /* Channel Operator */ - x[0] = 'o'; - break; - case 'v': - /* Voice */ - x[0] = 'v'; - break; - default: - 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 )); - ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG2_MSG, Client_ID( Client ), set ? '+' : '-', *mode_ptr ); - x[0] = '\0'; - } - } - else - { - /* Channel-Modes */ - switch( *mode_ptr ) - { - case 'i': - /* Invite-Only */ - x[0] = 'i'; - break; - case 'm': - /* Moderated */ - x[0] = 'm'; - break; - case 'n': - /* kein Schreiben in den Channel von aussen */ - x[0] = 'n'; - break; - case 't': - /* Topic Lock */ - x[0] = 't'; - break; - case 'P': - /* Persistent */ - x[0] = 'P'; - break; - default: - Log( LOG_DEBUG, "Unknown channel-mode \"%c%c\" from \"%s\" at %s!?", set ? '+' : '-', *mode_ptr, Client_ID( Client ), Channel_Name( chan )); - ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG2_MSG, Client_ID( Client ), set ? '+' : '-', *mode_ptr ); - x[0] = '\0'; - } + switch (*mode_ptr) { + case '+': + case '-': + if (((*mode_ptr == '+') && !set) + || ((*mode_ptr == '-') && set)) { + /* Action modifier ("+"/"-") must be changed ... */ + len = strlen(the_modes) - 1; + if (the_modes[len] == '+' || the_modes[len] == '-') { + /* Adjust last action modifier in result */ + the_modes[len] = *mode_ptr; + } else { + /* Append modifier character to result string */ + x[0] = *mode_ptr; + strlcat(the_modes, x, sizeof(the_modes)); } + set = *mode_ptr == '+'; } + continue; } - if( ! ok ) break; - - mode_ptr++; - if( ! x[0] ) continue; - - /* Okay, gueltigen Mode gefunden */ - if( cl ) - { - /* Es geht um User-Modes */ - if( set ) - { - /* Mode setzen. Wenn der Client ihn noch nicht hatte: merken */ - if( Client_ModeAdd( cl, x[0] )) strcat( the_modes, x ); - + + /* Are there arguments left? */ + if (arg_arg >= Req->argc) + arg_arg = -1; + + if(!is_machine && !is_oper) { + if (Channel_UserHasMode(Channel, Client, 'q')) + is_owner = true; + if (Channel_UserHasMode(Channel, Client, 'a')) + is_admin = true; + if (Channel_UserHasMode(Channel, Client, 'o')) + is_op = true; + if (Channel_UserHasMode(Channel, Client, 'h')) + is_halfop = true; + } + + /* Validate modes */ + x[0] = '\0'; + argadd[0] = '\0'; + client = NULL; + switch (*mode_ptr) { + /* --- Channel modes --- */ + case 'R': /* Registered users only */ + case 's': /* Secret channel */ + case 'z': /* Secure connections only */ + if(!is_oper && !is_machine && !is_owner && + !is_admin && !is_op) { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), Channel_Name(Channel)); + goto chan_exit; } + case 'i': /* Invite only */ + case 'V': /* Invite disallow */ + case 'M': /* Only identified nicks can write */ + case 'm': /* Moderated */ + case 'n': /* Only members can write */ + case 'Q': /* No kicks */ + case 't': /* Topic locked */ + if(is_oper || is_machine || is_owner || + is_admin || is_op || is_halfop) + x[0] = *mode_ptr; else - { - /* Modes geloescht. Wenn der Client ihn hatte: merken */ - if( Client_ModeDel( cl, x[0] )) strcat( the_modes, x ); - } - - /* "nachbearbeiten" */ - if( x[0] == 'a' ) - { - /* away */ - if( set ) Client_SetAway( cl, DEFAULT_AWAY_MSG ); - else Client_SetAway( cl, NULL ); + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), Channel_Name(Channel)); + break; + case 'k': /* Channel key */ + if (Mode_Limit_Reached(Client, mode_arg_count++)) + goto chan_exit; + if (!set) { + if (is_oper || is_machine || is_owner || + is_admin || is_op || is_halfop) + x[0] = *mode_ptr; + else + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + break; } - } - if( chan ) - { - /* Es geht um Channel-Modes oder Channel-User-Modes */ - if( chan_cl ) - { - /* Channel-User-Modes */ - if( set ) - { - /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */ - if( Channel_UserModeAdd( chan, chan_cl, x[0] )) strcat( the_modes, x ); + if (arg_arg > mode_arg) { + if (is_oper || is_machine || is_owner || + is_admin || is_op || is_halfop) { + Channel_ModeDel(Channel, 'k'); + Channel_SetKey(Channel, + Req->argv[arg_arg]); + strlcpy(argadd, Channel_Key(Channel), + sizeof(argadd)); + x[0] = *mode_ptr; + } else { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); } + Req->argv[arg_arg][0] = '\0'; + arg_arg++; + } else { +#ifdef STRICT_RFC + /* Only send error message in "strict" mode, + * this is how ircd2.11 and others behave ... */ + connected = IRC_WriteErrClient(Origin, + ERR_NEEDMOREPARAMS_MSG, + Client_ID(Origin), Req->command); +#endif + goto chan_exit; + } + break; + case 'l': /* Member limit */ + if (Mode_Limit_Reached(Client, mode_arg_count++)) + goto chan_exit; + if (!set) { + if (is_oper || is_machine || is_owner || + is_admin || is_op || is_halfop) + x[0] = *mode_ptr; else - { - /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */ - if( Channel_UserModeDel( chan, chan_cl, x[0] )) strcat( the_modes, x ); + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + break; + } + if (arg_arg > mode_arg) { + if (is_oper || is_machine || is_owner || + is_admin || is_op || is_halfop) { + l = atol(Req->argv[arg_arg]); + if (l > 0 && l < 0xFFFF) { + Channel_ModeDel(Channel, 'l'); + Channel_SetMaxUsers(Channel, l); + snprintf(argadd, sizeof(argadd), + "%ld", l); + x[0] = *mode_ptr; + } + } else { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); } + Req->argv[arg_arg][0] = '\0'; + arg_arg++; + } else { +#ifdef STRICT_RFC + /* Only send error message in "strict" mode, + * this is how ircd2.11 and others behave ... */ + connected = IRC_WriteErrClient(Origin, + ERR_NEEDMOREPARAMS_MSG, + Client_ID(Origin), Req->command); +#endif + goto chan_exit; } + break; + case 'O': /* IRC operators only */ + if (set) { + /* Only IRC operators are allowed to + * set the 'O' channel mode! */ + if(is_oper || is_machine) + x[0] = 'O'; + else + connected = IRC_WriteErrClient(Origin, + ERR_NOPRIVILEGES_MSG, + Client_ID(Origin)); + } else if(is_oper || is_machine || is_owner || + is_admin || is_op) + x[0] = 'O'; else - { - /* Channel-Mode */ - if( set ) - { - /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */ - if( Channel_ModeAdd( chan, x[0] )) strcat( the_modes, x ); - } + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + break; + case 'P': /* Persistent channel */ + if (set) { + /* Only IRC operators are allowed to + * set the 'P' channel mode! */ + if(is_oper || is_machine) + x[0] = 'P'; else - { - /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */ - if( Channel_ModeDel( chan, x[0] )) strcat( the_modes, x ); - } + connected = IRC_WriteErrClient(Origin, + ERR_NOPRIVILEGES_MSG, + Client_ID(Origin)); + } else if(is_oper || is_machine || is_owner || + is_admin || is_op) + x[0] = 'P'; + else + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + break; + /* --- Channel user modes --- */ + case 'q': /* Owner */ + case 'a': /* Channel admin */ + if(!is_oper && !is_machine && !is_owner && !is_admin) { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPPRIVTOOLOW_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + goto chan_exit; } - } - } - - /* Wurden Modes geaendert? */ - if( the_modes[1] ) - { - if( cl ) - { - /* Client-Mode */ - if( Client_Type( Client ) == CLIENT_SERVER ) - { - /* Modes an andere Server forwarden */ - IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Client_ID( cl ), the_modes ); + case 'o': /* Channel operator */ + if(!is_oper && !is_machine && !is_owner && + !is_admin && !is_op) { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + goto chan_exit; } - else - { - /* Bestaetigung an Client schicken & andere Server informieren */ - ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s", Client_ID( cl ), the_modes ); - IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Client_ID( cl ), the_modes ); + case 'h': /* Half Op */ + if(!is_oper && !is_machine && !is_owner && + !is_admin && !is_op) { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); + goto chan_exit; } - Log( LOG_DEBUG, "User \"%s\": Mode change, now \"%s\".", Client_Mask( cl ), Client_Modes( cl )); - } - if( chan ) - { - /* Channel-Modes oder Channel-User-Mode */ - if( chan_cl ) - { - /* Channel-User-Mode */ - if( Client_Type( Client ) == CLIENT_SERVER ) - { - /* Modes an andere Server und Channel-User forwarden */ - IRC_WriteStrServersPrefix( Client, prefix, "MODE %s %s :%s", Channel_Name( chan ), the_modes, Client_ID( chan_cl)); - IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl)); - } - else - { - /* Bestaetigung an Client schicken & andere Server sowie Channel-User informieren */ - ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl)); - IRC_WriteStrServersPrefix( Client, prefix, "MODE %s %s :%s", Channel_Name( chan ), the_modes, Client_ID( chan_cl)); - IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl)); + case 'v': /* Voice */ + if (arg_arg > mode_arg) { + if (is_oper || is_machine || is_owner || + is_admin || is_op || is_halfop) { + client = Client_Search(Req->argv[arg_arg]); + if (client) + x[0] = *mode_ptr; + else + connected = IRC_WriteErrClient(Origin, + ERR_NOSUCHNICK_MSG, + Client_ID(Origin), + Req->argv[arg_arg]); + } else { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); } - Log( LOG_DEBUG, "User \"%s\" on %s: Mode change, now \"%s\".", Client_Mask( chan_cl), Channel_Name( chan ), Channel_UserModes( chan, chan_cl )); + Req->argv[arg_arg][0] = '\0'; + arg_arg++; + } else { +#ifdef STRICT_RFC + /* Report an error to the client, when a user + * mode should be changed but no nickname is + * given. But don't do it when not in "strict" + * mode, because most other servers don't do + * it as well and some clients send "wired" + * MODE commands like "MODE #chan -ooo nick". */ + connected = IRC_WriteErrClient(Origin, + ERR_NEEDMOREPARAMS_MSG, + Client_ID(Origin), Req->command); +#endif + goto chan_exit; } - else - { - /* Channel-Mode */ - if( Client_Type( Client ) == CLIENT_SERVER ) - { - /* Modes an andere Server und Channel-User forwarden */ - IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Channel_Name( chan ), the_modes ); - IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s", Channel_Name( chan ), the_modes ); + break; + /* --- Channel lists --- */ + case 'I': /* Invite lists */ + case 'b': /* Ban lists */ + case 'e': /* Channel exception lists */ + if (Mode_Limit_Reached(Client, mode_arg_count++)) + goto chan_exit; + if (arg_arg > mode_arg) { + /* modify list */ + if (is_oper || is_machine || is_owner || + is_admin || is_op || is_halfop) { + connected = set + ? Add_To_List(*mode_ptr, Origin, + Client, Channel, + Req->argv[arg_arg]) + : Del_From_List(*mode_ptr, Origin, + Client, Channel, + Req->argv[arg_arg]); + } else { + connected = IRC_WriteErrClient(Origin, + ERR_CHANOPRIVSNEEDED_MSG, + Client_ID(Origin), + Channel_Name(Channel)); } - else - { - /* Bestaetigung an Client schicken & andere Server sowie Channel-User informieren */ - ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s", Channel_Name( chan ), the_modes ); - IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Channel_Name( chan ), the_modes ); - IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s", Channel_Name( chan ), the_modes ); + Req->argv[arg_arg][0] = '\0'; + arg_arg++; + } else { + switch (*mode_ptr) { + case 'I': + Channel_ShowInvites(Origin, Channel); + break; + case 'b': + Channel_ShowBans(Origin, Channel); + break; + case 'e': + Channel_ShowExcepts(Origin, Channel); + break; } - Log( LOG_DEBUG, "Channel \"%s\": Mode change, now \"%s\".", Channel_Name( chan ), Channel_Modes( chan )); + } + break; + default: + if (Client_Type(Client) != CLIENT_SERVER) { + Log(LOG_DEBUG, + "Unknown mode \"%c%c\" from \"%s\" on %s!?", + set ? '+' : '-', *mode_ptr, + Client_ID(Origin), Channel_Name(Channel)); + connected = IRC_WriteErrClient(Origin, + ERR_UNKNOWNMODE_MSG, + Client_ID(Origin), *mode_ptr, + Channel_Name(Channel)); + x[0] = '\0'; + } else { + Log(LOG_DEBUG, + "Handling unknown mode \"%c%c\" from \"%s\" on %s ...", + set ? '+' : '-', *mode_ptr, + Client_ID(Origin), Channel_Name(Channel)); + x[0] = *mode_ptr; } } - } - return ok; -} /* IRC_MODE */ + if (!connected) + break; + /* Is there a valid mode change? */ + if (!x[0]) + continue; -GLOBAL BOOLEAN -IRC_AWAY( CLIENT *Client, REQUEST *Req ) -{ - assert( Client != NULL ); - assert( Req != NULL ); - - if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client )); + /* Validate target client */ + if (client && (!Channel_IsMemberOf(Channel, client))) { + if (!IRC_WriteErrClient(Origin, ERR_USERNOTINCHANNEL_MSG, + Client_ID(Origin), + Client_ID(client), + Channel_Name(Channel))) + break; + continue; + } - /* Falsche Anzahl Parameter? */ - if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command ); + if (client) { + /* Channel-User-Mode */ + retval = set + ? Channel_UserModeAdd(Channel, client, x[0]) + : Channel_UserModeDel(Channel, client, x[0]); + if (retval) { + strlcat(the_args, " ", sizeof(the_args)); + strlcat(the_args, Client_ID(client), + sizeof(the_args)); + strlcat(the_modes, x, sizeof(the_modes)); + LogDebug + ("User \"%s\": Mode change on %s, now \"%s\"", + Client_Mask(client), Channel_Name(Channel), + Channel_UserModes(Channel, client)); + } + } else { + /* Channel-Mode */ + retval = set + ? Channel_ModeAdd(Channel, x[0]) + : Channel_ModeDel(Channel, x[0]); + if (retval) { + strlcat(the_modes, x, sizeof(the_modes)); + LogDebug("Channel %s: Mode change, now \"%s\".", + Channel_Name(Channel), + Channel_Modes(Channel)); + } + } - if(( Req->argc == 1 ) && (Req->argv[0][0] )) - { - /* AWAY setzen */ - Client_SetAway( Client, Req->argv[0] ); - IRC_WriteStrServersPrefix( Client, Client, "MODE %s :+a", Client_ID( Client )); - return IRC_WriteStrClient( Client, RPL_NOWAWAY_MSG, Client_ID( Client )); - } - else - { - /* AWAY loeschen */ - Client_SetAway( Client, NULL ); - IRC_WriteStrServersPrefix( Client, Client, "MODE %s :-a", Client_ID( Client )); - return IRC_WriteStrClient( Client, RPL_UNAWAY_MSG, Client_ID( Client )); + /* Are there additional arguments to add? */ + if (argadd[0]) { + strlcat(the_args, " ", sizeof(the_args)); + strlcat(the_args, argadd, sizeof(the_args)); + } } -} /* IRC_AWAY */ + chan_exit: + /* Are there changed modes? */ + if (the_modes[1]) { + /* Clean up mode string */ + len = strlen(the_modes) - 1; + if ((the_modes[len] == '+') || (the_modes[len] == '-')) + the_modes[len] = '\0'; -LOCAL BOOLEAN -Add_Invite( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern ) -{ - CHAR *mask; + if (Client_Type(Client) == CLIENT_SERVER) { + /* MODE requests for local channels from other servers + * are definitely invalid! */ + if (Channel_IsLocal(Channel)) { + Log(LOG_ALERT, "Got remote MODE command for local channel!? Ignored."); + return CONNECTED; + } - assert( Client != NULL ); - assert( Channel != NULL ); - assert( Pattern != NULL ); + /* Forward mode changes to channel users and all the + * other remote servers: */ + IRC_WriteStrServersPrefix(Client, Origin, + "MODE %s %s%s", Channel_Name(Channel), + the_modes, the_args); + IRC_WriteStrChannelPrefix(Client, Channel, Origin, + false, "MODE %s %s%s", Channel_Name(Channel), + the_modes, the_args); + } else { + if (use_servermode) + Origin = Client_ThisServer(); + /* Send reply to client and inform other servers and channel users */ + connected = IRC_WriteStrClientPrefix(Client, Origin, + "MODE %s %s%s", Channel_Name(Channel), + the_modes, the_args); + /* Only forward requests for non-local channels */ + if (!Channel_IsLocal(Channel)) + IRC_WriteStrServersPrefix(Client, Origin, + "MODE %s %s%s", Channel_Name(Channel), + the_modes, the_args); + IRC_WriteStrChannelPrefix(Client, Channel, Origin, + false, "MODE %s %s%s", Channel_Name(Channel), + the_modes, the_args); + } + } - mask = Lists_MakeMask( Pattern ); + IRC_SetPenalty(Client, 1); + return connected; +} /* Channel_Mode */ - if( ! Lists_AddInvited( mask, Channel, FALSE )) return CONNECTED; - return Send_ListChange( "+I", Prefix, Client, Channel, mask ); -} /* Add_Invite */ +/** + * Handler for the IRC "AWAY" command. + * + * @param Client The client from which this command has been received. + * @param Req Request structure with prefix and all parameters. + * @return CONNECTED or DISCONNECTED. + */ +GLOBAL bool +IRC_AWAY( CLIENT *Client, REQUEST *Req ) +{ + assert (Client != NULL); + assert (Req != NULL); + if (Req->argc == 1 && Req->argv[0][0]) { + Client_SetAway(Client, Req->argv[0]); + Client_ModeAdd(Client, 'a'); + IRC_WriteStrServersPrefix(Client, Client, "MODE %s :+a", + Client_ID( Client)); + return IRC_WriteStrClient(Client, RPL_NOWAWAY_MSG, + Client_ID( Client)); + } else { + Client_ModeDel(Client, 'a'); + IRC_WriteStrServersPrefix(Client, Client, "MODE %s :-a", + Client_ID( Client)); + return IRC_WriteStrClient(Client, RPL_UNAWAY_MSG, + Client_ID( Client)); + } +} /* IRC_AWAY */ -LOCAL BOOLEAN -Add_Ban( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern ) +/** + * Add entries to channel invite, ban and exception lists. + * + * @param what Can be 'I' for invite, 'b' for ban, and 'e' for exception list. + * @param Prefix The originator of the command. + * @param Client The sender of the command. + * @param Channel The channel of which the list should be modified. + * @param Pattern The pattern to add to the list. + * @return CONNECTED or DISCONNECTED. + */ +static bool +Add_To_List(char what, CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, + const char *Pattern) { - CHAR *mask; + char mask[MASK_LEN]; + struct list_head *list = NULL; + long int current_count; - assert( Client != NULL ); - assert( Channel != NULL ); - assert( Pattern != NULL ); + assert(Client != NULL); + assert(Channel != NULL); + assert(Pattern != NULL); + assert(what == 'I' || what == 'b' || what == 'e'); - mask = Lists_MakeMask( Pattern ); + Lists_MakeMask(Pattern, mask, sizeof(mask)); + current_count = Lists_Count(Channel_GetListInvites(Channel)) + + Lists_Count(Channel_GetListExcepts(Channel)) + + Lists_Count(Channel_GetListBans(Channel)); - if( ! Lists_AddBanned( mask, Channel )) return CONNECTED; - return Send_ListChange( "+b", Prefix, Client, Channel, mask ); -} /* Add_Ban */ + switch(what) { + case 'I': + list = Channel_GetListInvites(Channel); + break; + case 'b': + list = Channel_GetListBans(Channel); + break; + case 'e': + list = Channel_GetListExcepts(Channel); + break; + } + if (Lists_CheckDupeMask(list, mask)) + return CONNECTED; + if (Client_Type(Client) == CLIENT_USER && + current_count >= MAX_HNDL_CHANNEL_LISTS) + return IRC_WriteErrClient(Client, ERR_LISTFULL_MSG, + Client_ID(Client), + Channel_Name(Channel), mask, + MAX_HNDL_CHANNEL_LISTS); -LOCAL BOOLEAN -Del_Invite( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern ) -{ - CHAR *mask; - - assert( Client != NULL ); - assert( Channel != NULL ); - assert( Pattern != NULL ); + switch (what) { + case 'I': + if (!Channel_AddInvite(Channel, mask, false)) + return CONNECTED; + break; + case 'b': + if (!Channel_AddBan(Channel, mask)) + return CONNECTED; + break; + case 'e': + if (!Channel_AddExcept(Channel, mask)) + return CONNECTED; + break; + } + return Send_ListChange(true, what, Prefix, Client, Channel, mask); +} - mask = Lists_MakeMask( Pattern ); - Lists_DelInvited( mask, Channel ); - return Send_ListChange( "-I", Prefix, Client, Channel, mask ); -} /* Del_Invite */ +/** + * Delete entries from channel invite, ban and exception lists. + * + * @param what Can be 'I' for invite, 'b' for ban, and 'e' for exception list. + * @param Prefix The originator of the command. + * @param Client The sender of the command. + * @param Channel The channel of which the list should be modified. + * @param Pattern The pattern to add to the list. + * @return CONNECTED or DISCONNECTED. + */ +static bool +Del_From_List(char what, CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, + const char *Pattern) +{ + char mask[MASK_LEN]; + struct list_head *list = NULL; + assert(Client != NULL); + assert(Channel != NULL); + assert(Pattern != NULL); + assert(what == 'I' || what == 'b' || what == 'e'); -LOCAL BOOLEAN -Del_Ban( CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Pattern ) -{ - CHAR *mask; + Lists_MakeMask(Pattern, mask, sizeof(mask)); - assert( Client != NULL ); - assert( Channel != NULL ); - assert( Pattern != NULL ); + switch (what) { + case 'I': + list = Channel_GetListInvites(Channel); + break; + case 'b': + list = Channel_GetListBans(Channel); + break; + case 'e': + list = Channel_GetListExcepts(Channel); + break; + } - mask = Lists_MakeMask( Pattern ); - Lists_DelBanned( mask, Channel ); - return Send_ListChange( "-b", Prefix, Client, Channel, mask ); -} /* Del_Ban */ + if (!Lists_CheckDupeMask(list, mask)) + return CONNECTED; + Lists_Del(list, mask); + return Send_ListChange(false, what, Prefix, Client, Channel, mask); +} -LOCAL BOOLEAN -Send_ListChange( CHAR *Mode, CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel, CHAR *Mask ) +/** + * Send information about changed channel invite/ban/exception lists to clients. + * + * @param IsAdd true if the list item has been added, false otherwise. + * @param ModeChar The mode to use (e. g. 'b' or 'I') + * @param Prefix The originator of the mode list change. + * @param Client The sender of the command. + * @param Channel The channel of which the list has been modified. + * @param Mask The mask which has been added or removed. + * @return CONNECTED or DISCONNECTED. + */ +static bool +Send_ListChange(const bool IsAdd, const char ModeChar, CLIENT *Prefix, + CLIENT *Client, CHANNEL *Channel, const char *Mask) { - /* Bestaetigung an Client schicken & andere Server sowie Channel-User informieren */ + bool ok = true; - BOOLEAN ok; + /* Send confirmation to the client */ + if (Client_Type(Client) == CLIENT_USER) + ok = IRC_WriteStrClientPrefix(Client, Prefix, "MODE %s %c%c %s", + Channel_Name(Channel), + IsAdd ? '+' : '-', + ModeChar, Mask); - if( Client_Type( Client ) == CLIENT_USER ) - { - /* Bestaetigung an Client */ - ok = IRC_WriteStrClientPrefix( Client, Prefix, "MODE %s %s %s", Channel_Name( Channel ), Mode, Mask ); - } - else ok = TRUE; + /* to other servers */ + IRC_WriteStrServersPrefix(Client, Prefix, "MODE %s %c%c %s", + Channel_Name(Channel), IsAdd ? '+' : '-', + ModeChar, Mask); - /* an andere Server */ - IRC_WriteStrServersPrefix( Client, Prefix, "MODE %s %s %s", Channel_Name( Channel ), Mode, Mask ); + /* and local users in channel */ + IRC_WriteStrChannelPrefix(Client, Channel, Prefix, false, + "MODE %s %c%c %s", Channel_Name(Channel), + IsAdd ? '+' : '-', ModeChar, Mask ); - /* und lokale User im Channel */ - IRC_WriteStrChannelPrefix( Client, Channel, Prefix, FALSE, "MODE %s %s %s", Channel_Name( Channel ), Mode, Mask ); - return ok; } /* Send_ListChange */ - /* -eof- */