modules/m_dline.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  m_dline.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_dline.c 3225 2007-03-04 23:42:55Z 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
  46 static int mo_dline(struct Client *, struct Client *, int, const char **);
  47 static int me_dline(struct Client *, struct Client *, int, const char **);
  48 static int mo_undline(struct Client *, struct Client *, int, const char **);
  49 static int me_undline(struct Client *, struct Client *, int, const char **);
  50
  51 struct Message dline_msgtab = {
  52         "DLINE", 0, 0, 0, MFLG_SLOW,
  53         {mg_unreg, mg_not_oper, mg_ignore, mg_ignore, {me_dline, 3}, {mo_dline, 2}}
  54 };
  55 struct Message undline_msgtab = {
  56         "UNDLINE", 0, 0, 0, MFLG_SLOW,
  57         {mg_unreg, mg_not_oper, mg_ignore, mg_ignore, {me_undline, 1}, {mo_undline, 2}}
  58 };
  59
  60 mapi_clist_av1 dline_clist[] = { &dline_msgtab, &undline_msgtab, NULL };
  61 DECLARE_MODULE_AV1(dline, NULL, NULL, dline_clist, NULL, NULL, "$Revision: 3225 $");
  62
  63 static int valid_comment(char *comment);
  64 static int flush_write(struct Client *, FILE *, char *, char *);
  65 static int remove_temp_dline(struct ConfItem *);
  66 static int apply_dline(struct Client *, const char *, int, char *);
  67 static int apply_undline(struct Client *, const char *);
  68
  69 /* mo_dline()
  70  *
  71  *   parv[1] - dline to add
  72  *   parv[2] - reason
  73  */
  74 static int
  75 mo_dline(struct Client *client_p, struct Client *source_p,
  76          int parc, const char *parv[])
  77 {
  78         char def[] = "No Reason";
  79         const char *dlhost;
  80         char *reason = def;
  81         char cidr_form_host[HOSTLEN + 1];
  82         int tdline_time = 0;
  83         const char *target_server = NULL;
  84         int loc = 1;
  85
  86         if(!IsOperK(source_p))
  87         {
  88                 sendto_one(source_p, form_str(ERR_NOPRIVS),
  89                            me.name, source_p->name, "kline");
  90                 return 0;
  91         }
  92
  93         if((tdline_time = valid_temp_time(parv[loc])) >= 0)
  94                 loc++;
  95
  96         dlhost = parv[loc];
  97         rb_strlcpy(cidr_form_host, dlhost, sizeof(cidr_form_host));
  98
  99         loc++;
 100
 101         if(parc >= loc+2 && !irccmp(parv[loc], "ON"))
 102         {
 103                 if(!IsOperRemoteBan(source_p))
 104                 {
 105                         sendto_one(source_p, form_str(ERR_NOPRIVS),
 106                                 me.name, source_p->name, "remoteban");
 107                         return 0;
 108                 }
 109
 110                 target_server = parv[loc+1];
 111                 loc += 2;
 112         }
 113
 114         if(parc >= loc + 1 && !EmptyString(parv[loc]))
 115                 reason = LOCAL_COPY(parv[loc]);
 116
 117         if(target_server != NULL)
 118         {
 119                 sendto_match_servs(source_p, target_server,
 120                                 CAP_ENCAP, NOCAPS,
 121                                 "ENCAP %s DLINE %d %s :%s",
 122                                 target_server, tdline_time, dlhost, reason);
 123
 124                 if(!match(target_server, me.name))
 125                         return 0;
 126         }
 127
 128         apply_dline(source_p, dlhost, tdline_time, reason);
 129
 130         check_dlines();
 131         return 0;
 132 }
 133
 134 /* mo_undline()
 135  *
 136  *      parv[1] = dline to remove
 137  */
 138 static int
 139 mo_undline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 140 {
 141         const char *cidr;
 142         const char *target_server = NULL;
 143
 144         if(!IsOperK(source_p))
 145         {
 146                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 147                            me.name, source_p->name, "unkline");
 148                 return 0;
 149         }
 150
 151         cidr = parv[1];
 152
 153         if(parc >= 4 && !irccmp(parv[2], "ON"))
 154         {
 155                 if(!IsOperRemoteBan(source_p))
 156                 {
 157                         sendto_one(source_p, form_str(ERR_NOPRIVS),
 158                                 me.name, source_p->name, "remoteban");
 159                         return 0;
 160                 }
 161
 162                 target_server = parv[3];
 163                 sendto_match_servs(source_p, target_server,
 164                                 CAP_ENCAP, NOCAPS,
 165                                 "ENCAP %s UNDLINE %s",
 166                                 target_server, cidr);
 167
 168                 if(!match(target_server, me.name))
 169                         return 0;
 170         }
 171
 172         apply_undline(source_p, cidr);
 173
 174         return 0;
 175 }
 176
 177 static int
 178 me_dline(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 179 {
 180         int tdline_time = atoi(parv[1]);
 181         /* Since this is coming over a server link, assume that the originating
 182          * server did the relevant permission/sanity checks...
 183          */
 184
 185         if(!IsPerson(source_p))
 186                 return 0;
 187
 188         if(!find_shared_conf(source_p->username, source_p->host,
 189                                 source_p->servptr->name, tdline_time > 0 ? SHARED_TDLINE : SHARED_PDLINE))
 190                 return 0;
 191
 192         apply_dline(source_p, parv[2], tdline_time, LOCAL_COPY(parv[3]));
 193
 194         check_dlines();
 195         return 0;
 196 }
 197
 198 static int
 199 me_undline(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 200 {
 201         if(!IsPerson(source_p))
 202                 return 0;
 203
 204         if(!find_shared_conf(source_p->username, source_p->host,
 205                                 source_p->servptr->name, SHARED_UNDLINE))
 206                 return 0;
 207
 208         apply_undline(source_p, parv[1]);
 209
 210         return 0;
 211 }
 212
 213 static int
 214 apply_dline(struct Client *source_p, const char *dlhost, int tdline_time, char *reason)
 215 {
 216         struct ConfItem *aconf;
 217         char *oper_reason;
 218         char dlbuffer[IRCD_BUFSIZE];
 219         const char *current_date;
 220         struct rb_sockaddr_storage daddr;
 221         int t = AF_INET, ty, b;
 222         const char *creason;
 223
 224         ty = parse_netmask(dlhost, (struct sockaddr *)&daddr, &b);
 225         if(ty == HM_HOST)
 226         {
 227                 sendto_one(source_p, ":%s NOTICE %s :Invalid D-Line",
 228                            me.name, source_p->name);
 229                 return 0;
 230         }
 231 #ifdef RB_IPV6
 232         if(ty == HM_IPV6)
 233                 t = AF_INET6;
 234         else
 235 #endif
 236                 t = AF_INET;
 237
 238         /* This means dlines wider than /16 cannot be set remotely */
 239         if(IsOperAdmin(source_p))
 240         {
 241                 if(b < 8)
 242                 {
 243                         sendto_one_notice(source_p,
 244                                    ":For safety, bitmasks less than 8 require conf access.");
 245                         return 0;
 246                 }
 247         }
 248         else
 249         {
 250                 if(b < 16)
 251                 {
 252                         sendto_one_notice(source_p,
 253                                    ":Dline bitmasks less than 16 are for admins only.");
 254                         return 0;
 255                 }
 256         }
 257
 258         if(!valid_comment(reason))
 259         {
 260                 sendto_one(source_p,
 261                            ":%s NOTICE %s :Invalid character '\"' in comment",
 262                            me.name, source_p->name);
 263                 return 0;
 264         }
 265
 266         if(ConfigFileEntry.non_redundant_klines)
 267         {
 268                 if((aconf = find_dline((struct sockaddr *)&daddr, t)) != NULL)
 269                 {
 270                         int bx;
 271                         parse_netmask(aconf->host, NULL, &bx);
 272                         if(b >= bx)
 273                         {
 274                                 creason = aconf->passwd ? aconf->passwd : "<No Reason>";
 275                                 if(IsConfExemptKline(aconf))
 276                                         sendto_one(source_p,
 277                                                    ":%s NOTICE %s :[%s] is (E)d-lined by [%s] - %s",
 278                                                    me.name, source_p->name, dlhost, aconf->host, creason);
 279                                 else
 280                                         sendto_one(source_p,
 281                                                    ":%s NOTICE %s :[%s] already D-lined by [%s] - %s",
 282                                                    me.name, source_p->name, dlhost, aconf->host, creason);
 283                                 return 0;
 284                         }
 285                 }
 286         }
 287
 288         rb_set_time();
 289         current_date = smalldate();
 290
 291         aconf = make_conf();
 292         aconf->status = CONF_DLINE;
 293         aconf->host = rb_strdup(dlhost);
 294
 295         /* Look for an oper reason */
 296         if((oper_reason = strchr(reason, '|')) != NULL)
 297         {
 298                 *oper_reason = '\0';
 299                 oper_reason++;
 300
 301                 if(!EmptyString(oper_reason))
 302                         aconf->spasswd = rb_strdup(oper_reason);
 303         }
 304
 305         if(tdline_time > 0)
 306         {
 307                 rb_snprintf(dlbuffer, sizeof(dlbuffer),
 308                          "Temporary D-line %d min. - %s (%s)",
 309                          (int) (tdline_time / 60), reason, current_date);
 310                 aconf->passwd = rb_strdup(dlbuffer);
 311                 aconf->hold = rb_current_time() + tdline_time;
 312                 add_temp_dline(aconf);
 313
 314                 if(EmptyString(oper_reason))
 315                 {
 316                         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 317                                              "%s added temporary %d min. D-Line for [%s] [%s]",
 318                                              get_oper_name(source_p), tdline_time / 60,
 319                                              aconf->host, reason);
 320                         ilog(L_KLINE, "D %s %d %s %s",
 321                                 get_oper_name(source_p), tdline_time / 60,
 322                                 aconf->host, reason);
 323                 }
 324                 else
 325                 {
 326                         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 327                                              "%s added temporary %d min. D-Line for [%s] [%s|%s]",
 328                                              get_oper_name(source_p), tdline_time / 60,
 329                                              aconf->host, reason, oper_reason);
 330                         ilog(L_KLINE, "D %s %d %s %s|%s",
 331                                 get_oper_name(source_p), tdline_time / 60,
 332                                 aconf->host, reason, oper_reason);
 333                 }
 334
 335                 sendto_one(source_p, ":%s NOTICE %s :Added temporary %d min. D-Line for [%s]",
 336                            me.name, source_p->name, tdline_time / 60, aconf->host);
 337         }
 338         else
 339         {
 340                 rb_snprintf(dlbuffer, sizeof(dlbuffer), "%s (%s)", reason, current_date);
 341                 aconf->passwd = rb_strdup(dlbuffer);
 342                 add_conf_by_address(aconf->host, CONF_DLINE, NULL, NULL, aconf);
 343                 write_confitem(DLINE_TYPE, source_p, NULL, aconf->host, reason,
 344                                oper_reason, current_date, 0);
 345         }
 346
 347         return 0;
 348 }
 349
 350 static int
 351 apply_undline(struct Client *source_p, const char *cidr)
 352 {
 353         FILE *in;
 354         FILE *out;
 355         char buf[BUFSIZE], buff[BUFSIZE], temppath[BUFSIZE], *p;
 356         const char *filename, *found_cidr;
 357         int pairme = NO, error_on_write = NO;
 358         mode_t oldumask;
 359         struct ConfItem *aconf;
 360
 361         if(parse_netmask(cidr, NULL, NULL) == HM_HOST)
 362         {
 363                 sendto_one_notice(source_p, ":Invalid D-Line");
 364                 return 0;
 365         }
 366
 367         rb_snprintf(temppath, sizeof(temppath), "%s.tmp", ConfigFileEntry.dlinefile);
 368
 369         aconf = find_exact_conf_by_address(cidr, CONF_DLINE, NULL);
 370         if(aconf == NULL)
 371         {
 372                 sendto_one_notice(source_p, ":No D-Line for %s", cidr);
 373                 return 0;
 374         }
 375
 376         rb_strlcpy(buf, aconf->host, sizeof buf);
 377         if(remove_temp_dline(aconf))
 378         {
 379                 sendto_one(source_p,
 380                            ":%s NOTICE %s :Un-dlined [%s] from temporary D-lines",
 381                            me.name, source_p->name, buf);
 382                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 383                                      "%s has removed the temporary D-Line for: [%s]",
 384                                      get_oper_name(source_p), buf);
 385                 ilog(L_KLINE, "UD %s %s", get_oper_name(source_p), buf);
 386                 return 0;
 387         }
 388
 389         filename = get_conf_name(DLINE_TYPE);
 390
 391         if((in = fopen(filename, "r")) == 0)
 392         {
 393                 sendto_one(source_p, ":%s NOTICE %s :Cannot open %s", me.name, source_p->name, filename);
 394                 return 0;
 395         }
 396
 397         oldumask = umask(0);
 398         if((out = fopen(temppath, "w")) == 0)
 399         {
 400                 sendto_one(source_p, ":%s NOTICE %s :Cannot open %s", me.name, source_p->name, temppath);
 401                 fclose(in);
 402                 umask(oldumask);
 403                 return 0;
 404         }
 405
 406         umask(oldumask);
 407
 408         while (fgets(buf, sizeof(buf), in))
 409         {
 410                 rb_strlcpy(buff, buf, sizeof(buff));
 411
 412                 if((p = strchr(buff, '\n')) != NULL)
 413                         *p = '\0';
 414
 415                 if((*buff == '\0') || (*buff == '#'))
 416                 {
 417                         if(!error_on_write)
 418                                 flush_write(source_p, out, buf, temppath);
 419                         continue;
 420                 }
 421
 422                 if((found_cidr = getfield(buff)) == NULL)
 423                 {
 424                         if(!error_on_write)
 425                                 flush_write(source_p, out, buf, temppath);
 426                         continue;
 427                 }
 428
 429                 if(irccmp(found_cidr, aconf->host) == 0)
 430                 {
 431                         pairme++;
 432                 }
 433                 else
 434                 {
 435                         if(!error_on_write)
 436                                 flush_write(source_p, out, buf, temppath);
 437                         continue;
 438                 }
 439         }
 440
 441         fclose(in);
 442         if (fclose(out))
 443                 error_on_write = YES;
 444
 445         if(error_on_write)
 446         {
 447                 sendto_one(source_p,
 448                            ":%s NOTICE %s :Couldn't write D-line file, aborted",
 449                            me.name, source_p->name);
 450                 return 0;
 451         }
 452         else if(!pairme)
 453         {
 454                 sendto_one_notice(source_p, ":Cannot find D-Line for %s in file",
 455                                 aconf->host);
 456
 457                 if(temppath != NULL)
 458                         (void) unlink(temppath);
 459
 460                 return 0;
 461         }
 462
 463         if (rename(temppath, filename))
 464         {
 465                 sendto_one_notice(source_p, ":Couldn't rename temp file, aborted");
 466                 return 0;
 467         }
 468
 469         sendto_one(source_p, ":%s NOTICE %s :D-Line for [%s] is removed", me.name, source_p->name, aconf->host);
 470         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 471                              "%s has removed the D-Line for: [%s]", get_oper_name(source_p), aconf->host);
 472         ilog(L_KLINE, "UD %s %s", get_oper_name(source_p), aconf->host);
 473         delete_one_address_conf(aconf->host, aconf);
 474
 475         return 0;
 476 }
 477
 478 /*
 479  * valid_comment
 480  * inputs       - pointer to client
 481  *              - pointer to comment
 482  * output       - 0 if no valid comment, 1 if valid
 483  * side effects - NONE
 484  */
 485 static int
 486 valid_comment(char *comment)
 487 {
 488         if(strchr(comment, '"'))
 489                 return 0;
 490
 491         if(strlen(comment) > BANREASONLEN)
 492                 comment[BANREASONLEN] = '\0';
 493
 494         return 1;
 495 }
 496
 497 /*
 498  * flush_write()
 499  *
 500  * inputs       - pointer to client structure of oper requesting unkline
 501  *              - out is the file descriptor
 502  *              - buf is the buffer to write
 503  *              - ntowrite is the expected number of character to be written
 504  *              - temppath is the temporary file name to be written
 505  * output       - YES for error on write
 506  *              - NO for success
 507  * side effects - if successful, the buf is written to output file
 508  *                if a write failure happesn, and the file pointed to
 509  *                by temppath, if its non NULL, is removed.
 510  *
 511  * The idea here is, to be as robust as possible when writing to the
 512  * kline file.
 513  *
 514  * -Dianora
 515  */
 516 static int
 517 flush_write(struct Client *source_p, FILE * out, char *buf, char *temppath)
 518 {
 519         int error_on_write = (fputs(buf, out) < 0) ? YES : NO;
 520
 521         if(error_on_write)
 522         {
 523                 sendto_one_notice(source_p, ":Unable to write to %s", temppath);
 524                 fclose(out);
 525                 if(temppath != NULL)
 526                         (void) unlink(temppath);
 527         }
 528         return (error_on_write);
 529 }
 530
 531 /* remove_temp_dline()
 532  *
 533  * inputs       - confitem to undline
 534  * outputs      -
 535  * side effects - tries to undline anything that matches
 536  */
 537 static int
 538 remove_temp_dline(struct ConfItem *aconf)
 539 {
 540         rb_dlink_node *ptr;
 541         int i;
 542
 543         for (i = 0; i < LAST_TEMP_TYPE; i++)
 544         {
 545                 RB_DLINK_FOREACH(ptr, temp_dlines[i].head)
 546                 {
 547                         if (aconf == ptr->data)
 548                         {
 549                                 rb_dlinkDestroy(ptr, &temp_dlines[i]);
 550                                 delete_one_address_conf(aconf->host, aconf);
 551                                 return YES;
 552                         }
 553                 }
 554         }
 555
 556         return NO;
 557 }