modules/m_privs.c

   1 /*
   2  * m_privs.c: Shows effective operator privileges
   3  *
   4  * Copyright (C) 2008 Jilles Tjoelker
   5  * Copyright (C) 2008 charybdis development team
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are
   9  * met:
  10  *
  11  * 1.Redistributions of source code must retain the above copyright notice,
  12  *   this list of conditions and the following disclaimer.
  13  * 2.Redistributions in binary form must reproduce the above copyright
  14  *   notice, this list of conditions and the following disclaimer in the
  15  *   documentation and/or other materials provided with the distribution.
  16  * 3.The name of the author may not be used to endorse or promote products
  17  *   derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  28  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "stdinc.h"
  33 #include "client.h"
  34 #include "numeric.h"
  35 #include "send.h"
  36 #include "msg.h"
  37 #include "parse.h"
  38 #include "modules.h"
  39 #include "s_conf.h"
  40 #include "s_newconf.h"
  41 #include "hash.h"
  42
  43 static const char privs_desc[] = "Provides the PRIVS command to inspect an operator's privileges";
  44
  45 static void m_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
  46 static void me_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
  47 static void mo_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
  48
  49 struct Message privs_msgtab = {
  50         "PRIVS", 0, 0, 0, 0,
  51         {mg_unreg, {m_privs, 0}, mg_ignore, mg_ignore, {me_privs, 0}, {mo_privs, 0}}
  52 };
  53
  54 mapi_clist_av1 privs_clist[] = {
  55         &privs_msgtab,
  56         NULL
  57 };
  58
  59 /* XXX this is a copy, not so nice
  60  *
  61  * Sort of... it's int in newconf.c since oper confs don't need 64-bit wide flags.
  62  * --Elizafox
  63  */
  64 struct mode_table
  65 {
  66         const char *name;
  67         uint64_t mode;
  68 };
  69
  70 /* there is no such table like this anywhere else */
  71 static struct mode_table auth_client_table[] = {
  72         {"resv_exempt",         FLAGS_EXEMPTRESV        },
  73         {"kline_exempt",        FLAGS_EXEMPTKLINE       },
  74         {"flood_exempt",        FLAGS_EXEMPTFLOOD       },
  75         {"spambot_exempt",      FLAGS_EXEMPTSPAMBOT     },
  76         {"shide_exempt",        FLAGS_EXEMPTSHIDE       },
  77         {"jupe_exempt",         FLAGS_EXEMPTJUPE        },
  78         {"extend_chans",        FLAGS_EXTENDCHANS       },
  79         {NULL, 0}
  80 };
  81
  82 DECLARE_MODULE_AV2(privs, NULL, NULL, privs_clist, NULL, NULL, NULL, NULL, privs_desc);
  83
  84 static void show_privs(struct Client *source_p, struct Client *target_p)
  85 {
  86         struct mode_table *p;
  87
  88         send_multiline_init(source_p, " ", form_str(RPL_PRIVS),
  89                         get_id(&me, source_p),
  90                         get_id(source_p, source_p),
  91                         target_p->name,
  92                         "* ");
  93
  94         send_multiline_remote_pad(source_p, &me);
  95         send_multiline_remote_pad(source_p, source_p);
  96
  97         if (target_p->user->privset)
  98                 for (const char *const *s = privilegeset_privs(target_p->user->privset); *s != NULL; s++)
  99                         send_multiline_item(source_p, "%s", *s);
 100
 101         if (IsOper(target_p))
 102         {
 103                 if (target_p->user->opername)
 104                         send_multiline_item(source_p, "operator:%s", target_p->user->opername);
 105
 106                 if (target_p->user->privset)
 107                         send_multiline_item(source_p, "privset:%s", target_p->user->privset->name);
 108         }
 109         p = &auth_client_table[0];
 110         while (p->name != NULL)
 111         {
 112                 if (target_p->flags & p->mode)
 113                         send_multiline_item(source_p, "%s", p->name);
 114                 p++;
 115         }
 116
 117         send_multiline_fini(source_p, form_str(RPL_PRIVS),
 118                         get_id(&me, source_p),
 119                         get_id(source_p, source_p),
 120                         target_p->name,
 121                         "");
 122 }
 123
 124 static void
 125 me_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 126 {
 127         struct Client *target_p;
 128
 129         if (!IsOper(source_p) || parc < 2 || EmptyString(parv[1]))
 130                 return;
 131
 132         target_p = find_person(parv[1]);
 133
 134         if (target_p != NULL)
 135                 show_privs(source_p, target_p);
 136 }
 137
 138 static void
 139 mo_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 140 {
 141         struct Client *target_p;
 142         struct Client *server_p;
 143
 144         if (parc < 2 || EmptyString(parv[1]))
 145         {
 146                 server_p = target_p = source_p;
 147         }
 148         else
 149         {
 150                 if (parc >= 3)
 151                 {
 152                         server_p = find_named_client(parv[1]);
 153                         target_p = find_named_person(parv[2]);
 154                 }
 155                 else
 156                 {
 157                         server_p = target_p = find_named_person(parv[1]);
 158                 }
 159                 if (server_p == NULL || target_p == NULL)
 160                 {
 161                         sendto_one_numeric(source_p, ERR_NOSUCHNICK,
 162                                            form_str(ERR_NOSUCHNICK), parv[1]);
 163                         return;
 164                 }
 165         }
 166
 167         if (target_p != source_p && !HasPrivilege(source_p, "oper:privs"))
 168         {
 169                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 170                            me.name, source_p->name, "privs");
 171                 return;
 172         }
 173
 174         if (!IsServer(server_p))
 175                 server_p = server_p->servptr;
 176
 177         if (IsMe(server_p))
 178                 show_privs(source_p, target_p);
 179         else
 180                 sendto_one(server_p, ":%s ENCAP %s PRIVS %s",
 181                                 get_id(source_p, server_p),
 182                                 server_p->name,
 183                                 use_id(target_p));
 184 }
 185
 186 static void
 187 m_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 188 {
 189         if (parc >= 2 && !EmptyString(parv[1]) &&
 190                         irccmp(parv[1], source_p->name)) {
 191                 sendto_one_numeric(source_p, ERR_NOPRIVILEGES,
 192                                    form_str(ERR_NOPRIVILEGES));
 193                 return;
 194         }
 195
 196         show_privs(source_p, source_p);
 197 }