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