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: m_kline.c 3466 2007-05-19 23:36:51Z jilles $
  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
  47 static int mo_kline(struct Client *, struct Client *, int, const char **);
  48 static int ms_kline(struct Client *, struct Client *, int, const char **);
  49 static int me_kline(struct Client *, struct Client *, int, const char **);
  50 static int mo_unkline(struct Client *, struct Client *, int, const char **);
  51 static int ms_unkline(struct Client *, struct Client *, int, const char **);
  52 static int me_unkline(struct Client *, struct Client *, int, const char **);
  53
  54 struct Message kline_msgtab = {
  55         "KLINE", 0, 0, 0, MFLG_SLOW,
  56         {mg_unreg, mg_not_oper, {ms_kline, 5}, {ms_kline, 5}, {me_kline, 5}, {mo_kline, 3}}
  57 };
  58
  59 struct Message unkline_msgtab = {
  60         "UNKLINE", 0, 0, 0, MFLG_SLOW,
  61         {mg_unreg, mg_not_oper, {ms_unkline, 4}, {ms_unkline, 4}, {me_unkline, 3}, {mo_unkline, 2}}
  62 };
  63
  64 mapi_clist_av1 kline_clist[] = { &kline_msgtab, &unkline_msgtab, NULL };
  65 DECLARE_MODULE_AV1(kline, NULL, NULL, kline_clist, NULL, NULL, "$Revision: 3466 $");
  66
  67 /* Local function prototypes */
  68 static int find_user_host(struct Client *source_p, const char *userhost, char *user, char *host);
  69 static int valid_comment(struct Client *source_p, char *comment);
  70 static int valid_user_host(struct Client *source_p, const char *user, const char *host);
  71 static int valid_wild_card(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, const char *current_date);
  77 static void apply_tkline(struct Client *source_p, struct ConfItem *aconf,
  78                          const char *, const char *, const char *, int);
  79 static int already_placed_kline(struct Client *, const char *, const char *, int);
  80
  81 static void handle_remote_unkline(struct Client *source_p,
  82                         const char *user, const char *host);
  83 static void remove_permkline_match(struct Client *, struct ConfItem *);
  84 static int flush_write(struct Client *, FILE *, const char *, const char *);
  85 static int remove_temp_kline(struct Client *, struct ConfItem *);
  86
  87 /* mo_kline()
  88  *
  89  *   parv[1] - temp time or user@host
  90  *   parv[2] - user@host, "ON", or reason
  91  *   parv[3] - "ON", reason, or server to target
  92  *   parv[4] - server to target, or reason
  93  *   parv[5] - reason
  94  */
  95 static int
  96 mo_kline(struct Client *client_p, struct Client *source_p,
  97          int parc, const char **parv)
  98 {
  99         char def[] = "No Reason";
 100         char user[USERLEN + 2];
 101         char host[HOSTLEN + 2];
 102         char buffer[IRCD_BUFSIZE];
 103         char *reason = def;
 104         char *oper_reason;
 105         const char *current_date;
 106         const char *target_server = NULL;
 107         struct ConfItem *aconf;
 108         int tkline_time = 0;
 109         int loc = 1;
 110
 111         if(!IsOperK(source_p))
 112         {
 113                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 114                            me.name, source_p->name, "kline");
 115                 return 0;
 116         }
 117
 118         if((tkline_time = valid_temp_time(parv[loc])) >= 0)
 119                 loc++;
 120         /* we just set tkline_time to -1! */
 121         else
 122                 tkline_time = 0;
 123
 124         if(find_user_host(source_p, parv[loc], user, host) == 0)
 125                 return 0;
 126
 127         loc++;
 128
 129         if(parc >= loc+2 && !irccmp(parv[loc], "ON"))
 130         {
 131                 if(!IsOperRemoteBan(source_p))
 132                 {
 133                         sendto_one(source_p, form_str(ERR_NOPRIVS),
 134                                 me.name, source_p->name, "remoteban");
 135                         return 0;
 136                 }
 137
 138                 target_server = parv[loc+1];
 139                 loc += 2;
 140         }
 141
 142         if(parc <= loc || EmptyString(parv[loc]))
 143         {
 144                 sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
 145                            me.name, source_p->name, "KLINE");
 146                 return 0;
 147         }
 148
 149         reason = LOCAL_COPY(parv[loc]);
 150
 151         if(target_server != NULL)
 152         {
 153                 propagate_generic(source_p, "KLINE", target_server, CAP_KLN,
 154                                 "%d %s %s :%s",
 155                                 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         /* if we have cluster servers, send it to them.. */
 162         else if(rb_dlink_list_length(&cluster_conf_list) > 0)
 163                 cluster_generic(source_p, "KLINE",
 164                                 (tkline_time > 0) ? SHARED_TKLINE : SHARED_PKLINE, CAP_KLN,
 165                                 "%lu %s %s :%s",
 166                                 tkline_time, user, host, reason);
 167
 168         if(!valid_user_host(source_p, user, host) ||
 169            !valid_wild_card(source_p, user, host) ||
 170            !valid_comment(source_p, reason))
 171                 return 0;
 172
 173         if(already_placed_kline(source_p, user, host, tkline_time))
 174                 return 0;
 175
 176         rb_set_time();
 177         current_date = smalldate();
 178         aconf = make_conf();
 179         aconf->status = CONF_KILL;
 180         aconf->host = rb_strdup(host);
 181         aconf->user = rb_strdup(user);
 182         aconf->port = 0;
 183
 184         /* Look for an oper reason */
 185         if((oper_reason = strchr(reason, '|')) != NULL)
 186         {
 187                 *oper_reason = '\0';
 188                 oper_reason++;
 189
 190                 if(!EmptyString(oper_reason))
 191                         aconf->spasswd = rb_strdup(oper_reason);
 192         }
 193
 194         if(tkline_time > 0)
 195         {
 196                 rb_snprintf(buffer, sizeof(buffer),
 197                            "Temporary K-line %d min. - %s (%s)",
 198                            (int) (tkline_time / 60), reason, current_date);
 199                 aconf->passwd = rb_strdup(buffer);
 200                 apply_tkline(source_p, aconf, reason, oper_reason, current_date, tkline_time);
 201         }
 202         else
 203         {
 204                 rb_snprintf(buffer, sizeof(buffer), "%s (%s)", reason, current_date);
 205                 aconf->passwd = rb_strdup(buffer);
 206                 apply_kline(source_p, aconf, reason, oper_reason, current_date);
 207         }
 208
 209         if(ConfigFileEntry.kline_delay)
 210         {
 211                 if(kline_queued == 0)
 212                 {
 213                         rb_event_addonce("check_klines", check_klines_event, NULL,
 214                                      ConfigFileEntry.kline_delay);
 215                         kline_queued = 1;
 216                 }
 217         }
 218         else
 219                 check_klines();
 220
 221         return 0;
 222 }
 223
 224 /* ms_kline()
 225  *
 226  *   parv[1] - server targeted at
 227  *   parv[2] - tkline time (0 if perm)
 228  *   parv[3] - user
 229  *   parv[4] - host
 230  *   parv[5] - reason
 231  */
 232 static int
 233 ms_kline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 234 {
 235         int tkline_time = atoi(parv[2]);
 236
 237         /* 1.5-3 and earlier contains a bug that allows remote klines to be
 238          * sent with an empty reason field.  This is a protocol violation,
 239          * but its not worth dropping the link over.. --anfl
 240          */
 241         if(parc < 6 || EmptyString(parv[5]))
 242                 return 0;
 243
 244         propagate_generic(source_p, "KLINE", parv[1], CAP_KLN,
 245                         "%d %s %s :%s",
 246                         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 buffer[BUFSIZE];
 274         const char *current_date;
 275         char *reason = LOCAL_COPY(kreason);
 276         struct ConfItem *aconf = NULL;
 277         char *oper_reason;
 278
 279         if(!find_shared_conf(source_p->username, source_p->host,
 280                                 source_p->servptr->name,
 281                                 (tkline_time > 0) ? SHARED_TKLINE : SHARED_PKLINE))
 282                 return;
 283
 284         if(!valid_user_host(source_p, user, host) ||
 285            !valid_wild_card(source_p, user, host) ||
 286            !valid_comment(source_p, reason))
 287                 return;
 288
 289         if(already_placed_kline(source_p, user, host, tkline_time))
 290                 return;
 291
 292         aconf = make_conf();
 293
 294         aconf->status = CONF_KILL;
 295         aconf->user = rb_strdup(user);
 296         aconf->host = rb_strdup(host);
 297
 298         /* Look for an oper reason */
 299         if((oper_reason = strchr(reason, '|')) != NULL)
 300         {
 301                 *oper_reason = '\0';
 302                 oper_reason++;
 303
 304                 if(!EmptyString(oper_reason))
 305                         aconf->spasswd = rb_strdup(oper_reason);
 306         }
 307
 308         current_date = smalldate();
 309
 310         if(tkline_time > 0)
 311         {
 312                 rb_snprintf(buffer, sizeof(buffer),
 313                            "Temporary K-line %d min. - %s (%s)",
 314                            (int) (tkline_time / 60), reason, current_date);
 315                 aconf->passwd = rb_strdup(buffer);
 316                 apply_tkline(source_p, aconf, reason, oper_reason, current_date, tkline_time);
 317         }
 318         else
 319         {
 320                 rb_snprintf(buffer, sizeof(buffer), "%s (%s)", reason, current_date);
 321                 aconf->passwd = rb_strdup(buffer);
 322                 apply_kline(source_p, aconf, reason, oper_reason, current_date);
 323         }
 324
 325         if(ConfigFileEntry.kline_delay)
 326         {
 327                 if(kline_queued == 0)
 328                 {
 329                         rb_event_addonce("check_klines", check_klines_event, NULL,
 330                                      ConfigFileEntry.kline_delay);
 331                         kline_queued = 1;
 332                 }
 333         }
 334         else
 335                 check_klines();
 336
 337         return;
 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 int
 347 mo_unkline(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
 355         if(!IsOperUnkline(source_p))
 356         {
 357                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 358                            me.name, source_p->name, "unkline");
 359                 return 0;
 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 0;
 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 0;
 400                 }
 401
 402                 propagate_generic(source_p, "UNKLINE", parv[3], CAP_UNKLN,
 403                                 "%s %s", user, host);
 404
 405                 if(match(parv[3], me.name) == 0)
 406                         return 0;
 407         }
 408         else if(rb_dlink_list_length(&cluster_conf_list) > 0)
 409                 cluster_generic(source_p, "UNKLINE", SHARED_UNKLINE, CAP_UNKLN,
 410                                 "%s %s", user, host);
 411
 412         aconf = find_exact_conf_by_address(host, CONF_KILL, user);
 413         if(aconf == NULL)
 414         {
 415                 sendto_one_notice(source_p, ":No K-Line for %s@%s", user, host);
 416                 return 0;
 417         }
 418
 419         if(remove_temp_kline(source_p, aconf))
 420                 return 0;
 421
 422         remove_permkline_match(source_p, aconf);
 423
 424         return 0;
 425 }
 426
 427 /* ms_unkline()
 428  *
 429  *   parv[1] - target server
 430  *   parv[2] - user to unkline
 431  *   parv[3] - host to unkline
 432  */
 433 static int
 434 ms_unkline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 435 {
 436         /* parv[0]  parv[1]        parv[2]  parv[3]
 437          * oper     target server  user     host    */
 438         propagate_generic(source_p, "UNKLINE", parv[1], CAP_UNKLN,
 439                         "%s %s", parv[2], parv[3]);
 440
 441         if(!match(parv[1], me.name))
 442                 return 0;
 443
 444         if(!IsPerson(source_p))
 445                 return 0;
 446
 447         handle_remote_unkline(source_p, parv[2], parv[3]);
 448         return 0;
 449 }
 450
 451 static int
 452 me_unkline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 453 {
 454         /* user host */
 455         if(!IsPerson(source_p))
 456                 return 0;
 457
 458         handle_remote_unkline(source_p, parv[1], parv[2]);
 459         return 0;
 460 }
 461
 462 static void
 463 handle_remote_unkline(struct Client *source_p, const char *user, const char *host)
 464 {
 465         struct ConfItem *aconf;
 466
 467         if(!find_shared_conf(source_p->username, source_p->host,
 468                                 source_p->servptr->name, SHARED_UNKLINE))
 469                 return;
 470
 471         aconf = find_exact_conf_by_address(host, CONF_KILL, user);
 472         if(aconf == NULL)
 473         {
 474                 sendto_one_notice(source_p, ":No K-Line for %s@%s", user, host);
 475                 return;
 476         }
 477
 478         if(remove_temp_kline(source_p, aconf))
 479                 return;
 480
 481         remove_permkline_match(source_p, aconf);
 482 }
 483
 484 /* apply_kline()
 485  *
 486  * inputs       -
 487  * output       - NONE
 488  * side effects - kline as given, is added to the hashtable
 489  *                and conf file
 490  */
 491 static void
 492 apply_kline(struct Client *source_p, struct ConfItem *aconf,
 493             const char *reason, const char *oper_reason, const char *current_date)
 494 {
 495         add_conf_by_address(aconf->host, CONF_KILL, aconf->user, NULL, aconf);
 496         write_confitem(KLINE_TYPE, source_p, aconf->user, aconf->host,
 497                        reason, oper_reason, current_date, 0);
 498 }
 499
 500 /* apply_tkline()
 501  *
 502  * inputs       -
 503  * output       - NONE
 504  * side effects - tkline as given is placed
 505  */
 506 static void
 507 apply_tkline(struct Client *source_p, struct ConfItem *aconf,
 508              const char *reason, const char *oper_reason, const char *current_date, int tkline_time)
 509 {
 510         aconf->hold = rb_current_time() + tkline_time;
 511         add_temp_kline(aconf);
 512
 513         /* no oper reason.. */
 514         if(EmptyString(oper_reason))
 515         {
 516                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 517                                      "%s added temporary %d min. K-Line for [%s@%s] [%s]",
 518                                      get_oper_name(source_p), tkline_time / 60,
 519                                      aconf->user, aconf->host, reason);
 520                 ilog(L_KLINE, "K %s %d %s %s %s",
 521                         get_oper_name(source_p), tkline_time / 60,
 522                         aconf->user, aconf->host, reason);
 523         }
 524         else
 525         {
 526                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 527                                      "%s added temporary %d min. K-Line for [%s@%s] [%s|%s]",
 528                                      get_oper_name(source_p), tkline_time / 60,
 529                                      aconf->user, aconf->host, reason, oper_reason);
 530                 ilog(L_KLINE, "K %s %d %s %s %s|%s",
 531                         get_oper_name(source_p), tkline_time / 60,
 532                         aconf->user, aconf->host, reason, oper_reason);
 533         }
 534
 535         sendto_one_notice(source_p, ":Added temporary %d min. K-Line [%s@%s]",
 536                           tkline_time / 60, aconf->user, aconf->host);
 537 }
 538
 539 /* find_user_host()
 540  *
 541  * inputs       - client placing kline, user@host, user buffer, host buffer
 542  * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
 543  * side effects -
 544  */
 545 static int
 546 find_user_host(struct Client *source_p, const char *userhost, char *luser, char *lhost)
 547 {
 548         char *hostp;
 549
 550         hostp = strchr(userhost, '@');
 551
 552         if(hostp != NULL)       /* I'm a little user@host */
 553         {
 554                 *(hostp++) = '\0';      /* short and squat */
 555                 if(*userhost)
 556                         rb_strlcpy(luser, userhost, USERLEN + 1);       /* here is my user */
 557                 else
 558                         strcpy(luser, "*");
 559                 if(*hostp)
 560                         rb_strlcpy(lhost, hostp, HOSTLEN + 1);  /* here is my host */
 561                 else
 562                         strcpy(lhost, "*");
 563                 }
 564         else
 565         {
 566                 /* no '@', no '.', so its not a user@host or host, therefore
 567                  * its a nick, which support was removed for.
 568                  */
 569                 if(strchr(userhost, '.') == NULL && strchr(userhost, ':') == NULL)
 570                 {
 571                         sendto_one_notice(source_p, ":K-Line must be a user@host or host");
 572                         return 0;
 573                 }
 574
 575                 luser[0] = '*'; /* no @ found, assume its *@somehost */
 576                 luser[1] = '\0';
 577                 rb_strlcpy(lhost, userhost, HOSTLEN + 1);
 578         }
 579
 580         return 1;
 581 }
 582
 583 /* valid_user_host()
 584  *
 585  * inputs       - user buffer, host buffer
 586  * output       - 0 if invalid, 1 if valid
 587  * side effects -
 588  */
 589 static int
 590 valid_user_host(struct Client *source_p, const char *luser, const char *lhost)
 591 {
 592         /* # is invalid, as are '!' (n!u@h kline) and '@' (u@@h kline) */
 593         if(strchr(lhost, '#') || strchr(luser, '#') || strchr(luser, '!') ||
 594                         strchr(lhost, '@'))
 595         {
 596                 sendto_one_notice(source_p, ":Invalid K-Line");
 597                 return 0;
 598         }
 599
 600         return 1;
 601 }
 602
 603 /* valid_wild_card()
 604  *
 605  * input        - user buffer, host buffer
 606  * output       - 0 if invalid, 1 if valid
 607  * side effects -
 608  */
 609 static int
 610 valid_wild_card(struct Client *source_p, const char *luser, const char *lhost)
 611 {
 612         const char *p;
 613         char tmpch;
 614         int nonwild = 0;
 615         int bitlen;
 616
 617         /* user has no wildcards, always accept -- jilles */
 618         if (!strchr(luser, '?') && !strchr(luser, '*'))
 619                 return 1;
 620
 621         /* check there are enough non wildcard chars */
 622         p = luser;
 623         while ((tmpch = *p++))
 624         {
 625                 if(!IsKWildChar(tmpch))
 626                 {
 627                         /* found enough chars, return */
 628                         if(++nonwild >= ConfigFileEntry.min_nonwildcard)
 629                                 return 1;
 630                 }
 631         }
 632
 633         /* try host, as user didnt contain enough */
 634         /* special case for cidr masks -- jilles */
 635         if ((p = strrchr(lhost, '/')) != NULL && IsDigit(p[1]))
 636         {
 637                 bitlen = atoi(p + 1);
 638                 /* much like non-cidr for ipv6, rather arbitrary for ipv4 */
 639                 if (bitlen > 0 && bitlen >= (strchr(lhost, ':') ? 4 * (ConfigFileEntry.min_nonwildcard - nonwild) : 6 - 2 * nonwild))
 640                         return 1;
 641         }
 642         else
 643         {
 644                 p = lhost;
 645                 while ((tmpch = *p++))
 646                 {
 647                         if(!IsKWildChar(tmpch))
 648                                 if(++nonwild >= ConfigFileEntry.min_nonwildcard)
 649                                         return 1;
 650                 }
 651         }
 652
 653         sendto_one_notice(source_p,
 654                           ":Please include at least %d non-wildcard "
 655                           "characters with the user@host",
 656                           ConfigFileEntry.min_nonwildcard);
 657         return 0;
 658 }
 659
 660 /*
 661  * valid_comment
 662  * inputs       - pointer to client
 663  *              - pointer to comment
 664  * output       - 0 if no valid comment, 1 if valid
 665  * side effects - NONE
 666  */
 667 static int
 668 valid_comment(struct Client *source_p, char *comment)
 669 {
 670         if(strchr(comment, '"'))
 671         {
 672                 sendto_one_notice(source_p, ":Invalid character '\"' in comment");
 673                 return 0;
 674         }
 675
 676         if(strlen(comment) > BANREASONLEN)
 677                 comment[BANREASONLEN] = '\0';
 678
 679         return 1;
 680 }
 681
 682 /* already_placed_kline()
 683  *
 684  * inputs       - source to notify, user@host to check, tkline time
 685  * outputs      - 1 if a perm kline or a tkline when a tkline is being
 686  *                set exists, else 0
 687  * side effects - notifies source_p kline exists
 688  */
 689 /* Note: This currently works if the new K-line is a special case of an
 690  *       existing K-line, but not the other way round. To do that we would
 691  *       have to walk the hash and check every existing K-line. -A1kmm.
 692  */
 693 static int
 694 already_placed_kline(struct Client *source_p, const char *luser, const char *lhost, int tkline)
 695 {
 696         const char *reason, *p;
 697         struct rb_sockaddr_storage iphost, *piphost;
 698         struct ConfItem *aconf;
 699         int t, bits;
 700
 701         aconf = find_exact_conf_by_address(lhost, CONF_KILL, luser);
 702         if (aconf == NULL && ConfigFileEntry.non_redundant_klines)
 703         {
 704                 bits = 0;
 705                 if((t = parse_netmask(lhost, (struct sockaddr *)&iphost, &bits)) != HM_HOST)
 706                 {
 707 #ifdef RB_IPV6
 708                         if(t == HM_IPV6)
 709                                 t = AF_INET6;
 710                         else
 711 #endif
 712                                 t = AF_INET;
 713
 714                         piphost = &iphost;
 715                 }
 716                 else
 717                         piphost = NULL;
 718
 719                 aconf = find_conf_by_address(lhost, NULL, NULL, (struct sockaddr *)piphost, CONF_KILL, t, luser, NULL);
 720                 if (aconf != NULL)
 721                 {
 722                         /* The above was really a lookup of a single IP,
 723                          * so check if the new kline is wider than the
 724                          * existing one.
 725                          * -- jilles
 726                          */
 727                         p = strchr(aconf->host, '/');
 728                         if (bits > 0 && (p == NULL || bits < atoi(p + 1)))
 729                                 aconf = NULL;
 730                 }
 731         }
 732         if (aconf != NULL)
 733         {
 734                 /* setting a tkline, or existing one is perm */
 735                 if(tkline || ((aconf->flags & CONF_FLAGS_TEMPORARY) == 0))
 736                 {
 737                         reason = aconf->passwd ? aconf->passwd : "<No Reason>";
 738
 739                         sendto_one_notice(source_p,
 740                                           ":[%s@%s] already K-Lined by [%s@%s] - %s",
 741                                           luser, lhost, aconf->user,
 742                                           aconf->host, reason);
 743                         return 1;
 744                 }
 745         }
 746
 747         return 0;
 748 }
 749
 750 /* remove_permkline_match()
 751  *
 752  * hunts for a permanent kline, and removes it.
 753  */
 754 static void
 755 remove_permkline_match(struct Client *source_p, struct ConfItem *aconf)
 756 {
 757         FILE *in, *out;
 758         int pairme = 0;
 759         int error_on_write = NO;
 760         char buf[BUFSIZE];
 761         char matchbuf[BUFSIZE];
 762         char temppath[BUFSIZE];
 763         const char *filename;
 764         const char *host, *user;
 765         mode_t oldumask;
 766         int matchlen;
 767
 768         host = aconf->host;
 769         user = aconf->user;
 770
 771         rb_snprintf(temppath, sizeof(temppath),
 772                  "%s.tmp", ConfigFileEntry.klinefile);
 773
 774         filename = get_conf_name(KLINE_TYPE);
 775
 776         if((in = fopen(filename, "r")) == 0)
 777         {
 778                 sendto_one_notice(source_p, ":Cannot open %s", filename);
 779                 return;
 780         }
 781
 782         oldumask = umask(0);
 783         if((out = fopen(temppath, "w")) == 0)
 784         {
 785                 sendto_one_notice(source_p, ":Cannot open %s", temppath);
 786                 fclose(in);
 787                 umask(oldumask);
 788                 return;
 789         }
 790
 791         umask(oldumask);
 792
 793         snprintf(matchbuf, sizeof(matchbuf), "\"%s\",\"%s\"", user, host);
 794         matchlen = strlen(matchbuf);
 795
 796         while (fgets(buf, sizeof(buf), in))
 797         {
 798                 if(error_on_write)
 799                         break;
 800
 801                 if(!strncasecmp(buf, matchbuf, matchlen))
 802                 {
 803                         pairme++;
 804                         break;
 805                 }
 806                 else
 807                         error_on_write = flush_write(source_p, out, buf, temppath);
 808         }
 809
 810         /* we dropped out of the loop early because we found a match,
 811          * to drop into this somewhat faster loop as we presume we'll never
 812          * have two matching klines --anfl
 813          */
 814         if(pairme && !error_on_write)
 815         {
 816                 while(fgets(buf, sizeof(buf), in))
 817                 {
 818                         if(error_on_write)
 819                                 break;
 820
 821                         error_on_write = flush_write(source_p, out, buf, temppath);
 822                 }
 823         }
 824
 825         fclose(in);
 826         if (fclose(out))
 827                 error_on_write = YES;
 828
 829         /* The result of the rename should be checked too... oh well */
 830         /* If there was an error on a write above, then its been reported
 831          * and I am not going to trash the original kline /conf file
 832          */
 833         if(error_on_write)
 834         {
 835                 sendto_one_notice(source_p, ":Couldn't write temp kline file, aborted");
 836                 return;
 837         }
 838         else if(!pairme)
 839         {
 840                 sendto_one_notice(source_p, ":Cannot find K-Line for %s@%s in file",
 841                                   user, host);
 842
 843                 if(temppath != NULL)
 844                         (void) unlink(temppath);
 845
 846                 return;
 847         }
 848
 849         if (rename(temppath, filename))
 850         {
 851                 sendto_one_notice(source_p, ":Couldn't rename temp file, aborted");
 852                 return;
 853         }
 854
 855         sendto_one_notice(source_p, ":K-Line for [%s@%s] is removed",
 856                           user, host);
 857
 858         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 859                              "%s has removed the K-Line for: [%s@%s]",
 860                              get_oper_name(source_p), user, host);
 861
 862         ilog(L_KLINE, "UK %s %s %s",
 863                 get_oper_name(source_p), user, host);
 864
 865         remove_reject_mask(aconf->user, aconf->host);
 866         delete_one_address_conf(aconf->host, aconf);
 867
 868         return;
 869 }
 870
 871 /*
 872  * flush_write()
 873  *
 874  * inputs       - pointer to client structure of oper requesting unkline
 875  *              - out is the file descriptor
 876  *              - buf is the buffer to write
 877  *              - ntowrite is the expected number of character to be written
 878  *              - temppath is the temporary file name to be written
 879  * output       - YES for error on write
 880  *              - NO for success
 881  * side effects - if successful, the buf is written to output file
 882  *                if a write failure happesn, and the file pointed to
 883  *                by temppath, if its non NULL, is removed.
 884  *
 885  * The idea here is, to be as robust as possible when writing to the
 886  * kline file.
 887  *
 888  * -Dianora
 889  */
 890
 891 static int
 892 flush_write(struct Client *source_p, FILE * out, const char *buf, const char *temppath)
 893 {
 894         int error_on_write = (fputs(buf, out) < 0) ? YES : NO;
 895
 896         if(error_on_write)
 897         {
 898                 sendto_one_notice(source_p, ":Unable to write to %s",
 899                                   temppath);
 900                 if(temppath != NULL)
 901                         (void) unlink(temppath);
 902         }
 903         return (error_on_write);
 904 }
 905
 906 /* remove_temp_kline()
 907  *
 908  * inputs       - username, hostname to unkline
 909  * outputs      -
 910  * side effects - tries to unkline anything that matches
 911  */
 912 static int
 913 remove_temp_kline(struct Client *source_p, struct ConfItem *aconf)
 914 {
 915         rb_dlink_node *ptr;
 916         int i;
 917
 918         for (i = 0; i < LAST_TEMP_TYPE; i++)
 919         {
 920                 RB_DLINK_FOREACH(ptr, temp_klines[i].head)
 921                 {
 922                         if (aconf == ptr->data)
 923                         {
 924                                 sendto_one_notice(source_p,
 925                                                 ":Un-klined [%s@%s] from temporary k-lines",
 926                                                 aconf->user, aconf->host);
 927                                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 928                                                 "%s has removed the temporary K-Line for: [%s@%s]",
 929                                                 get_oper_name(source_p), aconf->user, aconf->host);
 930
 931                                 ilog(L_KLINE, "UK %s %s %s",
 932                                         get_oper_name(source_p),
 933                                         aconf->user, aconf->host);
 934                                 rb_dlinkDestroy(ptr, &temp_klines[i]);
 935                                 remove_reject_mask(aconf->user, aconf->host);
 936                                 delete_one_address_conf(aconf->host, aconf);
 937                                 return YES;
 938                         }
 939                 }
 940         }
 941
 942         return NO;
 943 }