modules/m_signon.c

   1 /* modules/m_signon.c
   2  *   Copyright (C) 2006 Michael Tharp <gxti@partiallystapled.com>
   3  *   Copyright (C) 2006 charybdis development team
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  * 1.Redistributions of source code must retain the above copyright notice,
  10  *   this list of conditions and the following disclaimer.
  11  * 2.Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * 3.The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  21  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  25  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  26  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27  * POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "stdinc.h"
  31
  32 #include "tools.h"
  33 #include "send.h"
  34 #include "channel.h"
  35 #include "client.h"
  36 #include "common.h"
  37 #include "config.h"
  38 #include "ircd.h"
  39 #include "numeric.h"
  40 #include "memory.h"
  41 #include "s_conf.h"
  42 #include "s_serv.h"
  43 #include "hash.h"
  44 #include "msg.h"
  45 #include "parse.h"
  46 #include "modules.h"
  47 #include "sprintf_irc.h"
  48 #include "whowas.h"
  49 #include "monitor.h"
  50 #include "s_stats.h"
  51 #include "snomask.h"
  52 #include "irc_string.h"
  53 #include "s_user.h"
  54
  55 static int me_svslogin(struct Client *, struct Client *, int, const char **);
  56 static int ms_signon(struct Client *, struct Client *, int, const char **);
  57
  58 static void send_signon(struct Client *, struct Client *, const char *, const char *, const char *, unsigned int, const char *);
  59
  60 struct Message svslogin_msgtab = {
  61         "SVSLOGIN", 0, 0, 0, MFLG_SLOW,
  62         {mg_ignore, mg_ignore, mg_ignore, mg_ignore, {me_svslogin, 6}, mg_ignore}
  63 };
  64 struct Message signon_msgtab = {
  65         "SIGNON", 0, 0, 0, MFLG_SLOW,
  66         {mg_ignore, mg_ignore, {ms_signon, 6}, mg_ignore, mg_ignore, mg_ignore}
  67 };
  68
  69 mapi_clist_av1 signon_clist[] = {
  70         &svslogin_msgtab, &signon_msgtab, NULL
  71 };
  72
  73 DECLARE_MODULE_AV1(signon, NULL, NULL, signon_clist, NULL, NULL, "$Revision: 108 $");
  74
  75 #define NICK_VALID      1
  76 #define USER_VALID      2
  77 #define HOST_VALID      4
  78
  79 static int
  80 clean_nick(const char *nick)
  81 {
  82         int len = 0;
  83
  84         if(*nick == '-')
  85                 return 0;
  86
  87         /* This is used to check logins, which are often
  88          * numeric. Don't check for leading digits, if
  89          * services wants to set someone's nick to something
  90          * starting with a number, let it try.
  91          * --gxti
  92          */
  93
  94         for (; *nick; nick++)
  95         {
  96                 len++;
  97                 if(!IsNickChar(*nick))
  98                         return 0;
  99         }
 100
 101         /* nicklen is +1 */
 102         if(len >= NICKLEN)
 103                 return 0;
 104
 105         return 1;
 106 }
 107
 108 static int
 109 clean_username(const char *username)
 110 {
 111         int len = 0;
 112
 113         for (; *username; username++)
 114         {
 115                 len++;
 116
 117                 if(!IsUserChar(*username))
 118                         return 0;
 119         }
 120
 121         if(len > USERLEN)
 122                 return 0;
 123
 124         return 1;
 125 }
 126
 127 static int
 128 clean_host(const char *host)
 129 {
 130         int len = 0;
 131
 132         for (; *host; host++)
 133         {
 134                 len++;
 135
 136                 if(!IsHostChar(*host))
 137                         return 0;
 138         }
 139
 140         if(len > HOSTLEN)
 141                 return 0;
 142
 143         return 1;
 144 }
 145
 146 static int
 147 me_svslogin(struct Client *client_p, struct Client *source_p,
 148         int parc, const char *parv[])
 149 {
 150         struct Client *target_p, *exist_p;
 151         char nick[NICKLEN+1], login[NICKLEN+1];
 152         char user[USERLEN+1], host[HOSTLEN+1];
 153         int valid = 0;
 154
 155         if(!(source_p->flags & FLAGS_SERVICE))
 156                 return 0;
 157
 158         if((target_p = find_client(parv[1])) == NULL)
 159                 return 0;
 160
 161         if(!MyClient(target_p) && !IsUnknown(target_p))
 162                 return 0;
 163
 164         if(clean_nick(parv[2]))
 165         {
 166                 strlcpy(nick, parv[2], NICKLEN + 1);
 167                 valid |= NICK_VALID;
 168         }
 169         else if(*target_p->name)
 170                 strlcpy(nick, target_p->name, NICKLEN + 1);
 171         else
 172                 strcpy(nick, "*");
 173
 174         if(clean_username(parv[3]))
 175         {
 176                 strlcpy(user, parv[3], USERLEN + 1);
 177                 valid |= USER_VALID;
 178         }
 179         else
 180                 strlcpy(user, target_p->username, USERLEN + 1);
 181
 182         if(clean_host(parv[4]))
 183         {
 184                 strlcpy(host, parv[4], HOSTLEN + 1);
 185                 valid |= HOST_VALID;
 186         }
 187         else
 188                 strlcpy(host, target_p->host, HOSTLEN + 1);
 189
 190         if(*parv[5] == '*')
 191         {
 192                 if(target_p->user)
 193                         strlcpy(login, target_p->user->suser, NICKLEN + 1);
 194                 else
 195                         login[0] = '\0';
 196         }
 197         else if(!strcmp(parv[5], "0"))
 198                 login[0] = '\0';
 199         else
 200                 strlcpy(login, parv[5], NICKLEN + 1);
 201
 202         /* Login (mostly) follows nick rules. */
 203         if(*login && !clean_nick(login))
 204                 return 0;
 205
 206         if((exist_p = find_person(nick)) && target_p != exist_p)
 207         {
 208                 char buf[BUFSIZE];
 209
 210                 if(MyClient(exist_p))
 211                         sendto_one(exist_p, ":%s KILL %s :(Nickname regained by services)",
 212                                 me.name, exist_p->name);
 213
 214                 exist_p->flags |= FLAGS_KILLED;
 215                 kill_client_serv_butone(NULL, exist_p, "%s (Nickname regained by services)",
 216                                         me.name);
 217
 218                 snprintf(buf, sizeof(buf), "Killed (%s (Nickname regained by services))",
 219                         me.name);
 220                 exit_client(NULL, exist_p, &me, buf);
 221         }else if((exist_p = find_client(nick)) && IsUnknown(exist_p) && exist_p != target_p) {
 222                 exit_client(NULL, exist_p, &me, "Overridden");
 223         }
 224
 225         if(*login)
 226         {
 227                 /* Strip leading digits, unless it's purely numeric. */
 228                 const char *p = login;
 229                 while(IsDigit(*p))
 230                         p++;
 231                 if(!*p)
 232                         p = login;
 233
 234                 sendto_one(target_p, form_str(RPL_LOGGEDIN), me.name, EmptyString(target_p->name) ? "*" : target_p->name,
 235                                 nick, user, host, p, p);
 236         }
 237         else
 238                 sendto_one(target_p, form_str(RPL_LOGGEDOUT), me.name, EmptyString(target_p->name) ? "*" : target_p->name,
 239                                 nick, user, host);
 240
 241         if(IsUnknown(target_p))
 242         {
 243                 struct User *user_p = make_user(target_p);
 244
 245                 if(valid & NICK_VALID)
 246                         strcpy(target_p->preClient->spoofnick, nick);
 247
 248                 if(valid & USER_VALID)
 249                         strcpy(target_p->preClient->spoofuser, user);
 250
 251                 if(valid & HOST_VALID)
 252                         strcpy(target_p->preClient->spoofhost, host);
 253
 254                 strlcpy(user_p->suser, login, NICKLEN + 1);
 255         }
 256         else
 257         {
 258                 send_signon(NULL, target_p, nick, user, host, CurrentTime, login);
 259                 comm_note(target_p->localClient->fd, "Nick: %s", target_p->name);
 260         }
 261
 262         return 0;
 263 }
 264
 265 static int
 266 ms_signon(struct Client *client_p, struct Client *source_p,
 267         int parc, const char *parv[])
 268 {
 269         struct Client *target_p;
 270         int newts, sameuser;
 271         char login[NICKLEN+1];
 272
 273         if(!clean_nick(parv[1]))
 274         {
 275                 ServerStats->is_kill++;
 276                 sendto_realops_snomask(SNO_DEBUG, L_ALL,
 277                                 "Bad Nick from SIGNON: %s From: %s(via %s)",
 278                                 parv[1], source_p->servptr->name, client_p->name);
 279                 /* if source_p has an id, kill_client_serv_butone() will
 280                  * send a kill to client_p, otherwise do it here */
 281                 if (!has_id(source_p))
 282                         sendto_one(client_p, ":%s KILL %s :%s (Bad nickname from SIGNON)",
 283                                 get_id(&me, client_p), parv[1], me.name);
 284                 kill_client_serv_butone(client_p, source_p, "%s (Bad nickname from SIGNON)",
 285                                 me.name);
 286                 source_p->flags |= FLAGS_KILLED;
 287                 exit_client(NULL, source_p, &me, "Bad nickname from SIGNON");
 288                 return 0;
 289         }
 290
 291         if(!clean_username(parv[2]) || !clean_host(parv[3]))
 292         {
 293                 ServerStats->is_kill++;
 294                 sendto_realops_snomask(SNO_DEBUG, L_ALL,
 295                                 "Bad user@host from SIGNON: %s@%s From: %s(via %s)",
 296                                 parv[2], parv[3], source_p->servptr->name, client_p->name);
 297                 /* if source_p has an id, kill_client_serv_butone() will
 298                  * send a kill to client_p, otherwise do it here */
 299                 if (!has_id(source_p))
 300                         sendto_one(client_p, ":%s KILL %s :%s (Bad user@host from SIGNON)",
 301                                 get_id(&me, client_p), parv[1], me.name);
 302                 kill_client_serv_butone(client_p, source_p, "%s (Bad user@host from SIGNON)",
 303                                 me.name);
 304                 source_p->flags |= FLAGS_KILLED;
 305                 exit_client(NULL, source_p, &me, "Bad user@host from SIGNON");
 306                 return 0;
 307         }
 308
 309         newts = atol(parv[4]);
 310
 311         if(!strcmp(parv[5], "0"))
 312                 login[0] = '\0';
 313         else if(*parv[5] != '*')
 314         {
 315                 if (clean_nick(parv[5]))
 316                         strlcpy(login, parv[5], NICKLEN + 1);
 317                 else
 318                         return 0;
 319         }
 320
 321         target_p = find_named_client(parv[1]);
 322         if(target_p != NULL && target_p != source_p)
 323         {
 324                 /* In case of collision, follow NICK rules. */
 325                 /* XXX this is duplicated code and does not do SAVE */
 326                 if(IsUnknown(target_p))
 327                         exit_client(NULL, target_p, &me, "Overridden");
 328                 else
 329                 {
 330                         if(!newts || !target_p->tsinfo || (newts == target_p->tsinfo) || !source_p->user)
 331                         {
 332                                 sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
 333                                                      "Nick change collision from SIGNON from %s to %s(%s <- %s)(both killed)",
 334                                                      source_p->name, target_p->name, target_p->from->name,
 335                                                      client_p->name);
 336
 337                                 ServerStats->is_kill++;
 338                                 sendto_one_numeric(target_p, ERR_NICKCOLLISION,
 339                                                    form_str(ERR_NICKCOLLISION), target_p->name);
 340
 341                                 kill_client_serv_butone(NULL, source_p, "%s (Nick change collision)", me.name);
 342
 343                                 ServerStats->is_kill++;
 344
 345                                 kill_client_serv_butone(NULL, target_p, "%s (Nick change collision)", me.name);
 346
 347                                 target_p->flags |= FLAGS_KILLED;
 348                                 exit_client(NULL, target_p, &me, "Nick collision(new)");
 349                                 source_p->flags |= FLAGS_KILLED;
 350                                 exit_client(client_p, source_p, &me, "Nick collision(old)");
 351                                 return 0;
 352                         }
 353                         else
 354                         {
 355                                 sameuser = !irccmp(target_p->username, source_p->username) &&
 356                                         !irccmp(target_p->host, source_p->host);
 357
 358                                 if((sameuser && newts < target_p->tsinfo) ||
 359                                    (!sameuser && newts > target_p->tsinfo))
 360                                 {
 361                                         if(sameuser)
 362                                                 sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
 363                                                                      "Nick change collision from SIGNON from %s to %s(%s <- %s)(older killed)",
 364                                                                      source_p->name, target_p->name,
 365                                                                      target_p->from->name, client_p->name);
 366                                         else
 367                                                 sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
 368                                                                      "Nick change collision from SIGNON from %s to %s(%s <- %s)(newer killed)",
 369                                                                      source_p->name, target_p->name,
 370                                                                      target_p->from->name, client_p->name);
 371
 372                                         ServerStats->is_kill++;
 373
 374                                         sendto_one_numeric(target_p, ERR_NICKCOLLISION,
 375                                                            form_str(ERR_NICKCOLLISION), target_p->name);
 376
 377                                         /* kill the client issuing the nickchange */
 378                                         kill_client_serv_butone(client_p, source_p,
 379                                                                 "%s (Nick change collision)", me.name);
 380
 381                                         source_p->flags |= FLAGS_KILLED;
 382
 383                                         if(sameuser)
 384                                                 exit_client(client_p, source_p, &me, "Nick collision(old)");
 385                                         else
 386                                                 exit_client(client_p, source_p, &me, "Nick collision(new)");
 387                                         return 0;
 388                                 }
 389                                 else
 390                                 {
 391                                         if(sameuser)
 392                                                 sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
 393                                                                      "Nick collision from SIGNON on %s(%s <- %s)(older killed)",
 394                                                                      target_p->name, target_p->from->name,
 395                                                                      client_p->name);
 396                                         else
 397                                                 sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
 398                                                                      "Nick collision from SIGNON on %s(%s <- %s)(newer killed)",
 399                                                                      target_p->name, target_p->from->name,
 400                                                                      client_p->name);
 401
 402                                         sendto_one_numeric(target_p, ERR_NICKCOLLISION,
 403                                                            form_str(ERR_NICKCOLLISION), target_p->name);
 404
 405                                         /* kill the client who existed before hand */
 406                                         kill_client_serv_butone(client_p, target_p,
 407                                                         "%s (Nick collision)", me.name);
 408
 409                                         ServerStats->is_kill++;
 410
 411                                         target_p->flags |= FLAGS_KILLED;
 412                                         (void) exit_client(client_p, target_p, &me, "Nick collision");
 413                                 }
 414                         }
 415
 416                 }
 417         }
 418
 419         send_signon(client_p, source_p, parv[1], parv[2], parv[3], newts, login);
 420         return 0;
 421 }
 422
 423 static void
 424 send_signon(struct Client *client_p, struct Client *target_p,
 425                 const char *nick, const char *user, const char *host,
 426                 unsigned int newts, const char *login)
 427 {
 428         sendto_server(client_p, NULL, CAP_TS6, NOCAPS, ":%s SIGNON %s %s %s %ld %s",
 429                         use_id(target_p), nick, user, host,
 430                         (long) target_p->tsinfo, *login ? login : "0");
 431         sendto_server(client_p, NULL, NOCAPS, CAP_TS6, ":%s SIGNON %s %s %s %ld %s",
 432                         target_p->name, nick, user, host,
 433                         (long) target_p->tsinfo, *login ? login : "0");
 434
 435         strcpy(target_p->user->suser, login);
 436
 437         change_nick_user_host(target_p, nick, user, host, newts, "Signing %s (%s)", *login ?  "in" : "out", nick);
 438 }
 439