modules/m_kline.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  m_kline.c: Bans/unbans a user.
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22  *  USA
  23  *
  24  *  $Id$
  25  */
  26
  27 #include "stdinc.h"
  28 #include "channel.h"
  29 #include "class.h"
  30 #include "client.h"
  31 #include "common.h"
  32 #include "match.h"
  33 #include "ircd.h"
  34 #include "hostmask.h"
  35 #include "numeric.h"
  36 #include "s_conf.h"
  37 #include "s_newconf.h"
  38 #include "logger.h"
  39 #include "send.h"
  40 #include "hash.h"
  41 #include "s_serv.h"
  42 #include "msg.h"
  43 #include "parse.h"
  44 #include "modules.h"
  45 #include "reject.h"
  46 #include "bandbi.h"
  47 #include "operhash.h"
  48
  49 static int mo_kline(struct Client *, struct Client *, int, const char **);
  50 static int ms_kline(struct Client *, struct Client *, int, const char **);
  51 static int me_kline(struct Client *, struct Client *, int, const char **);
  52 static int mo_unkline(struct Client *, struct Client *, int, const char **);
  53 static int ms_unkline(struct Client *, struct Client *, int, const char **);
  54 static int me_unkline(struct Client *, struct Client *, int, const char **);
  55
  56 struct Message kline_msgtab = {
  57         "KLINE", 0, 0, 0, MFLG_SLOW,
  58         {mg_unreg, mg_not_oper, {ms_kline, 5}, {ms_kline, 5}, {me_kline, 5}, {mo_kline, 3}}
  59 };
  60
  61 struct Message unkline_msgtab = {
  62         "UNKLINE", 0, 0, 0, MFLG_SLOW,
  63         {mg_unreg, mg_not_oper, {ms_unkline, 4}, {ms_unkline, 4}, {me_unkline, 3}, {mo_unkline, 2}}
  64 };
  65
  66 mapi_clist_av1 kline_clist[] = { &kline_msgtab, &unkline_msgtab, NULL };
  67
  68 DECLARE_MODULE_AV1(kline, NULL, NULL, kline_clist, NULL, NULL, "$Revision$");
  69
  70 /* Local function prototypes */
  71 static int find_user_host(struct Client *source_p, const char *userhost, char *user, char *host);
  72 static int valid_comment(struct Client *source_p, char *comment);
  73 static int valid_user_host(struct Client *source_p, const char *user, const char *host);
  74 static int valid_wild_card(struct Client *source_p, const char *user, const char *host);
  75
  76 static void handle_remote_kline(struct Client *source_p, int tkline_time,
  77                                 const char *user, const char *host, const char *reason);
  78 static void apply_kline(struct Client *source_p, struct ConfItem *aconf,
  79                         const char *reason, const char *oper_reason);
  80 static void apply_tkline(struct Client *source_p, struct ConfItem *aconf,
  81                          const char *, const char *, int);
  82 static void apply_prop_kline(struct Client *source_p, struct ConfItem *aconf,
  83                          const char *, const char *, int);
  84 static int already_placed_kline(struct Client *, const char *, const char *, int);
  85
  86 static void handle_remote_unkline(struct Client *source_p, const char *user, const char *host);
  87 static void remove_permkline_match(struct Client *, struct ConfItem *);
  88 static int remove_temp_kline(struct Client *, struct ConfItem *);
  89 static void remove_prop_kline(struct Client *, struct ConfItem *);
  90
  91 /* mo_kline()
  92  *
  93  *   parv[1] - temp time or user@host
  94  *   parv[2] - user@host, "ON", or reason
  95  *   parv[3] - "ON", reason, or server to target
  96  *   parv[4] - server to target, or reason
  97  *   parv[5] - reason
  98  */
  99 static int
 100 mo_kline(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 101 {
 102         char def[] = "No Reason";
 103         char user[USERLEN + 2];
 104         char host[HOSTLEN + 2];
 105         char *reason = def;
 106         char *oper_reason;
 107         const char *target_server = NULL;
 108         struct ConfItem *aconf;
 109         int tkline_time = 0;
 110         int loc = 1;
 111         int propagated = 1;
 112
 113         if(!IsOperK(source_p))
 114         {
 115                 sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "kline");
 116                 return 0;
 117         }
 118
 119         if((tkline_time = valid_temp_time(parv[loc])) >= 0)
 120                 loc++;
 121         /* we just set tkline_time to -1! */
 122         else
 123                 tkline_time = 0;
 124
 125         if(find_user_host(source_p, parv[loc], user, host) == 0)
 126                 return 0;
 127
 128         loc++;
 129
 130         if(parc >= loc + 2 && !irccmp(parv[loc], "ON"))
 131         {
 132                 if(!IsOperRemoteBan(source_p))
 133                 {
 134                         sendto_one(source_p, form_str(ERR_NOPRIVS),
 135                                    me.name, source_p->name, "remoteban");
 136                         return 0;
 137                 }
 138
 139                 target_server = parv[loc + 1];
 140                 loc += 2;
 141         }
 142
 143         if(parc <= loc || EmptyString(parv[loc]))
 144         {
 145                 sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
 146                            me.name, source_p->name, "KLINE");
 147                 return 0;
 148         }
 149
 150         reason = LOCAL_COPY(parv[loc]);
 151
 152         if(target_server != NULL)
 153         {
 154                 propagate_generic(source_p, "KLINE", target_server, CAP_KLN,
 155                                   "%d %s %s :%s", tkline_time, user, host, reason);
 156
 157                 /* If we are sending it somewhere that doesnt include us, stop */
 158                 if(!match(target_server, me.name))
 159                         return 0;
 160
 161                 /* Set as local-only. */
 162                 propagated = 0;
 163         }
 164         /* if we have cluster servers, send it to them.. */
 165         else if(!propagated && rb_dlink_list_length(&cluster_conf_list) > 0)
 166                 cluster_generic(source_p, "KLINE",
 167                                 (tkline_time > 0) ? SHARED_TKLINE : SHARED_PKLINE, CAP_KLN,
 168                                 "%lu %s %s :%s", tkline_time, user, host, reason);
 169
 170         if(!valid_user_host(source_p, user, host) ||
 171            !valid_wild_card(source_p, user, host) || !valid_comment(source_p, reason))
 172                 return 0;
 173
 174         if(propagated && tkline_time == 0)
 175         {
 176                 sendto_one_notice(source_p, ":Cannot set a permanent global ban");
 177                 return 0;
 178         }
 179
 180         if(already_placed_kline(source_p, user, host, tkline_time))
 181                 return 0;
 182
 183         rb_set_time();
 184         aconf = make_conf();
 185         aconf->status = CONF_KILL;
 186         aconf->created = rb_current_time();
 187         aconf->host = rb_strdup(host);
 188         aconf->user = rb_strdup(user);
 189         aconf->port = 0;
 190         aconf->info.oper = operhash_add(get_oper_name(source_p));
 191
 192         /* Look for an oper reason */
 193         if((oper_reason = strchr(reason, '|')) != NULL)
 194         {
 195                 *oper_reason = '\0';
 196                 oper_reason++;
 197
 198                 if(!EmptyString(oper_reason))
 199                         aconf->spasswd = rb_strdup(oper_reason);
 200         }
 201         aconf->passwd = rb_strdup(reason);
 202
 203         if(propagated)
 204                 apply_prop_kline(source_p, aconf, reason, oper_reason, tkline_time);
 205         else if(tkline_time > 0)
 206                 apply_tkline(source_p, aconf, reason, oper_reason, tkline_time);
 207         else
 208                 apply_kline(source_p, aconf, reason, oper_reason);
 209
 210         if(ConfigFileEntry.kline_delay)
 211         {
 212                 if(kline_queued == 0)
 213                 {
 214                         rb_event_addonce("check_klines", check_klines_event, NULL,
 215                                          ConfigFileEntry.kline_delay);
 216                         kline_queued = 1;
 217                 }
 218         }
 219         else
 220                 check_klines();
 221
 222         return 0;
 223 }
 224
 225 /* ms_kline()
 226  *
 227  *   parv[1] - server targeted at
 228  *   parv[2] - tkline time (0 if perm)
 229  *   parv[3] - user
 230  *   parv[4] - host
 231  *   parv[5] - reason
 232  */
 233 static int
 234 ms_kline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 235 {
 236         int tkline_time = atoi(parv[2]);
 237
 238         /* 1.5-3 and earlier contains a bug that allows remote klines to be
 239          * sent with an empty reason field.  This is a protocol violation,
 240          * but its not worth dropping the link over.. --anfl
 241          */
 242         if(parc < 6 || EmptyString(parv[5]))
 243                 return 0;
 244
 245         propagate_generic(source_p, "KLINE", parv[1], CAP_KLN,
 246                           "%d %s %s :%s", tkline_time, parv[3], parv[4], parv[5]);
 247
 248         if(!match(parv[1], me.name))
 249                 return 0;
 250
 251         if(!IsPerson(source_p))
 252                 return 0;
 253
 254         handle_remote_kline(source_p, tkline_time, parv[3], parv[4], parv[5]);
 255         return 0;
 256 }
 257
 258 static int
 259 me_kline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 260 {
 261         /* <tkline_time> <user> <host> :<reason> */
 262         if(!IsPerson(source_p))
 263                 return 0;
 264
 265         handle_remote_kline(source_p, atoi(parv[1]), parv[2], parv[3], parv[4]);
 266         return 0;
 267 }
 268
 269 static void
 270 handle_remote_kline(struct Client *source_p, int tkline_time,
 271                     const char *user, const char *host, const char *kreason)
 272 {
 273         char *reason = LOCAL_COPY(kreason);
 274         struct ConfItem *aconf = NULL;
 275         char *oper_reason;
 276
 277         if(!find_shared_conf(source_p->username, source_p->host,
 278                              source_p->servptr->name,
 279                              (tkline_time > 0) ? SHARED_TKLINE : SHARED_PKLINE))
 280                 return;
 281
 282         if(!valid_user_host(source_p, user, host) ||
 283            !valid_wild_card(source_p, user, host) || !valid_comment(source_p, reason))
 284                 return;
 285
 286         if(already_placed_kline(source_p, user, host, tkline_time))
 287                 return;
 288
 289         aconf = make_conf();
 290
 291         aconf->status = CONF_KILL;
 292         aconf->created = rb_current_time();
 293         aconf->user = rb_strdup(user);
 294         aconf->host = rb_strdup(host);
 295         aconf->info.oper = operhash_add(get_oper_name(source_p));
 296
 297         /* Look for an oper reason */
 298         if((oper_reason = strchr(reason, '|')) != NULL)
 299         {
 300                 *oper_reason = '\0';
 301                 oper_reason++;
 302
 303                 if(!EmptyString(oper_reason))
 304                         aconf->spasswd = rb_strdup(oper_reason);
 305         }
 306         aconf->passwd = rb_strdup(reason);
 307
 308         if(tkline_time > 0)
 309                 apply_tkline(source_p, aconf, reason, oper_reason, tkline_time);
 310         else
 311                 apply_kline(source_p, aconf, reason, oper_reason);
 312
 313         if(ConfigFileEntry.kline_delay)
 314         {
 315                 if(kline_queued == 0)
 316                 {
 317                         rb_event_addonce("check_klines", check_klines_event, NULL,
 318                                          ConfigFileEntry.kline_delay);
 319                         kline_queued = 1;
 320                 }
 321         }
 322         else
 323                 check_klines();
 324
 325         return;
 326 }
 327
 328 /* mo_unkline()
 329  *
 330  *   parv[1] - kline to remove
 331  *   parv[2] - optional "ON"
 332  *   parv[3] - optional target server
 333  */
 334 static int
 335 mo_unkline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 336 {
 337         const char *user;
 338         char *host;
 339         char splat[] = "*";
 340         char *h = LOCAL_COPY(parv[1]);
 341         struct ConfItem *aconf;
 342         int propagated = 1;
 343
 344         if(!IsOperUnkline(source_p))
 345         {
 346                 sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "unkline");
 347                 return 0;
 348         }
 349
 350         if((host = strchr(h, '@')) || *h == '*' || strchr(h, '.') || strchr(h, ':'))
 351         {
 352                 /* Explicit user@host mask given */
 353
 354                 if(host)        /* Found user@host */
 355                 {
 356                         *host++ = '\0';
 357
 358                         /* check for @host */
 359                         if(*h)
 360                                 user = h;
 361                         else
 362                                 user = splat;
 363
 364                         /* check for user@ */
 365                         if(!*host)
 366                                 host = splat;
 367                 }
 368                 else
 369                 {
 370                         user = splat;   /* no @ found, assume its *@somehost */
 371                         host = h;
 372                 }
 373         }
 374         else
 375         {
 376                 sendto_one_notice(source_p, ":Invalid parameters");
 377                 return 0;
 378         }
 379
 380         /* possible remote kline.. */
 381         if((parc > 3) && (irccmp(parv[2], "ON") == 0))
 382         {
 383                 if(!IsOperRemoteBan(source_p))
 384                 {
 385                         sendto_one(source_p, form_str(ERR_NOPRIVS),
 386                                    me.name, source_p->name, "remoteban");
 387                         return 0;
 388                 }
 389
 390                 propagate_generic(source_p, "UNKLINE", parv[3], CAP_UNKLN, "%s %s", user, host);
 391
 392                 if(match(parv[3], me.name) == 0)
 393                         return 0;
 394
 395                 propagated = 0;
 396         }
 397
 398         aconf = find_exact_conf_by_address(host, CONF_KILL, user);
 399
 400         /* No clustering for removing a propagated kline */
 401         if(propagated && (aconf == NULL || !aconf->lifetime) &&
 402                         rb_dlink_list_length(&cluster_conf_list) > 0)
 403                 cluster_generic(source_p, "UNKLINE", SHARED_UNKLINE, CAP_UNKLN,
 404                                 "%s %s", user, host);
 405
 406         if(aconf == NULL)
 407         {
 408                 sendto_one_notice(source_p, ":No K-Line for %s@%s", user, host);
 409                 return 0;
 410         }
 411
 412         if(aconf->lifetime)
 413         {
 414                 if(propagated)
 415                         remove_prop_kline(source_p, aconf);
 416                 else
 417                         sendto_one_notice(source_p, ":Cannot remove global K-Line %s@%s on specific servers", user, host);
 418                 return 0;
 419         }
 420
 421         if(remove_temp_kline(source_p, aconf))
 422                 return 0;
 423
 424         remove_permkline_match(source_p, aconf);
 425
 426         return 0;
 427 }
 428
 429 /* ms_unkline()
 430  *
 431  *   parv[1] - target server
 432  *   parv[2] - user to unkline
 433  *   parv[3] - host to unkline
 434  */
 435 static int
 436 ms_unkline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 437 {
 438         /* parv[0]  parv[1]        parv[2]  parv[3]
 439          * oper     target server  user     host    */
 440         propagate_generic(source_p, "UNKLINE", parv[1], CAP_UNKLN, "%s %s", parv[2], parv[3]);
 441
 442         if(!match(parv[1], me.name))
 443                 return 0;
 444
 445         if(!IsPerson(source_p))
 446                 return 0;
 447
 448         handle_remote_unkline(source_p, parv[2], parv[3]);
 449         return 0;
 450 }
 451
 452 static int
 453 me_unkline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 454 {
 455         /* user host */
 456         if(!IsPerson(source_p))
 457                 return 0;
 458
 459         handle_remote_unkline(source_p, parv[1], parv[2]);
 460         return 0;
 461 }
 462
 463 static void
 464 handle_remote_unkline(struct Client *source_p, const char *user, const char *host)
 465 {
 466         struct ConfItem *aconf;
 467
 468         if(!find_shared_conf(source_p->username, source_p->host,
 469                              source_p->servptr->name, SHARED_UNKLINE))
 470                 return;
 471
 472         aconf = find_exact_conf_by_address(host, CONF_KILL, user);
 473         if(aconf == NULL)
 474         {
 475                 sendto_one_notice(source_p, ":No K-Line for %s@%s", user, host);
 476                 return;
 477         }
 478         if(aconf->lifetime)
 479         {
 480                 sendto_one_notice(source_p, ":Cannot remove global K-Line %s@%s on specific servers", user, host);
 481                 return;
 482         }
 483
 484         if(remove_temp_kline(source_p, aconf))
 485                 return;
 486
 487         remove_permkline_match(source_p, aconf);
 488 }
 489
 490 /* apply_kline()
 491  *
 492  * inputs       -
 493  * output       - NONE
 494  * side effects - kline as given, is added to the hashtable
 495  *                and conf file
 496  */
 497 static void
 498 apply_kline(struct Client *source_p, struct ConfItem *aconf,
 499             const char *reason, const char *oper_reason)
 500 {
 501         add_conf_by_address(aconf->host, CONF_KILL, aconf->user, NULL, aconf);
 502         bandb_add(BANDB_KLINE, source_p, aconf->user, aconf->host,
 503                   reason, EmptyString(oper_reason) ? NULL : oper_reason, 0);
 504
 505         /* no oper reason.. */
 506         if(EmptyString(oper_reason))
 507         {
 508                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 509                                        "%s added K-Line for [%s@%s] [%s]",
 510                                        get_oper_name(source_p), aconf->user, aconf->host, reason);
 511                 ilog(L_KLINE, "K %s 0 %s %s %s",
 512                      get_oper_name(source_p), aconf->user, aconf->host, reason);
 513         }
 514         else
 515         {
 516                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 517                                        "%s added K-Line for [%s@%s] [%s|%s]",
 518                                        get_oper_name(source_p), aconf->user, aconf->host,
 519                                        reason, oper_reason);
 520                 ilog(L_KLINE, "K %s 0 %s %s %s|%s",
 521                      get_oper_name(source_p), aconf->user, aconf->host, reason, oper_reason);
 522         }
 523
 524         sendto_one_notice(source_p, ":Added K-Line [%s@%s]",
 525                           aconf->user, aconf->host);
 526 }
 527
 528 /* apply_tkline()
 529  *
 530  * inputs       -
 531  * output       - NONE
 532  * side effects - tkline as given is placed
 533  */
 534 static void
 535 apply_tkline(struct Client *source_p, struct ConfItem *aconf,
 536              const char *reason, const char *oper_reason, int tkline_time)
 537 {
 538         aconf->hold = rb_current_time() + tkline_time;
 539         add_temp_kline(aconf);
 540
 541         /* no oper reason.. */
 542         if(EmptyString(oper_reason))
 543         {
 544                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 545                                        "%s added temporary %d min. K-Line for [%s@%s] [%s]",
 546                                        get_oper_name(source_p), tkline_time / 60,
 547                                        aconf->user, aconf->host, reason);
 548                 ilog(L_KLINE, "K %s %d %s %s %s",
 549                      get_oper_name(source_p), tkline_time / 60, aconf->user, aconf->host, reason);
 550         }
 551         else
 552         {
 553                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 554                                        "%s added temporary %d min. K-Line for [%s@%s] [%s|%s]",
 555                                        get_oper_name(source_p), tkline_time / 60,
 556                                        aconf->user, aconf->host, reason, oper_reason);
 557                 ilog(L_KLINE, "K %s %d %s %s %s|%s",
 558                      get_oper_name(source_p), tkline_time / 60,
 559                      aconf->user, aconf->host, reason, oper_reason);
 560         }
 561
 562         sendto_one_notice(source_p, ":Added temporary %d min. K-Line [%s@%s]",
 563                           tkline_time / 60, aconf->user, aconf->host);
 564 }
 565
 566 static void
 567 apply_prop_kline(struct Client *source_p, struct ConfItem *aconf,
 568              const char *reason, const char *oper_reason, int tkline_time)
 569 {
 570         rb_dlink_node *ptr;
 571         struct ConfItem *oldconf;
 572
 573         aconf->flags |= CONF_FLAGS_MYOPER | CONF_FLAGS_TEMPORARY;
 574         aconf->hold = rb_current_time() + tkline_time;
 575         aconf->lifetime = aconf->hold;
 576
 577         ptr = find_prop_ban(aconf->status, aconf->user, aconf->host);
 578         if(ptr != NULL)
 579         {
 580                 oldconf = ptr->data;
 581                 /* Remember at least as long as the old one. */
 582                 if(oldconf->lifetime > aconf->lifetime)
 583                         aconf->lifetime = oldconf->lifetime;
 584                 /* Force creation time to increase. */
 585                 if(oldconf->created >= aconf->created)
 586                         aconf->created = oldconf->created + 1;
 587                 /* Leave at least one second of validity. */
 588                 if(aconf->hold <= aconf->created)
 589                         aconf->hold = aconf->created + 1;
 590                 if(aconf->lifetime < aconf->hold)
 591                         aconf->lifetime = aconf->hold;
 592                 /* Tell deactivate_conf() to destroy it. */
 593                 oldconf->lifetime = rb_current_time();
 594                 deactivate_conf(oldconf, ptr);
 595         }
 596
 597         rb_dlinkAddAlloc(aconf, &prop_bans);
 598         add_conf_by_address(aconf->host, CONF_KILL, aconf->user, NULL, aconf);
 599
 600         /* no oper reason.. */
 601         if(EmptyString(oper_reason))
 602         {
 603                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 604                                        "%s added global %d min. K-Line for [%s@%s] [%s]",
 605                                        get_oper_name(source_p), tkline_time / 60,
 606                                        aconf->user, aconf->host, reason);
 607                 ilog(L_KLINE, "K %s %d %s %s %s",
 608                      get_oper_name(source_p), tkline_time / 60, aconf->user, aconf->host, reason);
 609         }
 610         else
 611         {
 612                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 613                                        "%s added global %d min. K-Line for [%s@%s] [%s|%s]",
 614                                        get_oper_name(source_p), tkline_time / 60,
 615                                        aconf->user, aconf->host, reason, oper_reason);
 616                 ilog(L_KLINE, "K %s %d %s %s %s|%s",
 617                      get_oper_name(source_p), tkline_time / 60,
 618                      aconf->user, aconf->host, reason, oper_reason);
 619         }
 620
 621         sendto_one_notice(source_p, ":Added global %d min. K-Line [%s@%s]",
 622                           tkline_time / 60, aconf->user, aconf->host);
 623
 624         sendto_server(NULL, NULL, CAP_BAN|CAP_TS6, NOCAPS,
 625                         ":%s BAN K %s %s %lu %d %d * :%s%s%s",
 626                         source_p->id, aconf->user, aconf->host,
 627                         (unsigned long)aconf->created,
 628                         (int)(aconf->hold - aconf->created),
 629                         (int)(aconf->lifetime - aconf->created),
 630                         reason,
 631                         oper_reason ? "|" : "",
 632                         oper_reason ? oper_reason : "");
 633 }
 634
 635 /* find_user_host()
 636  *
 637  * inputs       - client placing kline, user@host, user buffer, host buffer
 638  * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
 639  * side effects -
 640  */
 641 static int
 642 find_user_host(struct Client *source_p, const char *userhost, char *luser, char *lhost)
 643 {
 644         char *hostp;
 645
 646         hostp = strchr(userhost, '@');
 647
 648         if(hostp != NULL)       /* I'm a little user@host */
 649         {
 650                 *(hostp++) = '\0';      /* short and squat */
 651                 if(*userhost)
 652                         rb_strlcpy(luser, userhost, USERLEN + 1);       /* here is my user */
 653                 else
 654                         strcpy(luser, "*");
 655                 if(*hostp)
 656                         rb_strlcpy(lhost, hostp, HOSTLEN + 1);  /* here is my host */
 657                 else
 658                         strcpy(lhost, "*");
 659         }
 660         else
 661         {
 662                 /* no '@', no '.', so its not a user@host or host, therefore
 663                  * its a nick, which support was removed for.
 664                  */
 665                 if(strchr(userhost, '.') == NULL && strchr(userhost, ':') == NULL)
 666                 {
 667                         sendto_one_notice(source_p, ":K-Line must be a user@host or host");
 668                         return 0;
 669                 }
 670
 671                 luser[0] = '*'; /* no @ found, assume its *@somehost */
 672                 luser[1] = '\0';
 673                 rb_strlcpy(lhost, userhost, HOSTLEN + 1);
 674         }
 675
 676         return 1;
 677 }
 678
 679 /* valid_user_host()
 680  *
 681  * inputs       - user buffer, host buffer
 682  * output       - 0 if invalid, 1 if valid
 683  * side effects -
 684  */
 685 static int
 686 valid_user_host(struct Client *source_p, const char *luser, const char *lhost)
 687 {
 688         /* # is invalid, as are '!' (n!u@h kline) and '@' (u@@h kline) */
 689         if(strchr(lhost, '#') || strchr(luser, '#') || strchr(luser, '!') || strchr(lhost, '@'))
 690         {
 691                 sendto_one_notice(source_p, ":Invalid K-Line");
 692                 return 0;
 693         }
 694
 695         return 1;
 696 }
 697
 698 /* valid_wild_card()
 699  *
 700  * input        - user buffer, host buffer
 701  * output       - 0 if invalid, 1 if valid
 702  * side effects -
 703  */
 704 static int
 705 valid_wild_card(struct Client *source_p, const char *luser, const char *lhost)
 706 {
 707         const char *p;
 708         char tmpch;
 709         int nonwild = 0;
 710         int bitlen;
 711
 712         /* user has no wildcards, always accept -- jilles */
 713         if(!strchr(luser, '?') && !strchr(luser, '*'))
 714                 return 1;
 715
 716         /* check there are enough non wildcard chars */
 717         p = luser;
 718         while((tmpch = *p++))
 719         {
 720                 if(!IsKWildChar(tmpch))
 721                 {
 722                         /* found enough chars, return */
 723                         if(++nonwild >= ConfigFileEntry.min_nonwildcard)
 724                                 return 1;
 725                 }
 726         }
 727
 728         /* try host, as user didnt contain enough */
 729         /* special case for cidr masks -- jilles */
 730         if((p = strrchr(lhost, '/')) != NULL && IsDigit(p[1]))
 731         {
 732                 bitlen = atoi(p + 1);
 733                 /* much like non-cidr for ipv6, rather arbitrary for ipv4 */
 734                 if(bitlen > 0
 735                    && bitlen >=
 736                    (strchr(lhost, ':') ? 4 * (ConfigFileEntry.min_nonwildcard - nonwild) : 6 -
 737                     2 * nonwild))
 738                         return 1;
 739         }
 740         else
 741         {
 742                 p = lhost;
 743                 while((tmpch = *p++))
 744                 {
 745                         if(!IsKWildChar(tmpch))
 746                                 if(++nonwild >= ConfigFileEntry.min_nonwildcard)
 747                                         return 1;
 748                 }
 749         }
 750
 751         sendto_one_notice(source_p,
 752                           ":Please include at least %d non-wildcard "
 753                           "characters with the user@host", ConfigFileEntry.min_nonwildcard);
 754         return 0;
 755 }
 756
 757 /*
 758  * valid_comment
 759  * inputs       - pointer to client
 760  *              - pointer to comment
 761  * output       - 0 if no valid comment, 1 if valid
 762  * side effects - NONE
 763  */
 764 static int
 765 valid_comment(struct Client *source_p, char *comment)
 766 {
 767         if(strchr(comment, '"'))
 768         {
 769                 sendto_one_notice(source_p, ":Invalid character '\"' in comment");
 770                 return 0;
 771         }
 772
 773         if(strlen(comment) > BANREASONLEN)
 774                 comment[BANREASONLEN] = '\0';
 775
 776         return 1;
 777 }
 778
 779 /* already_placed_kline()
 780  *
 781  * inputs       - source to notify, user@host to check, tkline time
 782  * outputs      - 1 if a perm kline or a tkline when a tkline is being
 783  *                set exists, else 0
 784  * side effects - notifies source_p kline exists
 785  */
 786 /* Note: This currently works if the new K-line is a special case of an
 787  *       existing K-line, but not the other way round. To do that we would
 788  *       have to walk the hash and check every existing K-line. -A1kmm.
 789  */
 790 static int
 791 already_placed_kline(struct Client *source_p, const char *luser, const char *lhost, int tkline)
 792 {
 793         const char *reason, *p;
 794         struct rb_sockaddr_storage iphost, *piphost;
 795         struct ConfItem *aconf;
 796         int t, bits;
 797
 798         aconf = find_exact_conf_by_address(lhost, CONF_KILL, luser);
 799         if(aconf == NULL && ConfigFileEntry.non_redundant_klines)
 800         {
 801                 bits = 0;
 802                 if((t = parse_netmask(lhost, (struct sockaddr *) &iphost, &bits)) != HM_HOST)
 803                 {
 804 #ifdef RB_IPV6
 805                         if(t == HM_IPV6)
 806                                 t = AF_INET6;
 807                         else
 808 #endif
 809                                 t = AF_INET;
 810
 811                         piphost = &iphost;
 812                 }
 813                 else
 814                         piphost = NULL;
 815
 816                 aconf = find_conf_by_address(lhost, NULL, NULL, (struct sockaddr *) piphost,
 817                                              CONF_KILL, t, luser, NULL);
 818                 if(aconf != NULL)
 819                 {
 820                         /* The above was really a lookup of a single IP,
 821                          * so check if the new kline is wider than the
 822                          * existing one.
 823                          * -- jilles
 824                          */
 825                         p = strchr(aconf->host, '/');
 826                         if(bits > 0 && (p == NULL || bits < atoi(p + 1)))
 827                                 aconf = NULL;
 828                 }
 829         }
 830         if(aconf != NULL)
 831         {
 832                 /* setting a tkline, or existing one is perm */
 833                 if(tkline || ((aconf->flags & CONF_FLAGS_TEMPORARY) == 0))
 834                 {
 835                         reason = aconf->passwd ? aconf->passwd : "<No Reason>";
 836
 837                         sendto_one_notice(source_p,
 838                                           ":[%s@%s] already K-Lined by [%s@%s] - %s",
 839                                           luser, lhost, aconf->user, aconf->host, reason);
 840                         return 1;
 841                 }
 842         }
 843
 844         return 0;
 845 }
 846
 847 /* remove_permkline_match()
 848  *
 849  * hunts for a permanent kline, and removes it.
 850  */
 851 static void
 852 remove_permkline_match(struct Client *source_p, struct ConfItem *aconf)
 853 {
 854         sendto_one_notice(source_p, ":K-Line for [%s@%s] is removed", aconf->user, aconf->host);
 855
 856         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 857                                "%s has removed the K-Line for: [%s@%s]",
 858                                get_oper_name(source_p), aconf->user, aconf->host);
 859
 860         ilog(L_KLINE, "UK %s %s %s", get_oper_name(source_p), aconf->user, aconf->host);
 861
 862         remove_reject_mask(aconf->user, aconf->host);
 863         bandb_del(BANDB_KLINE, aconf->user, aconf->host);
 864         delete_one_address_conf(aconf->host, aconf);
 865
 866         return;
 867 }
 868
 869 /* remove_temp_kline()
 870  *
 871  * inputs       - username, hostname to unkline
 872  * outputs      -
 873  * side effects - tries to unkline anything that matches
 874  */
 875 static int
 876 remove_temp_kline(struct Client *source_p, struct ConfItem *aconf)
 877 {
 878         rb_dlink_node *ptr;
 879         int i;
 880
 881         for(i = 0; i < LAST_TEMP_TYPE; i++)
 882         {
 883                 RB_DLINK_FOREACH(ptr, temp_klines[i].head)
 884                 {
 885                         if(aconf == ptr->data)
 886                         {
 887                                 sendto_one_notice(source_p,
 888                                                   ":Un-klined [%s@%s] from temporary k-lines",
 889                                                   aconf->user, aconf->host);
 890                                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 891                                                        "%s has removed the temporary K-Line for: [%s@%s]",
 892                                                        get_oper_name(source_p), aconf->user,
 893                                                        aconf->host);
 894
 895                                 ilog(L_KLINE, "UK %s %s %s",
 896                                      get_oper_name(source_p), aconf->user, aconf->host);
 897                                 rb_dlinkDestroy(ptr, &temp_klines[i]);
 898                                 remove_reject_mask(aconf->user, aconf->host);
 899                                 delete_one_address_conf(aconf->host, aconf);
 900                                 return YES;
 901                         }
 902                 }
 903         }
 904
 905         return NO;
 906 }
 907
 908 static void
 909 remove_prop_kline(struct Client *source_p, struct ConfItem *aconf)
 910 {
 911         rb_dlink_node *ptr;
 912
 913         ptr = rb_dlinkFind(aconf, &prop_bans);
 914         if (!ptr)
 915                 return;
 916         sendto_one_notice(source_p,
 917                           ":Un-klined [%s@%s] from global k-lines",
 918                           aconf->user, aconf->host);
 919         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 920                                "%s has removed the global K-Line for: [%s@%s]",
 921                                get_oper_name(source_p), aconf->user,
 922                                aconf->host);
 923
 924         ilog(L_KLINE, "UK %s %s %s",
 925              get_oper_name(source_p), aconf->user, aconf->host);
 926         if(aconf->created < rb_current_time())
 927                 aconf->created = rb_current_time();
 928         else
 929                 aconf->created++;
 930         aconf->hold = aconf->created;
 931         operhash_delete(aconf->info.oper);
 932         aconf->info.oper = operhash_add(get_oper_name(source_p));
 933         aconf->flags |= CONF_FLAGS_MYOPER | CONF_FLAGS_TEMPORARY;
 934         sendto_server(NULL, NULL, CAP_BAN|CAP_TS6, NOCAPS,
 935                         ":%s BAN K %s %s %lu %d %d * :*",
 936                         source_p->id, aconf->user, aconf->host,
 937                         (unsigned long)aconf->created,
 938                         0,
 939                         (int)(aconf->lifetime - aconf->created));
 940         remove_reject_mask(aconf->user, aconf->host);
 941         deactivate_conf(aconf, ptr);
 942 }