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