X-Git-Url: http://git.pk910.de/?a=blobdiff_plain;f=ircd%2Fclient.c;h=e3961b43ffac28d51545d7267d57f072532e8727;hb=refs%2Fheads%2Fupstream-ssl;hp=e978f77fbaa417c3df17223e6a4687263c4e4558;hpb=79035436c61e2b58004b47f250ab1e54744a88d6;p=ircu2.10.12-pk.git diff --git a/ircd/client.c b/ircd/client.c index e978f77..e3961b4 100644 --- a/ircd/client.c +++ b/ircd/client.c @@ -15,8 +15,10 @@ * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * $Id$ + */ +/** @file + * @brief Implementation of functions for handling local clients. + * @version $Id$ */ #include "config.h" @@ -24,6 +26,7 @@ #include "class.h" #include "ircd.h" #include "ircd_features.h" +#include "ircd_log.h" #include "ircd_reply.h" #include "list.h" #include "msgq.h" @@ -33,15 +36,14 @@ #include "send.h" #include "struct.h" -#include +/* #include -- Now using assert in ircd_log.h */ #include -#define BAD_PING ((unsigned int)-2) - -/* - * client_get_ping - * returns shortest ping time in attached server or client conf - * classes or PINGFREQUENCY +/** Find the shortest non-zero ping time attached to a client. + * If all attached ping times are zero, return the value for + * FEAT_PINGFREQUENCY. + * @param[in] acptr Client to find ping time for. + * @return Ping time in seconds. */ int client_get_ping(const struct Client* acptr) { @@ -67,9 +69,9 @@ int client_get_ping(const struct Client* acptr) return ping; } -/* - * client_get_default_umode - * returns default usermode in attached client connection class +/** Find the default usermode for a client. + * @param[in] sptr Client to find default usermode for. + * @return Pointer to usermode string (or NULL, if there is no default). */ const char* client_get_default_umode(const struct Client* sptr) { @@ -86,10 +88,8 @@ const char* client_get_default_umode(const struct Client* sptr) return NULL; } -/* - * client_drop_sendq - * removes the client's connection from the list of connections with - * queued data +/** Remove a connection from the list of connections with queued data. + * @param[in] con Connection with no queued data. */ void client_drop_sendq(struct Connection* con) { @@ -103,10 +103,9 @@ void client_drop_sendq(struct Connection* con) } } -/* - * client_add_sendq - * adds the client's connection to the list of connections with - * queued data +/** Add a connection to the list of connections with queued data. + * @param[in] con Connection with queued data. + * @param[in,out] con_p Previous pointer to next connection. */ void client_add_sendq(struct Connection* con, struct Connection** con_p) { @@ -120,59 +119,68 @@ void client_add_sendq(struct Connection* con, struct Connection** con_p) } } +/** Default privilege set for global operators. */ static struct Privs privs_global; +/** Default privilege set for local operators. */ static struct Privs privs_local; +/** Non-zero if #privs_global and #privs_local have been initialized. */ static int privs_defaults_set; /* client_set_privs(struct Client* client) * * Sets the privileges for opers. */ +/** Set the privileges for a client. + * @param[in] client Client who has become an operator. + * @param[in] oper Configuration item describing oper's privileges. + */ void client_set_privs(struct Client *client, struct ConfItem *oper) { struct Privs *source, *defaults; enum Priv priv; + if (!MyConnect(client)) + return; + + /* Clear out client's privileges. */ + memset(cli_privs(client), 0, sizeof(struct Privs)); + + if (!IsAnOper(client) || !oper) + return; + if (!privs_defaults_set) { memset(&privs_global, -1, sizeof(privs_global)); + FlagClr(&privs_global, PRIV_WALK_LCHAN); + FlagClr(&privs_global, PRIV_UNLIMIT_QUERY); + FlagClr(&privs_global, PRIV_SET); + FlagClr(&privs_global, PRIV_BADCHAN); + FlagClr(&privs_global, PRIV_LOCAL_BADCHAN); + FlagClr(&privs_global, PRIV_APASS_OPMODE); + memset(&privs_local, 0, sizeof(privs_local)); - PrivSet(&privs_local, PRIV_CHAN_LIMIT); - PrivSet(&privs_local, PRIV_MODE_LCHAN); - PrivSet(&privs_local, PRIV_SHOW_INVIS); - PrivSet(&privs_local, PRIV_SHOW_ALL_INVIS); - PrivSet(&privs_local, PRIV_LOCAL_KILL); - PrivSet(&privs_local, PRIV_REHASH); - PrivSet(&privs_local, PRIV_LOCAL_GLINE); - PrivSet(&privs_local, PRIV_LOCAL_JUPE); - PrivSet(&privs_local, PRIV_LOCAL_OPMODE); - PrivSet(&privs_local, PRIV_WHOX); - PrivSet(&privs_local, PRIV_DISPLAY); - PrivSet(&privs_local, PRIV_FORCE_LOCAL_OPMODE); - privs_defaults_set = 1; - } - memset(&(cli_privs(client)), 0, sizeof(struct Privs)); + FlagSet(&privs_local, PRIV_CHAN_LIMIT); + FlagSet(&privs_local, PRIV_MODE_LCHAN); + FlagSet(&privs_local, PRIV_SHOW_INVIS); + FlagSet(&privs_local, PRIV_SHOW_ALL_INVIS); + FlagSet(&privs_local, PRIV_LOCAL_KILL); + FlagSet(&privs_local, PRIV_REHASH); + FlagSet(&privs_local, PRIV_LOCAL_GLINE); + FlagSet(&privs_local, PRIV_LOCAL_JUPE); + FlagSet(&privs_local, PRIV_LOCAL_OPMODE); + FlagSet(&privs_local, PRIV_WHOX); + FlagSet(&privs_local, PRIV_DISPLAY); + FlagSet(&privs_local, PRIV_FORCE_LOCAL_OPMODE); - if (!IsAnOper(client)) - return; - else if (!MyConnect(client)) - { - memset(&(cli_privs(client)), 255, sizeof(struct Privs)); - PrivClr(&(cli_privs(client)), PRIV_SET); - return; + privs_defaults_set = 1; } - else if (oper == NULL) - return; - - /* Clear out client's privileges. */ - memset(&cli_privs(client), 0, sizeof(struct Privs)); /* Decide whether to use global or local oper defaults. */ - if (PrivHas(&oper->privs_dirty, PRIV_PROPAGATE)) - defaults = PrivHas(&oper->privs, PRIV_PROPAGATE) ? &privs_global : &privs_local; - else if (PrivHas(&oper->conn_class->privs_dirty, PRIV_PROPAGATE)) - defaults = PrivHas(&oper->conn_class->privs, PRIV_PROPAGATE) ? &privs_global : &privs_local; + if (FlagHas(&oper->privs_dirty, PRIV_PROPAGATE)) + defaults = FlagHas(&oper->privs, PRIV_PROPAGATE) ? &privs_global : &privs_local; + else if (FlagHas(&oper->conn_class->privs_dirty, PRIV_PROPAGATE)) + defaults = FlagHas(&oper->conn_class->privs, PRIV_PROPAGATE) ? &privs_global : &privs_local; else { assert(0 && "Oper has no propagation and neither does connection class"); return; @@ -184,39 +192,41 @@ client_set_privs(struct Client *client, struct ConfItem *oper) for (priv = 0; priv < PRIV_LAST_PRIV; ++priv) { /* Figure out most applicable definition for the privilege. */ - if (PrivHas(&oper->privs_dirty, priv)) + if (FlagHas(&oper->privs_dirty, priv)) source = &oper->privs; - else if (PrivHas(&oper->conn_class->privs_dirty, priv)) + else if (FlagHas(&oper->conn_class->privs_dirty, priv)) source = &oper->conn_class->privs; else source = defaults; /* Set it if necessary (privileges were already cleared). */ - if (PrivHas(source, priv)) - PrivSet(&cli_privs(client), priv); + if (FlagHas(source, priv)) + SetPriv(client, priv); } /* This should be handled in the config, but lets be sure... */ - if (PrivHas(&cli_privs(client), PRIV_PROPAGATE)) + if (HasPriv(client, PRIV_PROPAGATE)) { /* force propagating opers to display */ - PrivSet(&cli_privs(client), PRIV_DISPLAY); + SetPriv(client, PRIV_DISPLAY); } else { /* if they don't propagate oper status, prevent desyncs */ - PrivClr(&cli_privs(client), PRIV_KILL); - PrivClr(&cli_privs(client), PRIV_GLINE); - PrivClr(&cli_privs(client), PRIV_JUPE); - PrivClr(&cli_privs(client), PRIV_OPMODE); - PrivClr(&cli_privs(client), PRIV_BADCHAN); + ClrPriv(client, PRIV_KILL); + ClrPriv(client, PRIV_GLINE); + ClrPriv(client, PRIV_JUPE); + ClrPriv(client, PRIV_OPMODE); + ClrPriv(client, PRIV_BADCHAN); } } +/** Array mapping privilege values to names and vice versa. */ static struct { - char *name; - unsigned int priv; + char *name; /**< Name of privilege. */ + unsigned int priv; /**< Enumeration value of privilege */ } privtab[] = { +/** Helper macro to define an array entry for a privilege. */ #define P(priv) { #priv, PRIV_ ## priv } P(CHAN_LIMIT), P(MODE_LCHAN), P(WALK_LCHAN), P(DEOP_LCHAN), P(SHOW_INVIS), P(SHOW_ALL_INVIS), P(UNLIMIT_QUERY), P(KILL), @@ -224,15 +234,16 @@ static struct { P(GLINE), P(LOCAL_GLINE), P(JUPE), P(LOCAL_JUPE), P(OPMODE), P(LOCAL_OPMODE), P(SET), P(WHOX), P(BADCHAN), P(LOCAL_BADCHAN), P(SEE_CHAN), P(PROPAGATE), - P(DISPLAY), P(SEE_OPERS), P(FORCE_OPMODE), P(FORCE_LOCAL_OPMODE), - P(WIDE_GLINE), + P(DISPLAY), P(SEE_OPERS), P(WIDE_GLINE), P(LIST_CHAN), + P(FORCE_OPMODE), P(FORCE_LOCAL_OPMODE), P(APASS_OPMODE), #undef P { 0, 0 } }; -/* client_report_privs(struct Client *to, struct Client *client) - * - * Sends a summary of the oper's privileges to the oper. +/** Report privileges of \a client to \a to. + * @param[in] to Client requesting privilege list. + * @param[in] client Client whos privileges should be listed. + * @return Zero. */ int client_report_privs(struct Client *to, struct Client *client)