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         char buf[512];
  87         struct mode_table *p;
  88
  89         buf[0] = '\0';
  90         if (target_p->user->privset)
  91                 rb_strlcat(buf, target_p->user->privset->privs, sizeof buf);
  92         if (IsOper(target_p))
  93         {
  94                 if (target_p->user->opername)
  95                 {
  96                         if (buf[0] != '\0')
  97                                 rb_strlcat(buf, " ", sizeof buf);
  98                         rb_strlcat(buf, "operator:", sizeof buf);
  99                         rb_strlcat(buf, target_p->user->opername, sizeof buf);
 100                 }
 101
 102                 if (target_p->user->privset)
 103                 {
 104                         if (buf[0] != '\0')
 105                                 rb_strlcat(buf, " ", sizeof buf);
 106                         rb_strlcat(buf, "privset:", sizeof buf);
 107                         rb_strlcat(buf, target_p->user->privset->name, sizeof buf);
 108                 }
 109         }
 110         p = &auth_client_table[0];
 111         while (p->name != NULL)
 112         {
 113                 if (target_p->flags & p->mode)
 114                 {
 115                         if (buf[0] != '\0')
 116                                 rb_strlcat(buf, " ", sizeof buf);
 117                         rb_strlcat(buf, p->name, sizeof buf);
 118                 }
 119                 p++;
 120         }
 121         sendto_one_numeric(source_p, RPL_PRIVS, form_str(RPL_PRIVS),
 122                         target_p->name, buf);
 123 }
 124
 125 static void
 126 me_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 127 {
 128         struct Client *target_p;
 129
 130         if (!IsOper(source_p) || parc < 2 || EmptyString(parv[1]))
 131                 return;
 132
 133         target_p = find_person(parv[1]);
 134
 135         if (target_p != NULL)
 136                 show_privs(source_p, target_p);
 137 }
 138
 139 static void
 140 mo_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 141 {
 142         struct Client *target_p;
 143         struct Client *server_p;
 144
 145         if (parc < 2 || EmptyString(parv[1]))
 146         {
 147                 server_p = target_p = source_p;
 148         }
 149         else
 150         {
 151                 if (parc >= 3)
 152                 {
 153                         server_p = find_named_client(parv[1]);
 154                         target_p = find_named_person(parv[2]);
 155                 }
 156                 else
 157                 {
 158                         server_p = target_p = find_named_person(parv[1]);
 159                 }
 160                 if (server_p == NULL || target_p == NULL)
 161                 {
 162                         sendto_one_numeric(source_p, ERR_NOSUCHNICK,
 163                                            form_str(ERR_NOSUCHNICK), parv[1]);
 164                         return;
 165                 }
 166         }
 167
 168         if (!IsServer(server_p))
 169                 server_p = server_p->servptr;
 170
 171         if (IsMe(server_p))
 172                 show_privs(source_p, target_p);
 173         else
 174                 sendto_one(server_p, ":%s ENCAP %s PRIVS %s",
 175                                 get_id(source_p, server_p),
 176                                 server_p->name,
 177                                 use_id(target_p));
 178 }
 179
 180 static void
 181 m_privs(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 182 {
 183         if (parc >= 2 && !EmptyString(parv[1]) &&
 184                         irccmp(parv[1], source_p->name)) {
 185                 sendto_one_numeric(source_p, ERR_NOPRIVILEGES,
 186                                    form_str(ERR_NOPRIVILEGES));
 187                 return;
 188         }
 189
 190         show_privs(source_p, source_p);
 191 }