src/parse.c

   1 /*
   2  *  charybdis: an advanced ircd.
   3  *  parse.c: The message parser.
   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  *  Copyright (C) 2007 William Pitcock
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  23  *  USA
  24  *
  25  *  $Id: parse.c 3177 2007-02-01 00:19:14Z jilles $
  26  */
  27
  28 #include "stdinc.h"
  29 #include "parse.h"
  30 #include "client.h"
  31 #include "channel.h"
  32 #include "common.h"
  33 #include "hash.h"
  34 #include "match.h"
  35 #include "ircd.h"
  36 #include "numeric.h"
  37 #include "logger.h"
  38 #include "s_stats.h"
  39 #include "send.h"
  40 #include "msg.h"
  41 #include "s_conf.h"
  42 #include "s_serv.h"
  43 #include "packet.h"
  44 #include "s_assert.h"
  45
  46 static struct Dictionary *cmd_dict = NULL;
  47 struct Dictionary *alias_dict = NULL;
  48
  49 /* parv[0] is not used, and parv[LAST] == NULL */
  50 static char *para[MAXPARA + 2];
  51
  52 static void cancel_clients(struct Client *, struct Client *, char *);
  53 static void remove_unknown(struct Client *, char *, char *);
  54
  55 static void do_numeric(char[], struct Client *, struct Client *, int, char **);
  56 static void do_alias(struct alias_entry *, struct Client *, char *);
  57
  58 static int handle_command(struct Message *, struct Client *, struct Client *, int, const char**);
  59
  60 static char buffer[1024];
  61
  62 /* turn a string into a parc/parv pair */
  63
  64
  65 static inline int
  66 string_to_array(char *string, char **parv)
  67 {
  68         char *p, *buf = string;
  69         int x = 1;
  70
  71         parv[x] = NULL;
  72         while (*buf == ' ')     /* skip leading spaces */
  73                 buf++;
  74         if(*buf == '\0')        /* ignore all-space args */
  75                 return x;
  76
  77         do
  78         {
  79                 if(*buf == ':') /* Last parameter */
  80                 {
  81                         buf++;
  82                         parv[x++] = buf;
  83                         parv[x] = NULL;
  84                         return x;
  85                 }
  86                 else
  87                 {
  88                         parv[x++] = buf;
  89                         parv[x] = NULL;
  90                         if((p = strchr(buf, ' ')) != NULL)
  91                         {
  92                                 *p++ = '\0';
  93                                 buf = p;
  94                         }
  95                         else
  96                                 return x;
  97                 }
  98                 while (*buf == ' ')
  99                         buf++;
 100                 if(*buf == '\0')
 101                         return x;
 102         }
 103         /* we can go upto parv[MAXPARA], as parv[0] is skipped */
 104         while (x < MAXPARA);
 105
 106         if(*p == ':')
 107                 p++;
 108
 109         parv[x++] = p;
 110         parv[x] = NULL;
 111         return x;
 112 }
 113
 114 /* parse()
 115  *
 116  * given a raw buffer, parses it and generates parv and parc
 117  */
 118 void
 119 parse(struct Client *client_p, char *pbuffer, char *bufend)
 120 {
 121         struct Client *from = client_p;
 122         char *sender;
 123         char *ch;
 124         char *s;
 125         char *end;
 126         int i = 1;
 127         char *numeric = 0;
 128         struct Message *mptr;
 129
 130         s_assert(MyConnect(client_p));
 131         s_assert(client_p->localClient->F != NULL);
 132         if(IsAnyDead(client_p))
 133                 return;
 134
 135         for (ch = pbuffer; *ch == ' '; ch++)    /* skip spaces */
 136                 /* null statement */ ;
 137
 138         para[0] = from->name;
 139
 140         if(*ch == ':')
 141         {
 142                 ch++;
 143
 144                 /* point sender to the sender param */
 145                 sender = ch;
 146
 147                 if((s = strchr(ch, ' ')))
 148                 {
 149                         *s = '\0';
 150                         s++;
 151                         ch = s;
 152                 }
 153
 154                 if(*sender && IsServer(client_p))
 155                 {
 156                         from = find_client(sender);
 157
 158                         /* didnt find any matching client, issue a kill */
 159                         if(from == NULL)
 160                         {
 161                                 ServerStats.is_unpf++;
 162                                 remove_unknown(client_p, sender, pbuffer);
 163                                 return;
 164                         }
 165
 166                         para[0] = from->name;
 167
 168                         /* fake direction, hmm. */
 169                         if(from->from != client_p)
 170                         {
 171                                 ServerStats.is_wrdi++;
 172                                 cancel_clients(client_p, from, pbuffer);
 173                                 return;
 174                         }
 175                 }
 176                 while (*ch == ' ')
 177                         ch++;
 178         }
 179
 180         if(*ch == '\0')
 181         {
 182                 ServerStats.is_empt++;
 183                 return;
 184         }
 185
 186         /* at this point there must be some sort of command parameter */
 187
 188         /*
 189          * Extract the command code from the packet.  Point s to the end
 190          * of the command code and calculate the length using pointer
 191          * arithmetic.  Note: only need length for numerics and *all*
 192          * numerics must have parameters and thus a space after the command
 193          * code. -avalon
 194          */
 195
 196         /* EOB is 3 chars long but is not a numeric */
 197
 198         if(*(ch + 3) == ' ' &&  /* ok, lets see if its a possible numeric.. */
 199            IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
 200         {
 201                 mptr = NULL;
 202                 numeric = ch;
 203                 ServerStats.is_num++;
 204                 s = ch + 3;     /* I know this is ' ' from above if */
 205                 *s++ = '\0';    /* blow away the ' ', and point s to next part */
 206         }
 207         else
 208         {
 209                 int ii = 0;
 210
 211                 if((s = strchr(ch, ' ')))
 212                         *s++ = '\0';
 213
 214                 mptr = irc_dictionary_retrieve(cmd_dict, ch);
 215
 216                 /* no command or its encap only, error */
 217                 if(!mptr || !mptr->cmd)
 218                 {
 219                         /*
 220                          * Note: Give error message *only* to recognized
 221                          * persons. It's a nightmare situation to have
 222                          * two programs sending "Unknown command"'s or
 223                          * equivalent to each other at full blast....
 224                          * If it has got to person state, it at least
 225                          * seems to be well behaving. Perhaps this message
 226                          * should never be generated, though...  --msa
 227                          * Hm, when is the buffer empty -- if a command
 228                          * code has been found ?? -Armin
 229                          */
 230                         if(pbuffer[0] != '\0')
 231                         {
 232                                 if (IsPerson(client_p))
 233                                 {
 234                                         struct alias_entry *aptr = irc_dictionary_retrieve(alias_dict, ch);
 235                                         if (aptr != NULL)
 236                                         {
 237                                                 do_alias(aptr, client_p, s);
 238                                                 return;
 239                                         }
 240                                 }
 241                                 if(IsPerson(from))
 242                                 {
 243                                         sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
 244                                                    me.name, from->name, ch);
 245                                 }
 246                         }
 247                         ServerStats.is_unco++;
 248                         return;
 249                 }
 250
 251                 ii = bufend - ((s) ? s : ch);
 252                 mptr->bytes += ii;
 253         }
 254
 255         end = bufend - 1;
 256
 257         /* XXX this should be done before parse() is called */
 258         if(*end == '\n')
 259                 *end-- = '\0';
 260         if(*end == '\r')
 261                 *end = '\0';
 262
 263         if(s != NULL)
 264                 i = string_to_array(s, para);
 265
 266         if(mptr == NULL)
 267         {
 268                 do_numeric(numeric, client_p, from, i, para);
 269                 return;
 270         }
 271
 272         if(handle_command(mptr, client_p, from, i, /* XXX discards const!!! */ (const char **)para) < -1)
 273         {
 274                 char *p;
 275                 for (p = pbuffer; p <= end; p += 8)
 276                 {
 277                         /* HACK HACK */
 278                         /* Its expected this nasty code can be removed
 279                          * or rewritten later if still needed.
 280                          */
 281                         if((unsigned long) (p + 8) > (unsigned long) end)
 282                         {
 283                                 for (; p <= end; p++)
 284                                 {
 285                                         ilog(L_MAIN, "%02x |%c", p[0], p[0]);
 286                                 }
 287                         }
 288                         else
 289                                 ilog(L_MAIN,
 290                                      "%02x %02x %02x %02x %02x %02x %02x %02x |%c%c%c%c%c%c%c%c",
 291                                      p[0], p[1], p[2], p[3], p[4], p[5],
 292                                      p[6], p[7], p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
 293                 }
 294         }
 295
 296 }
 297
 298 /*
 299  * handle_command
 300  *
 301  * inputs       - pointer to message block
 302  *              - pointer to client
 303  *              - pointer to client message is from
 304  *              - count of number of args
 305  *              - pointer to argv[] array
 306  * output       - -1 if error from server
 307  * side effects -
 308  */
 309 static int
 310 handle_command(struct Message *mptr, struct Client *client_p,
 311                struct Client *from, int i, const char** hpara)
 312 {
 313         struct MessageEntry ehandler;
 314         MessageHandler handler = 0;
 315         char squitreason[80];
 316
 317         if(IsAnyDead(client_p))
 318                 return -1;
 319
 320         if(IsServer(client_p))
 321                 mptr->rcount++;
 322
 323         mptr->count++;
 324
 325         /* New patch to avoid server flooding from unregistered connects
 326            - Pie-Man 07/27/2000 */
 327
 328         if(!IsRegistered(client_p))
 329         {
 330                 /* if its from a possible server connection
 331                  * ignore it.. more than likely its a header thats sneaked through
 332                  */
 333
 334                 if(IsAnyServer(client_p) && !(mptr->flags & MFLG_UNREG))
 335                         return (1);
 336         }
 337
 338         ehandler = mptr->handlers[from->handler];
 339         handler = ehandler.handler;
 340
 341         /* check right amount of params is passed... --is */
 342         if(i < ehandler.min_para ||
 343            (ehandler.min_para && EmptyString(hpara[ehandler.min_para - 1])))
 344         {
 345                 if(!IsServer(client_p))
 346                 {
 347                         sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
 348                                    me.name,
 349                                    EmptyString(client_p->name) ? "*" : client_p->name,
 350                                    mptr->cmd);
 351                         if(MyClient(client_p))
 352                                 return (1);
 353                         else
 354                                 return (-1);
 355                 }
 356
 357                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 358                                      "Dropping server %s due to (invalid) command '%s'"
 359                                      " with only %d arguments (expecting %d).",
 360                                      client_p->name, mptr->cmd, i, ehandler.min_para);
 361                 ilog(L_SERVER,
 362                      "Insufficient parameters (%d < %d) for command '%s' from %s.",
 363                      i, ehandler.min_para, mptr->cmd, client_p->name);
 364                 rb_snprintf(squitreason, sizeof squitreason,
 365                                 "Insufficient parameters (%d < %d) for command '%s'",
 366                                 i, ehandler.min_para, mptr->cmd);
 367                 exit_client(client_p, client_p, client_p, squitreason);
 368                 return (-1);
 369         }
 370
 371         (*handler) (client_p, from, i, hpara);
 372         return (1);
 373 }
 374
 375 void
 376 handle_encap(struct Client *client_p, struct Client *source_p,
 377              const char *command, int parc, const char *parv[])
 378 {
 379         struct Message *mptr;
 380         struct MessageEntry ehandler;
 381         MessageHandler handler = 0;
 382
 383         parv[0] = source_p->name;
 384
 385         mptr = irc_dictionary_retrieve(cmd_dict, command);
 386
 387         if(mptr == NULL || mptr->cmd == NULL)
 388                 return;
 389
 390         ehandler = mptr->handlers[ENCAP_HANDLER];
 391         handler = ehandler.handler;
 392
 393         if(parc < ehandler.min_para ||
 394            (ehandler.min_para && EmptyString(parv[ehandler.min_para - 1])))
 395                 return;
 396
 397         (*handler) (client_p, source_p, parc, parv);
 398 }
 399
 400 /*
 401  * clear_hash_parse()
 402  *
 403  * inputs       -
 404  * output       - NONE
 405  * side effects - MUST MUST be called at startup ONCE before
 406  *                any other keyword hash routine is used.
 407  *
 408  */
 409 void
 410 clear_hash_parse()
 411 {
 412         cmd_dict = irc_dictionary_create(strcasecmp);
 413 }
 414
 415 /* mod_add_cmd
 416  *
 417  * inputs       - command name
 418  *              - pointer to struct Message
 419  * output       - none
 420  * side effects - load this one command name
 421  *                msg->count msg->bytes is modified in place, in
 422  *                modules address space. Might not want to do that...
 423  */
 424 void
 425 mod_add_cmd(struct Message *msg)
 426 {
 427         s_assert(msg != NULL);
 428         if(msg == NULL)
 429                 return;
 430
 431         if (irc_dictionary_find(cmd_dict, msg->cmd) != NULL)
 432                 return;
 433
 434         msg->count = 0;
 435         msg->rcount = 0;
 436         msg->bytes = 0;
 437
 438         irc_dictionary_add(cmd_dict, msg->cmd, msg);
 439 }
 440
 441 /* mod_del_cmd
 442  *
 443  * inputs       - command name
 444  * output       - none
 445  * side effects - unload this one command name
 446  */
 447 void
 448 mod_del_cmd(struct Message *msg)
 449 {
 450         s_assert(msg != NULL);
 451         if(msg == NULL)
 452                 return;
 453
 454         irc_dictionary_delete(cmd_dict, msg->cmd);
 455 }
 456
 457 /*
 458  * report_messages
 459  *
 460  * inputs       - pointer to client to report to
 461  * output       - NONE
 462  * side effects - NONE
 463  */
 464 void
 465 report_messages(struct Client *source_p)
 466 {
 467         struct DictionaryIter iter;
 468         struct Message *msg;
 469         struct alias_entry *amsg;
 470
 471         DICTIONARY_FOREACH(msg, &iter, cmd_dict)
 472         {
 473                 s_assert(msg->cmd != NULL);
 474                 sendto_one_numeric(source_p, RPL_STATSCOMMANDS,
 475                                    form_str(RPL_STATSCOMMANDS),
 476                                    msg->cmd, msg->count,
 477                                    msg->bytes, msg->rcount);
 478         }
 479
 480         DICTIONARY_FOREACH(amsg, &iter, alias_dict)
 481         {
 482                 s_assert(amsg->name != NULL);
 483                 sendto_one_numeric(source_p, RPL_STATSCOMMANDS,
 484                                    form_str(RPL_STATSCOMMANDS),
 485                                    amsg->name, amsg->hits, 0, 0);
 486         }
 487 }
 488
 489 /* cancel_clients()
 490  *
 491  * inputs       - client who sent us the message, client with fake
 492  *                direction, command
 493  * outputs      - a given warning about the fake direction
 494  * side effects -
 495  */
 496 static void
 497 cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
 498 {
 499         /* ok, fake prefix happens naturally during a burst on a nick
 500          * collision with TS5, we cant kill them because one client has to
 501          * survive, so we just send an error.
 502          */
 503         if(IsServer(source_p) || IsMe(source_p))
 504         {
 505                 sendto_realops_snomask(SNO_DEBUG, L_ALL,
 506                                      "Message for %s[%s] from %s",
 507                                      source_p->name, source_p->from->name,
 508                                      client_p->name);
 509         }
 510         else
 511         {
 512                 sendto_realops_snomask(SNO_DEBUG, L_ALL,
 513                                      "Message for %s[%s@%s!%s] from %s (TS, ignored)",
 514                                      source_p->name,
 515                                      source_p->username,
 516                                      source_p->host,
 517                                      source_p->from->name,
 518                                      client_p->name);
 519         }
 520 }
 521
 522 /* remove_unknown()
 523  *
 524  * inputs       - client who gave us message, supposed sender, buffer
 525  * output       -
 526  * side effects - kills issued for clients, squits for servers
 527  */
 528 static void
 529 remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
 530 {
 531         int slen = strlen(lsender);
 532         char sid[4];
 533         struct Client *server;
 534
 535         /* meepfoo      is a nickname (ignore)
 536          * #XXXXXXXX    is a UID (KILL)
 537          * #XX          is a SID (SQUIT)
 538          * meep.foo     is a server (SQUIT)
 539          */
 540         if((IsDigit(lsender[0]) && slen == 3) ||
 541            (strchr(lsender, '.') != NULL))
 542         {
 543                 sendto_realops_snomask(SNO_DEBUG, L_ALL,
 544                                      "Unknown prefix (%s) from %s, Squitting %s",
 545                                      lbuffer, client_p->name, lsender);
 546
 547                 sendto_one(client_p,
 548                            ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
 549                            get_id(&me, client_p), lsender,
 550                            lbuffer, client_p->name);
 551         }
 552         else if(!IsDigit(lsender[0]))
 553                 ;
 554         else if(slen != 9)
 555                 sendto_realops_snomask(SNO_DEBUG, L_ALL,
 556                                      "Invalid prefix (%s) from %s",
 557                                      lbuffer, client_p->name);
 558         else
 559         {
 560                 memcpy(sid, lsender, 3);
 561                 sid[3] = '\0';
 562                 server = find_server(NULL, sid);
 563                 if (server != NULL && server->from == client_p)
 564                         sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
 565                                         get_id(&me, client_p), lsender, me.name);
 566         }
 567 }
 568
 569
 570
 571 /*
 572  *
 573  *      parc    number of arguments ('sender' counted as one!)
 574  *      parv[1]..parv[parc-1]
 575  *              pointers to additional parameters, this is a NULL
 576  *              terminated list (parv[parc] == NULL).
 577  *
 578  * *WARNING*
 579  *      Numerics are mostly error reports. If there is something
 580  *      wrong with the message, just *DROP* it! Don't even think of
 581  *      sending back a neat error message -- big danger of creating
 582  *      a ping pong error message...
 583  */
 584 static void
 585 do_numeric(char numeric[], struct Client *client_p, struct Client *source_p, int parc, char *parv[])
 586 {
 587         struct Client *target_p;
 588         struct Channel *chptr;
 589
 590         if(parc < 2 || !IsServer(source_p))
 591                 return;
 592
 593         /* Remap low number numerics. */
 594         if(numeric[0] == '0')
 595                 numeric[0] = '1';
 596
 597         /*
 598          * Prepare the parameter portion of the message into 'buffer'.
 599          * (Because the buffer is twice as large as the message buffer
 600          * for the socket, no overflow can occur here... ...on current
 601          * assumptions--bets are off, if these are changed --msa)
 602          * Note: if buffer is non-empty, it will begin with SPACE.
 603          */
 604         if(parc > 1)
 605         {
 606                 char *t = buffer;       /* Current position within the buffer */
 607                 int i;
 608                 int tl;         /* current length of presently being built string in t */
 609                 for (i = 2; i < (parc - 1); i++)
 610                 {
 611                         tl = rb_sprintf(t, " %s", parv[i]);
 612                         t += tl;
 613                 }
 614                 rb_sprintf(t, " :%s", parv[parc - 1]);
 615         }
 616
 617         if((target_p = find_client(parv[1])) != NULL)
 618         {
 619                 if(IsMe(target_p))
 620                 {
 621                         /*
 622                          * We shouldn't get numerics sent to us,
 623                          * any numerics we do get indicate a bug somewhere..
 624                          */
 625                         /* ugh.  this is here because of nick collisions.  when two servers
 626                          * relink, they burst each other their nicks, then perform collides.
 627                          * if there is a nick collision, BOTH servers will kill their own
 628                          * nicks, and BOTH will kill the other servers nick, which wont exist,
 629                          * because it will have been already killed by the local server.
 630                          *
 631                          * unfortunately, as we cant guarantee other servers will do the
 632                          * "right thing" on a nick collision, we have to keep both kills.
 633                          * ergo we need to ignore ERR_NOSUCHNICK. --fl_
 634                          */
 635                         /* quick comment. This _was_ tried. i.e. assume the other servers
 636                          * will do the "right thing" and kill a nick that is colliding.
 637                          * unfortunately, it did not work. --Dianora
 638                          */
 639                         /* note, now we send PING on server connect, we can
 640                          * also get ERR_NOSUCHSERVER..
 641                          */
 642                         if(atoi(numeric) != ERR_NOSUCHNICK &&
 643                            atoi(numeric) != ERR_NOSUCHSERVER)
 644                                 sendto_realops_snomask(SNO_GENERAL, L_ADMIN,
 645                                                      "*** %s(via %s) sent a %s numeric to me: %s",
 646                                                      source_p->name,
 647                                                      client_p->name, numeric, buffer);
 648                         return;
 649                 }
 650                 else if(target_p->from == client_p)
 651                 {
 652                         /* This message changed direction (nick collision?)
 653                          * ignore it.
 654                          */
 655                         return;
 656                 }
 657
 658                 /* csircd will send out unknown umode flag for +a (admin), drop it here. */
 659                 if((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
 660                         return;
 661
 662                 /* Fake it for server hiding, if its our client */
 663                 sendto_one(target_p, ":%s %s %s%s",
 664                            get_id(source_p, target_p), numeric,
 665                            get_id(target_p, target_p), buffer);
 666                 return;
 667         }
 668         else if((chptr = find_channel(parv[1])) != NULL)
 669                 sendto_channel_flags(client_p, ALL_MEMBERS, source_p, chptr,
 670                                      "%s %s%s",
 671                                      numeric, chptr->chname, buffer);
 672 }
 673
 674 static void do_alias(struct alias_entry *aptr, struct Client *source_p, char *text)
 675 {
 676         char *p;
 677         struct Client *target_p;
 678
 679         if (!IsFloodDone(source_p) && source_p->localClient->receiveM > 20)
 680                 flood_endgrace(source_p);
 681
 682         p = strchr(aptr->target, '@');
 683         if (p != NULL)
 684         {
 685                 /* user@server */
 686                 target_p = find_server(NULL, p + 1);
 687                 if (target_p != NULL && IsMe(target_p))
 688                         target_p = NULL;
 689         }
 690         else
 691         {
 692                 /* nick, must be +S */
 693                 target_p = find_named_person(aptr->target);
 694                 if (target_p != NULL && !IsService(target_p))
 695                         target_p = NULL;
 696         }
 697
 698         if (target_p == NULL)
 699         {
 700                 sendto_one_numeric(source_p, ERR_SERVICESDOWN, form_str(ERR_SERVICESDOWN), aptr->target);
 701                 return;
 702         }
 703
 704         if (text != NULL && *text == ':')
 705                 text++;
 706         if (text == NULL || *text == '\0')
 707         {
 708                 sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name);
 709                 return;
 710         }
 711
 712         /* increment the hitcounter on this alias */
 713         aptr->hits++;
 714
 715         sendto_one(target_p, ":%s PRIVMSG %s :%s",
 716                         get_id(source_p, target_p),
 717                         p != NULL ? aptr->target : get_id(target_p, target_p),
 718                         text);
 719 }
 720
 721 int
 722 m_not_oper(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 723 {
 724         sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES));
 725         return 0;
 726 }
 727
 728 int
 729 m_unregistered(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 730 {
 731         /* bit of a hack.
 732          * I don't =really= want to waste a bit in a flag
 733          * number_of_nick_changes is only really valid after the client
 734          * is fully registered..
 735          */
 736         if(client_p->localClient->number_of_nick_changes == 0)
 737         {
 738                 sendto_one(client_p, form_str(ERR_NOTREGISTERED), me.name);
 739                 client_p->localClient->number_of_nick_changes++;
 740         }
 741
 742         return 0;
 743 }
 744
 745 int
 746 m_registered(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 747 {
 748         sendto_one(client_p, form_str(ERR_ALREADYREGISTRED), me.name, source_p->name);
 749         return 0;
 750 }
 751
 752 int
 753 m_ignore(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 754 {
 755         return 0;
 756 }