modules/m_scan.c

   1 /*
   2  *  charybdis: an advanced Internet Relay Chat Daemon(ircd).
   3  *  m_scan.c: Provides information about various targets on various topics
   4  *
   5  *  Copyright (c) 2006 William Pitcock <nenolod -at- nenolod.net>
   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  *  $Id: m_scan.c 1853 2006-08-24 18:30:52Z jilles $
  32  */
  33
  34 #include "stdinc.h"
  35 #include "class.h"
  36 #include "hook.h"
  37 #include "client.h"
  38 #include "hash.h"
  39 #include "common.h"
  40 #include "hash.h"
  41 #include "match.h"
  42 #include "ircd.h"
  43 #include "numeric.h"
  44 #include "s_serv.h"
  45 #include "s_conf.h"
  46 #include "s_newconf.h"
  47 #include "s_user.h"
  48 #include "send.h"
  49 #include "msg.h"
  50 #include "parse.h"
  51 #include "modules.h"
  52
  53 static int mo_scan(struct Client *, struct Client *, int, const char **);
  54 static int scan_umodes(struct Client *, struct Client *, int, const char **);
  55 /*static int scan_cmodes(struct Client *, struct Client *, int, const char **);*/
  56
  57 struct Message scan_msgtab = {
  58         "SCAN", 0, 0, 0, MFLG_SLOW,
  59         {mg_ignore, mg_not_oper, mg_ignore, mg_ignore, mg_ignore, {mo_scan, 2}}
  60 };
  61
  62 mapi_clist_av1 scan_clist[] = { &scan_msgtab, NULL };
  63 DECLARE_MODULE_AV1(scan, NULL, NULL, scan_clist, NULL, NULL, "$Revision: 1853 $");
  64
  65 typedef int (*scan_handler)(struct Client *, struct Client *, int,
  66         const char **);
  67
  68 struct scan_cmd {
  69         const char *name;
  70         int operlevel;
  71         scan_handler handler;
  72 } scan_cmds[] = {
  73         {"UMODES", L_OPER, scan_umodes},
  74         {NULL, 0, NULL}
  75 };
  76
  77 static const char *empty_sockhost = "255.255.255.255";
  78 static const char *spoofed_sockhost = "0";
  79
  80 /*
  81  * m_scan
  82  *      parv[1] = options [or target]
  83  *      parv[2] = [target]
  84  */
  85 static int
  86 mo_scan(struct Client *client_p, struct Client *source_p, int parc,
  87         const char *parv[])
  88 {
  89         struct scan_cmd *sptr;
  90
  91         for (sptr = scan_cmds; sptr->name != NULL; sptr++)
  92         {
  93                 if (!irccmp(sptr->name, parv[1]))
  94                 {
  95                         if (sptr->operlevel == L_ADMIN &&
  96                                 !IsOperAdmin(source_p))
  97                                 return -1;
  98                         else
  99                                 return sptr->handler(client_p, source_p, parc, parv);
 100                 }
 101         }
 102
 103         sendto_one_notice(source_p, ":*** %s is not an implemented SCAN target",
 104                           parv[1]);
 105
 106         return 0;
 107 }
 108
 109 static int
 110 scan_umodes(struct Client *client_p, struct Client *source_p, int parc,
 111         const char *parv[])
 112 {
 113         unsigned int allowed_umodes = 0, disallowed_umodes = 0;
 114         int what = MODE_ADD;
 115         int mode;
 116         int list_users = YES;
 117         int list_max = 500;
 118         int list_count = 0, count = 0;
 119         const char *mask = NULL;
 120         const char *c;
 121         struct Client *target_p;
 122         rb_dlink_list *target_list = &lclient_list;     /* local clients only by default */
 123         rb_dlink_node *tn;
 124         int i;
 125         const char *sockhost;
 126         char buf[512];
 127
 128         if (parc < 3)
 129         {
 130                 if (MyClient(source_p))
 131                         sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
 132                                 me.name, source_p->name, "SCAN UMODES");
 133
 134                 return -1;
 135         }
 136
 137         if (parv[2][0] != '+' && parv[2][0] != '-')
 138         {
 139                 sendto_one_notice(source_p, ":SCAN UMODES: umodes parameter must start with '+' or '-'");
 140                 return -1;
 141         }
 142
 143         for (c = parv[2]; *c; c++)
 144         {
 145                 switch(*c)
 146                 {
 147                         case '+':
 148                                 what = MODE_ADD;
 149                                 break;
 150                         case '-':
 151                                 what = MODE_DEL;
 152                                 break;
 153                         default:
 154                                 if ((mode = user_modes[(unsigned char) *c]) != 0)
 155                                 {
 156                                         if (what == MODE_ADD)
 157                                                 allowed_umodes |= mode;
 158                                         else
 159                                                 disallowed_umodes |= mode;
 160                                 }
 161                 }
 162         }
 163
 164         for (i = 3; i < parc; i++)
 165         {
 166                 if (!irccmp(parv[i], "no-list"))
 167                         list_users = NO;
 168                 else if (!irccmp(parv[i], "list"))
 169                         list_users = YES;
 170                 else if (!irccmp(parv[i], "global"))
 171                         target_list = &global_client_list;
 172                 else if (i < (parc - 1))
 173                 {
 174                         if (!irccmp(parv[i], "list-max"))
 175                                 list_max = atoi(parv[++i]);
 176                         else if (!irccmp(parv[i], "mask"))
 177                                 mask = parv[++i];
 178                         else
 179                         {
 180                                 sendto_one_notice(source_p, ":SCAN UMODES: invalid parameters");
 181                                 return -1;
 182                         }
 183                 }
 184                 else
 185                 {
 186                         sendto_one_notice(source_p, ":SCAN UMODES: invalid parameters");
 187                         return -1;
 188                 }
 189         }
 190         if (target_list == &global_client_list && list_users)
 191         {
 192                 if (IsOperSpy(source_p))
 193                 {
 194                         if (!ConfigFileEntry.operspy_dont_care_user_info)
 195                         {
 196                                 rb_strlcpy(buf, "UMODES", sizeof buf);
 197                                 for (i = 2; i < parc; i++)
 198                                 {
 199                                         rb_strlcat(buf, " ", sizeof buf);
 200                                         rb_strlcat(buf, parv[i], sizeof buf);
 201                                 }
 202                                 report_operspy(source_p, "SCAN", buf);
 203                         }
 204                 }
 205                 else
 206                 {
 207                         sendto_one(source_p, form_str(ERR_NOPRIVS),
 208                                    me.name, source_p->name, "oper_spy");
 209                         return -1;
 210                 }
 211         }
 212
 213         RB_DLINK_FOREACH(tn, target_list->head)
 214         {
 215                 unsigned int working_umodes = 0;
 216                 char maskbuf[BUFSIZE];
 217
 218                 target_p = tn->data;
 219
 220                 if (!IsClient(target_p))
 221                         continue;
 222
 223                 if(EmptyString(target_p->sockhost))
 224                         sockhost = empty_sockhost;
 225                 else if(!show_ip(source_p, target_p))
 226                         sockhost = spoofed_sockhost;
 227                 else
 228                         sockhost = target_p->sockhost;
 229
 230                 working_umodes = target_p->umodes;
 231
 232                 /* require that we have the allowed umodes... */
 233                 if ((working_umodes & allowed_umodes) != allowed_umodes)
 234                         continue;
 235
 236                 /* require that we have NONE of the disallowed ones */
 237                 if ((working_umodes & disallowed_umodes) != 0)
 238                         continue;
 239
 240                 if (mask != NULL)
 241                 {
 242                         rb_snprintf(maskbuf, BUFSIZE, "%s!%s@%s",
 243                                 target_p->name, target_p->username, target_p->host);
 244
 245                         if (!match(mask, maskbuf))
 246                                 continue;
 247                 }
 248
 249                 if (list_users && (!list_max || (list_count < list_max)))
 250                 {
 251                         char modebuf[BUFSIZE];
 252                         char *m = modebuf;
 253
 254                         *m++ = '+';
 255
 256                         for (i = 0; i < 128; i++)
 257                         {
 258                                 if (target_p->umodes & user_modes[i])
 259                                         *m++ = (char) i;
 260                         }
 261
 262                         *m++ = '\0';
 263
 264                         list_count++;
 265
 266                         sendto_one_numeric(source_p, RPL_SCANUMODES,
 267                                                 form_str(RPL_SCANUMODES),
 268                                                 target_p->name, target_p->username,
 269                                                 target_p->host, sockhost,
 270                                                 target_p->servptr->name, modebuf,
 271                                                 target_p->info);
 272                 }
 273                 count++;
 274         }
 275
 276         sendto_one_numeric(source_p, RPL_SCANMATCHED,
 277                         form_str(RPL_SCANMATCHED), count);
 278
 279         return 0;
 280 }