trunk/src/parse.c

/*
 *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
 *
 *  Copyright (c) 1997-2014 ircd-hybrid development team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 *  USA
 */

/*! \file parse.c
 * \brief The message parser.
 * \version $Id$
 */

#include "stdinc.h"
#include "client.h"
#include "parse.h"
#include "channel.h"
#include "hash.h"
#include "irc_string.h"
#include "ircd.h"
#include "numeric.h"
#include "log.h"
#include "send.h"
#include "conf.h"
#include "memory.h"
#include "user.h"
#include "server.h"


/*
 * (based on orabidoo's parser code)
 *
 * This has always just been a trie. Look at volume III of Knuth ACP
 *
 *
 * ok, you start out with an array of pointers, each one corresponds
 * to a letter at the current position in the command being examined.
 *
 * so roughly you have this for matching 'trie' or 'tie'
 *
 * 't' points -> [MessageTree *] 'r' -> [MessageTree *] -> 'i'
 *   -> [MessageTree *] -> [MessageTree *] -> 'e' and matches
 *
 *                               'i' -> [MessageTree *] -> 'e' and matches
 *
 * BUGS (Limitations!)
 *
 * I designed this trie to parse ircd commands. Hence it currently
 * casefolds. This is trivial to fix by increasing MAXPTRLEN.
 * This trie also "folds" '{' etc. down. This means, the input to this
 * trie must be alpha tokens only. This again, is a limitation that
 * can be overcome by increasing MAXPTRLEN to include upper/lower case
 * at the expense of more memory. At the extreme end, you could make
 * MAXPTRLEN 128.
 *
 * This is also not a patricia trie. On short ircd tokens, this is
 * not likely going to matter.
 *
 * Diane Bruce (Dianora), June 6 2003
 */

/*
 * Must be a power of 2, and larger than 26 [a-z]|[A-Z]. It's used to allocate
 * the set of pointers at each node of the tree.
 * There are MAXPTRLEN pointers at each node. Obviously, there have to be more
 * pointers than ASCII letters. 32 is a nice number since there is then no need
 * to shift 'A'/'a' to base 0 index, at the expense of a few never used
 * pointers.
 * For a small parser like this, this is a good compromise and does
 * make it somewhat faster. - Dianora
 */
#define MAXPTRLEN 32


static struct MessageTree
{
  int links; /* Count of all pointers (including msg) at this node
              * used as reference count for deletion of _this_ node.
              */
  struct Message *msg;
  struct MessageTree *pointers[MAXPTRLEN];
} msg_tree;


/* remove_unknown()
 *
 * inputs       -
 * output       -
 * side effects -
 */
static void
parse_remove_unknown(struct Client *client_p, const char *lsender, char *lbuffer)
{
  /*
   * Do kill if it came from a server because it means there is a ghost
   * user on the other server which needs to be removed. -avalon
   * Tell opers about this. -Taner
   */
  /*
   * '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
   * 'nodots'          is a nickname (KILL)
   * 'no.dot.at.start' is a server   (SQUIT)
   */
  if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
  {
    sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
                         "Unknown prefix (%s) from %s, Squitting %s",
                         lbuffer, get_client_name(client_p, SHOW_IP), lsender);
    sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
                         "Unknown prefix (%s) from %s, Squitting %s",
                         lbuffer, client_p->name, lsender);
    sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
               me.id, lsender, lbuffer, client_p->name);
  }
  else
    sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
               me.id, lsender, me.name);
}

/*
 *
 *      parc    number of arguments ('sender' counted as one!)
 *      parv[0] pointer to 'sender' (may point to empty string) (not used)
 *      parv[1]..parv[parc-1]
 *              pointers to additional parameters, this is a NULL
 *              terminated list (parv[parc] == NULL).
 *
 * *WARNING*
 *      Numerics are mostly error reports. If there is something
 *      wrong with the message, just *DROP* it! Don't even think of
 *      sending back a neat error message -- big danger of creating
 *      a ping pong error message...
 *
 * Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
 *
 * Called when we get a numeric message from a remote _server_ and we are
 * supposed to forward it somewhere. Note that we always ignore numerics sent
 * to 'me' and simply drop the message if we can't handle with this properly:
 * the savvy approach is NEVER generate an error in response to an... error :)
 */
static void
parse_handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
{
  struct Client *target_p = NULL;
  struct Channel *chptr = NULL;

  /*
   * Avoid trash, we need it to come from a server and have a target
   */
  if (parc < 2 || !IsServer(source_p))
    return;

  /*
   * Who should receive this message ? Will we do something with it ?
   * Note that we use findUser functions, so the target can't be neither
   * a server, nor a channel (?) nor a list of targets (?) .. u2.10
   * should never generate numeric replies to non-users anyway
   * Ahem... it can be a channel actually, csc bots use it :\ --Nem
   */
  if (IsChanPrefix(*parv[1]))
    chptr = hash_find_channel(parv[1]);
  else
    target_p = find_person(source_p, parv[1]);

  if ((!target_p || target_p->from == source_p->from) && !chptr)
    return;

  /*
   * Remap low number numerics, not that I understand WHY.. --Nemesi
   */
  /*
   * Numerics below 100 talk about the current 'connection', you're not
   * connected to a remote server so it doesn't make sense to send them
   * remotely - but the information they contain may be useful, so we
   * remap them up. Weird, but true.  -- Isomer
   */
  if (numeric < 100)
    numeric += 100;

  if (target_p)
  {
    /* Fake it for server hiding, if it's our client */
    if ((ConfigServerHide.hide_servers || IsHidden(source_p)) && MyConnect(target_p) &&
        !HasUMode(target_p, UMODE_OPER))
      sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
    else
      sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
  }
  else
    sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
                          numeric, chptr->name, parv[2]);
}

/* handle_command()
 *
 * inputs       - pointer to message block
 *              - pointer to client
 *              - pointer to client message is from
 *              - count of number of args
 *              - pointer to argv[] array
 * output       - -1 if error from server
 * side effects -
 */
static void
parse_handle_command(struct Message *message, struct Client *source_p,
                     unsigned int i, char *para[])
{
  if (IsServer(source_p->from))
    ++message->rcount;

  ++message->count;

  /* Check right amount of parameters is passed... --is */
  if (i < message->args_min)
    sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, message->cmd);
  else
    message->handlers[source_p->from->handler](source_p, i, para);
}

/*
 * parse a buffer.
 *
 * NOTE: parse() should not be called recusively by any other functions!
 */
void
parse(struct Client *client_p, char *pbuffer, char *bufend)
{
  struct Client *from = client_p;
  struct Message *message = NULL;
  char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
  char *ch = NULL;
  char *s = NULL;
  unsigned int numeric = 0;
  unsigned int parc = 0;
  unsigned int paramcount;

  if (IsDefunct(client_p))
    return;

  assert(client_p->connection->fd.flags.open);
  assert((bufend - pbuffer) < IRCD_BUFSIZE);

  for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
    ;

  if (*ch == ':')
  {
    /*
     * Copy the prefix to 'sender' assuming it terminates
     * with SPACE (or NULL, which is an error, though).
     */
    const char *const sender = ++ch;

    if ((s = strchr(ch, ' ')))
    {
      *s = '\0';
      ch = ++s;
    }

    if (*sender && IsServer(client_p))
    {
      if ((from = hash_find_id(sender)) == NULL)
        from = hash_find_client(sender);

      /*
       * Hmm! If the client corresponding to the prefix is not found--what is
       * the correct action??? Now, I will ignore the message (old IRC just
       * let it through as if the prefix just wasn't there...) --msa
       */
      if (from == NULL)
      {
        ++ServerStats.is_unpf;
        parse_remove_unknown(client_p, sender, pbuffer);
        return;
      }

      if (from->from != client_p)
      {
        ++ServerStats.is_wrdi;
        sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
                             "Fake direction: dropped message from %s[%s] via %s",
                             from->name, from->from->name,
                             get_client_name(client_p, SHOW_IP));
        sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
                             "Fake direction: dropped message from %s[%s] via %s",
                             from->name, from->from->name,
                             get_client_name(client_p, MASK_IP));
        return;
      }
    }

    while (*ch == ' ')
      ++ch;
  }

  if (*ch == '\0')
  {
    ++ServerStats.is_empt;
    return;
  }

  /*
   * Extract the command code from the packet. Point s to the end
   * of the command code and calculate the length using pointer
   * arithmetic. Note: only need length for numerics and *all*
   * numerics must have parameters and thus a space after the command
   * code. -avalon
   */

  /* EOB is 3 characters long but is not a numeric */
  if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
      IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
  {
    numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
    paramcount = 2;  /* Destination, and the rest of it */
    ++ServerStats.is_num;
    s = ch + 3;  /* I know this is ' ' from above if */
    *s++ = '\0';  /* Blow away the ' ', and point s to next part */
  }
  else
  {
    unsigned int length = 0;

    if ((s = strchr(ch, ' ')))
      *s++ = '\0';

    if ((message = find_command(ch)) == NULL)
    {
      /*
       * Note: Give error message *only* to recognized
       * persons. It's a nightmare situation to have
       * two programs sending "Unknown command"'s or
       * equivalent to each other at full blast....
       * If it has got to person state, it at least
       * seems to be well behaving. Perhaps this message
       * should never be generated, though...  --msa
       * Hm, when is the buffer empty -- if a command
       * code has been found ?? -Armin
       */
      if (*pbuffer)
        if (IsClient(from))
          sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);

      ++ServerStats.is_unco;
      return;
    }

    assert(message->cmd);

    paramcount = message->args_max;
    length = bufend - ((s) ? s : ch);
    message->bytes += length;
  }

  /*
   * Must the following loop really be so devious? On surface it
   * splits the message to parameters from blank spaces. But, if
   * paramcount has been reached, the rest of the message goes into
   * this last parameter (about same effect as ":" has...) --msa
   */

  /* Note initially true: s == NULL || *(s - 1) == '\0' !! */

  para[parc] = ch;

  if (message && (message->flags & MFLG_EXTRA))
  {
    /*
     * XXX: This will have to go away after the command handler rewrite
     */
    para[++parc] = message->extra;
  }

  if (s)
  {
    if (paramcount > MAXPARA)
      paramcount = MAXPARA;

    while (1)
    {
       while (*s == ' ')
         *s++ = '\0';

       if (*s == '\0')
         break;

       if (*s == ':')
       {
         /* The rest is single parameter--can include blanks also. */
         para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
         break;
       }

       para[++parc] = s;

       if (parc >= paramcount)
         break;

       while (*s && *s != ' ')
         ++s;
    }
  }

  para[++parc] = NULL;

  if (message)
    parse_handle_command(message, from, parc, para);
  else
    parse_handle_numeric(numeric, from, parc, para);
}

/* add_msg_element()
 *
 * inputs       - pointer to MessageTree
 *              - pointer to Message to add for given command
 *              - pointer to current portion of command being added
 * output       - NONE
 * side effects - recursively build the Message Tree ;-)
 */
/*
 * How this works.
 *
 * The code first checks to see if its reached the end of the command
 * If so, that struct MessageTree has a msg pointer updated and the links
 * count incremented, since a msg pointer is a reference.
 * Then the code descends recursively, building the trie.
 * If a pointer index inside the struct MessageTree is NULL a new
 * child struct MessageTree has to be allocated.
 * The links (reference count) is incremented as they are created
 * in the parent.
 */
static void
add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
                const char *cmd)
{
  struct MessageTree *ntree_p = NULL;

  if (*cmd == '\0')
  {
    mtree_p->msg = msg_p;
    mtree_p->links++;  /* Have msg pointer, so up ref count */
  }
  else
  {
    /*
     * *cmd & (MAXPTRLEN-1)
     * convert the char pointed to at *cmd from ASCII to an integer
     * between 0 and MAXPTRLEN.
     * Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
     */
    if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
    {
      ntree_p = MyCalloc(sizeof(struct MessageTree));
      mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;

      mtree_p->links++;  /* Have new pointer, so up ref count */
    }

    add_msg_element(ntree_p, msg_p, cmd + 1);
  }
}

/* del_msg_element()
 *
 * inputs       - Pointer to MessageTree to delete from
 *              - pointer to command name to delete
 * output       - NONE
 * side effects - recursively deletes a token from the Message Tree ;-)
 */
/*
 * How this works.
 *
 * Well, first off, the code recursively descends into the trie
 * until it finds the terminating letter of the command being removed.
 * Once it has done that, it marks the msg pointer as NULL then
 * reduces the reference count on that allocated struct MessageTree
 * since a command counts as a reference.
 *
 * Then it pops up the recurse stack. As it comes back up the recurse
 * The code checks to see if the child now has no pointers or msg
 * i.e. the links count has gone to zero. If it's no longer used, the
 * child struct MessageTree can be deleted. The parent reference
 * to this child is then removed and the parents link count goes down.
 * Thus, we continue to go back up removing all unused MessageTree(s)
 */
static void
del_msg_element(struct MessageTree *mtree_p, const char *cmd)
{
  struct MessageTree *ntree_p = NULL;

  /*
   * In case this is called for a nonexistent command
   * check that there is a msg pointer here, else links-- goes -ve
   * -db
   */
  if (*cmd == '\0' && mtree_p->msg)
  {
    mtree_p->msg = NULL;
    mtree_p->links--;
  }
  else
  {
    if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
    {
      del_msg_element(ntree_p, cmd + 1);

      if (ntree_p->links == 0)
      {
        mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
        mtree_p->links--;
        MyFree(ntree_p);
      }
    }
  }
}

/* msg_tree_parse()
 *
 * inputs       - Pointer to command to find
 *              - Pointer to MessageTree root
 * output       - Find given command returning Message * if found NULL if not
 * side effects - none
 */
static struct Message *
msg_tree_parse(const char *cmd)
{
  struct MessageTree *mtree = &msg_tree;

  assert(cmd && *cmd);

  while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
    if (*++cmd == '\0')
      return mtree->msg;

  return NULL;
}

/* mod_add_cmd()
 *
 * inputs       - pointer to struct Message
 * output       - none
 * side effects - load this one command name
 */
void
mod_add_cmd(struct Message *msg)
{
  assert(msg && msg->cmd);

  /* Command already added? */
  if (msg_tree_parse(msg->cmd))
    return;

  add_msg_element(&msg_tree, msg, msg->cmd);
}

/* mod_del_cmd()
 *
 * inputs       - pointer to struct Message
 * output       - none
 * side effects - unload this one command name
 */
void
mod_del_cmd(struct Message *msg)
{
  assert(msg && msg->cmd);

  if (!msg_tree_parse(msg->cmd))
    return;

  del_msg_element(&msg_tree, msg->cmd);
}

/* find_command()
 *
 * inputs       - command name
 * output       - pointer to struct Message
 * side effects - none
 */
struct Message *
find_command(const char *cmd)
{
  return msg_tree_parse(cmd);
}

static void
recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
{
  if (mtree->msg)
    sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
                       mtree->msg->cmd,
                       mtree->msg->count, mtree->msg->bytes,
                       mtree->msg->rcount);

  for (unsigned int i = 0; i < MAXPTRLEN; ++i)
    if (mtree->pointers[i])
      recurse_report_messages(source_p, mtree->pointers[i]);
}

/* report_messages()
 *
 * inputs       - pointer to client to report to
 * output       - NONE
 * side effects - client is shown list of commands
 */
void
report_messages(struct Client *source_p)
{
  const struct MessageTree *const mtree = &msg_tree;

  for (unsigned int i = 0; i < MAXPTRLEN; ++i)
    if (mtree->pointers[i])
      recurse_report_messages(source_p, mtree->pointers[i]);
}

/* m_not_oper()
 * inputs       -
 * output       -
 * side effects - just returns a nastyogram to given user
 */
int
m_not_oper(struct Client *source_p, int parc, char *parv[])
{
  sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
  return 0;
}

int
m_unregistered(struct Client *source_p, int parc, char *parv[])
{
  sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
  return 0;
}

int
m_registered(struct Client *source_p, int parc, char *parv[])
{
  sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
  return 0;
}

int
m_ignore(struct Client *source_p, int parc, char *parv[])
{
  return 0;
}
Revision:	4959
Committed:	Sun Nov 30 17:23:06 2014 UTC (10 years, 8 months ago) by michael
Content type:	text/x-csrc
File size:	18737 byte(s)
Log Message:	- parse.c:parse_handle_numeric(): removed extraneous parentheses
#	User	Rev	Content
1	adx	30	/*
2	michael	2916	* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3	adx	30	*
4	michael	2916	* Copyright (c) 1997-2014 ircd-hybrid development team
5	adx	30	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18	michael	4565	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19	adx	30	* USA
20			*/
21
22	michael	2916	/*! \file parse.c
23			* \brief The message parser.
24			* \version $Id$
25			*/
26
27	adx	30	#include "stdinc.h"
28	michael	1243	#include "client.h"
29	adx	30	#include "parse.h"
30			#include "channel.h"
31			#include "hash.h"
32			#include "irc_string.h"
33			#include "ircd.h"
34			#include "numeric.h"
35	michael	1309	#include "log.h"
36	adx	30	#include "send.h"
37	michael	1309	#include "conf.h"
38	adx	30	#include "memory.h"
39	michael	3347	#include "user.h"
40			#include "server.h"
41	adx	30
42	michael	2916
43	adx	30	/*
44			* (based on orabidoo's parser code)
45			*
46			* This has always just been a trie. Look at volume III of Knuth ACP
47			*
48			*
49			* ok, you start out with an array of pointers, each one corresponds
50			* to a letter at the current position in the command being examined.
51			*
52			* so roughly you have this for matching 'trie' or 'tie'
53			*
54			* 't' points -> [MessageTree ] 'r' -> [MessageTree ] -> 'i'
55			* -> [MessageTree ] -> [MessageTree ] -> 'e' and matches
56			*
57	michael	2916	* 'i' -> [MessageTree *] -> 'e' and matches
58	adx	30	*
59			* BUGS (Limitations!)
60	michael	2345	*
61	adx	30	* I designed this trie to parse ircd commands. Hence it currently
62			* casefolds. This is trivial to fix by increasing MAXPTRLEN.
63			* This trie also "folds" '{' etc. down. This means, the input to this
64			* trie must be alpha tokens only. This again, is a limitation that
65			* can be overcome by increasing MAXPTRLEN to include upper/lower case
66			* at the expense of more memory. At the extreme end, you could make
67			* MAXPTRLEN 128.
68			*
69			* This is also not a patricia trie. On short ircd tokens, this is
70	michael	2345	* not likely going to matter.
71	adx	30	*
72			* Diane Bruce (Dianora), June 6 2003
73			*/
74
75	michael	4231	/*
76			* Must be a power of 2, and larger than 26 [a-z]\|[A-Z]. It's used to allocate
77			* the set of pointers at each node of the tree.
78			* There are MAXPTRLEN pointers at each node. Obviously, there have to be more
79			* pointers than ASCII letters. 32 is a nice number since there is then no need
80			* to shift 'A'/'a' to base 0 index, at the expense of a few never used
81			* pointers.
82			* For a small parser like this, this is a good compromise and does
83			* make it somewhat faster. - Dianora
84			*/
85	michael	2182	#define MAXPTRLEN 32
86	adx	30
87	michael	4231
88			static struct MessageTree
89	adx	30	{
90	michael	2345	int links; /* Count of all pointers (including msg) at this node
91	michael	2182	* used as reference count for deletion of _this_ node.
92			*/
93	adx	30	struct Message *msg;
94			struct MessageTree *pointers[MAXPTRLEN];
95	michael	4231	} msg_tree;
96	adx	30
97
98	michael	4231	/* remove_unknown()
99			*
100			* inputs -
101			* output -
102			* side effects -
103			*/
104			static void
105	michael	4552	parse_remove_unknown(struct Client client_p, const char lsender, char *lbuffer)
106	michael	4231	{
107			/*
108			* Do kill if it came from a server because it means there is a ghost
109			* user on the other server which needs to be removed. -avalon
110			* Tell opers about this. -Taner
111			*/
112			/*
113			* '[0-9]something' is an ID (KILL/SQUIT depending on its length)
114			* 'nodots' is a nickname (KILL)
115			* 'no.dot.at.start' is a server (SQUIT)
116			*/
117			if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) \|\| strchr(lsender, '.'))
118			{
119			sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
120			"Unknown prefix (%s) from %s, Squitting %s",
121			lbuffer, get_client_name(client_p, SHOW_IP), lsender);
122			sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
123			"Unknown prefix (%s) from %s, Squitting %s",
124			lbuffer, client_p->name, lsender);
125			sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
126			me.id, lsender, lbuffer, client_p->name);
127			}
128			else
129			sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
130			me.id, lsender, me.name);
131			}
132	adx	30
133			/*
134	michael	4231	*
135			* parc number of arguments ('sender' counted as one!)
136			* parv[0] pointer to 'sender' (may point to empty string) (not used)
137			* parv[1]..parv[parc-1]
138			* pointers to additional parameters, this is a NULL
139			* terminated list (parv[parc] == NULL).
140			*
141			* WARNING
142			* Numerics are mostly error reports. If there is something
143			* wrong with the message, just DROP it! Don't even think of
144			* sending back a neat error message -- big danger of creating
145			* a ping pong error message...
146			*
147			* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
148			*
149			* Called when we get a numeric message from a remote _server_ and we are
150			* supposed to forward it somewhere. Note that we always ignore numerics sent
151			* to 'me' and simply drop the message if we can't handle with this properly:
152			* the savvy approach is NEVER generate an error in response to an... error :)
153			*/
154			static void
155			parse_handle_numeric(unsigned int numeric, struct Client source_p, int parc, char parv[])
156			{
157			struct Client *target_p = NULL;
158			struct Channel *chptr = NULL;
159
160			/*
161			* Avoid trash, we need it to come from a server and have a target
162			*/
163			if (parc < 2 \|\| !IsServer(source_p))
164			return;
165
166			/*
167			* Who should receive this message ? Will we do something with it ?
168			* Note that we use findUser functions, so the target can't be neither
169			* a server, nor a channel (?) nor a list of targets (?) .. u2.10
170			* should never generate numeric replies to non-users anyway
171			* Ahem... it can be a channel actually, csc bots use it :\ --Nem
172			*/
173			if (IsChanPrefix(*parv[1]))
174			chptr = hash_find_channel(parv[1]);
175			else
176			target_p = find_person(source_p, parv[1]);
177
178	michael	4959	if ((!target_p \|\| target_p->from == source_p->from) && !chptr)
179	michael	4231	return;
180
181			/*
182			* Remap low number numerics, not that I understand WHY.. --Nemesi
183			*/
184			/*
185			* Numerics below 100 talk about the current 'connection', you're not
186			* connected to a remote server so it doesn't make sense to send them
187			* remotely - but the information they contain may be useful, so we
188			* remap them up. Weird, but true. -- Isomer
189			*/
190			if (numeric < 100)
191			numeric += 100;
192
193			if (target_p)
194			{
195			/* Fake it for server hiding, if it's our client */
196			if ((ConfigServerHide.hide_servers \|\| IsHidden(source_p)) && MyConnect(target_p) &&
197			!HasUMode(target_p, UMODE_OPER))
198			sendto_one_numeric(target_p, &me, numeric\|SND_EXPLICIT, "%s", parv[2]);
199			else
200			sendto_one_numeric(target_p, source_p, numeric\|SND_EXPLICIT, "%s", parv[2]);
201			}
202			else
203			sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
204	michael	4618	numeric, chptr->name, parv[2]);
205	michael	4231	}
206
207			/* handle_command()
208			*
209			* inputs - pointer to message block
210			* - pointer to client
211			* - pointer to client message is from
212			* - count of number of args
213			* - pointer to argv[] array
214			* output - -1 if error from server
215			* side effects -
216			*/
217			static void
218	michael	4937	parse_handle_command(struct Message message, struct Client source_p,
219	michael	4231	unsigned int i, char *para[])
220			{
221			if (IsServer(source_p->from))
222	michael	4937	++message->rcount;
223	michael	4231
224	michael	4937	++message->count;
225	michael	4231
226			/* Check right amount of parameters is passed... --is */
227	michael	4937	if (i < message->args_min)
228			sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, message->cmd);
229	michael	4231	else
230	michael	4937	message->handlers[source_p->from->handler](source_p, i, para);
231	michael	4231	}
232
233			/*
234	adx	30	* parse a buffer.
235			*
236			* NOTE: parse() should not be called recusively by any other functions!
237			*/
238			void
239			parse(struct Client client_p, char pbuffer, char *bufend)
240			{
241			struct Client *from = client_p;
242	michael	4937	struct Message *message = NULL;
243	michael	3638	char para[MAXPARA + 2]; / <command> + <parameters> + NULL */
244	michael	1246	char *ch = NULL;
245			char *s = NULL;
246	michael	3573	unsigned int numeric = 0;
247	michael	1178	unsigned int parc = 0;
248			unsigned int paramcount;
249	adx	30
250			if (IsDefunct(client_p))
251			return;
252
253	michael	4588	assert(client_p->connection->fd.flags.open);
254	michael	2786	assert((bufend - pbuffer) < IRCD_BUFSIZE);
255	adx	30
256	michael	3628	for (ch = pbuffer; ch == ' '; ++ch) / Skip spaces */
257			;
258	adx	30
259			if (*ch == ':')
260			{
261	michael	1178	/*
262			* Copy the prefix to 'sender' assuming it terminates
263	adx	30	* with SPACE (or NULL, which is an error, though).
264			*/
265	michael	4833	const char *const sender = ++ch;
266	adx	30
267	michael	3235	if ((s = strchr(ch, ' ')))
268	adx	30	{
269			*s = '\0';
270	michael	1178	ch = ++s;
271	adx	30	}
272
273			if (*sender && IsServer(client_p))
274			{
275	michael	4554	if ((from = hash_find_id(sender)) == NULL)
276			from = hash_find_client(sender);
277	adx	30
278	michael	2345	/*
279			* Hmm! If the client corresponding to the prefix is not found--what is
280			* the correct action??? Now, I will ignore the message (old IRC just
281			* let it through as if the prefix just wasn't there...) --msa
282	adx	30	*/
283			if (from == NULL)
284			{
285	michael	896	++ServerStats.is_unpf;
286	michael	4231	parse_remove_unknown(client_p, sender, pbuffer);
287	adx	30	return;
288			}
289
290			if (from->from != client_p)
291			{
292	michael	896	++ServerStats.is_wrdi;
293	michael	4926	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
294			"Fake direction: dropped message from %s[%s] via %s",
295			from->name, from->from->name,
296			get_client_name(client_p, SHOW_IP));
297			sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
298	michael	4928	"Fake direction: dropped message from %s[%s] via %s",
299	michael	4926	from->name, from->from->name,
300			get_client_name(client_p, MASK_IP));
301	adx	30	return;
302			}
303			}
304
305			while (*ch == ' ')
306	michael	1178	++ch;
307	adx	30	}
308
309			if (*ch == '\0')
310			{
311	michael	896	++ServerStats.is_empt;
312	adx	30	return;
313			}
314
315	michael	2345	/*
316			* Extract the command code from the packet. Point s to the end
317	adx	30	* of the command code and calculate the length using pointer
318	michael	2345	* arithmetic. Note: only need length for numerics and all
319	adx	30	* numerics must have parameters and thus a space after the command
320			* code. -avalon
321			*/
322
323	michael	3628	/* EOB is 3 characters long but is not a numeric */
324	michael	4298	if ((ch + 3) == ' ' && / Ok, let's see if it's a possible numeric */
325	adx	30	IsDigit(ch) && IsDigit((ch + 1)) && IsDigit(*(ch + 2)))
326			{
327	michael	3573	numeric = (ch - '0') 100 + ((ch + 1) - '0') 10 + (*(ch + 2) - '0');
328	michael	3628	paramcount = 2; /* Destination, and the rest of it */
329	michael	896	++ServerStats.is_num;
330	michael	3628	s = ch + 3; /* I know this is ' ' from above if */
331			s++ = '\0'; / Blow away the ' ', and point s to next part */
332	adx	30	}
333			else
334	michael	2345	{
335	michael	4760	unsigned int length = 0;
336	adx	30
337	michael	3235	if ((s = strchr(ch, ' ')))
338	adx	30	*s++ = '\0';
339
340	michael	4937	if ((message = find_command(ch)) == NULL)
341	adx	30	{
342	michael	2916	/*
343	michael	2345	* Note: Give error message only to recognized
344	adx	30	* persons. It's a nightmare situation to have
345			* two programs sending "Unknown command"'s or
346			* equivalent to each other at full blast....
347			* If it has got to person state, it at least
348			* seems to be well behaving. Perhaps this message
349			* should never be generated, though... --msa
350			* Hm, when is the buffer empty -- if a command
351			* code has been found ?? -Armin
352			*/
353	michael	3335	if (*pbuffer)
354	adx	30	if (IsClient(from))
355	michael	3109	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
356	adx	30
357	michael	896	++ServerStats.is_unco;
358	adx	30	return;
359			}
360
361	michael	4937	assert(message->cmd);
362	adx	30
363	michael	4937	paramcount = message->args_max;
364	michael	4760	length = bufend - ((s) ? s : ch);
365	michael	4937	message->bytes += length;
366	adx	30	}
367
368	michael	1178	/*
369			* Must the following loop really be so devious? On surface it
370			* splits the message to parameters from blank spaces. But, if
371			* paramcount has been reached, the rest of the message goes into
372			* this last parameter (about same effect as ":" has...) --msa
373			*/
374
375	michael	3250	/* Note initially true: s == NULL \|\| (s - 1) == '\0' !! /
376	michael	1178
377	michael	3096	para[parc] = ch;
378	michael	1178
379	michael	4937	if (message && (message->flags & MFLG_EXTRA))
380	michael	4545	{
381			/*
382			* XXX: This will have to go away after the command handler rewrite
383			*/
384	michael	4937	para[++parc] = message->extra;
385	michael	4545	}
386
387	michael	1178	if (s)
388	adx	30	{
389	michael	1178	if (paramcount > MAXPARA)
390			paramcount = MAXPARA;
391
392			while (1)
393			{
394			while (*s == ' ')
395			*s++ = '\0';
396
397			if (*s == '\0')
398			break;
399
400			if (*s == ':')
401			{
402	michael	4747	/* The rest is single parameter--can include blanks also. */
403	michael	3250	para[++parc] = s + (!numeric); /* Keep the colon if it's a numeric */
404	michael	1178	break;
405			}
406
407			para[++parc] = s;
408
409			if (parc >= paramcount)
410			break;
411
412			while (s && s != ' ')
413			++s;
414			}
415	adx	30	}
416
417	michael	1178	para[++parc] = NULL;
418
419	michael	4937	if (message)
420			parse_handle_command(message, from, parc, para);
421	adx	30	else
422	michael	4231	parse_handle_numeric(numeric, from, parc, para);
423	adx	30	}
424
425			/* add_msg_element()
426			*
427			* inputs - pointer to MessageTree
428			* - pointer to Message to add for given command
429			* - pointer to current portion of command being added
430			* output - NONE
431			* side effects - recursively build the Message Tree ;-)
432			*/
433			/*
434			* How this works.
435			*
436			* The code first checks to see if its reached the end of the command
437			* If so, that struct MessageTree has a msg pointer updated and the links
438			* count incremented, since a msg pointer is a reference.
439			* Then the code descends recursively, building the trie.
440			* If a pointer index inside the struct MessageTree is NULL a new
441			* child struct MessageTree has to be allocated.
442			* The links (reference count) is incremented as they are created
443			* in the parent.
444			*/
445			static void
446	michael	1570	add_msg_element(struct MessageTree mtree_p, struct Message msg_p,
447			const char *cmd)
448	adx	30	{
449	michael	3624	struct MessageTree *ntree_p = NULL;
450	adx	30
451			if (*cmd == '\0')
452			{
453			mtree_p->msg = msg_p;
454	michael	1570	mtree_p->links++; /* Have msg pointer, so up ref count */
455	adx	30	}
456			else
457			{
458	michael	2345	/*
459			* *cmd & (MAXPTRLEN-1)
460	adx	30	* convert the char pointed to at *cmd from ASCII to an integer
461			* between 0 and MAXPTRLEN.
462			* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
463			*/
464	michael	1013	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
465	adx	30	{
466	michael	3504	ntree_p = MyCalloc(sizeof(struct MessageTree));
467	michael	1013	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
468	adx	30
469	michael	1570	mtree_p->links++; /* Have new pointer, so up ref count */
470	adx	30	}
471	michael	896
472	michael	1013	add_msg_element(ntree_p, msg_p, cmd + 1);
473	adx	30	}
474			}
475
476			/* del_msg_element()
477			*
478			* inputs - Pointer to MessageTree to delete from
479			* - pointer to command name to delete
480			* output - NONE
481			* side effects - recursively deletes a token from the Message Tree ;-)
482			*/
483			/*
484			* How this works.
485			*
486			* Well, first off, the code recursively descends into the trie
487			* until it finds the terminating letter of the command being removed.
488			* Once it has done that, it marks the msg pointer as NULL then
489			* reduces the reference count on that allocated struct MessageTree
490			* since a command counts as a reference.
491			*
492			* Then it pops up the recurse stack. As it comes back up the recurse
493			* The code checks to see if the child now has no pointers or msg
494	michael	4298	* i.e. the links count has gone to zero. If it's no longer used, the
495	adx	30	* child struct MessageTree can be deleted. The parent reference
496			* to this child is then removed and the parents link count goes down.
497			* Thus, we continue to go back up removing all unused MessageTree(s)
498			*/
499			static void
500			del_msg_element(struct MessageTree mtree_p, const char cmd)
501			{
502	michael	3624	struct MessageTree *ntree_p = NULL;
503	adx	30
504	michael	1246	/*
505			* In case this is called for a nonexistent command
506	adx	30	* check that there is a msg pointer here, else links-- goes -ve
507			* -db
508			*/
509	michael	3235	if (*cmd == '\0' && mtree_p->msg)
510	adx	30	{
511			mtree_p->msg = NULL;
512			mtree_p->links--;
513			}
514			else
515			{
516	michael	3235	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
517	adx	30	{
518	michael	1013	del_msg_element(ntree_p, cmd + 1);
519	michael	896
520	adx	30	if (ntree_p->links == 0)
521			{
522	michael	1570	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
523			mtree_p->links--;
524			MyFree(ntree_p);
525	adx	30	}
526			}
527			}
528			}
529
530			/* msg_tree_parse()
531			*
532			* inputs - Pointer to command to find
533			* - Pointer to MessageTree root
534			* output - Find given command returning Message * if found NULL if not
535			* side effects - none
536			*/
537			static struct Message *
538	michael	1427	msg_tree_parse(const char *cmd)
539	adx	30	{
540	michael	1427	struct MessageTree *mtree = &msg_tree;
541	michael	3250
542	adx	30	assert(cmd && *cmd);
543
544	michael	522	while (IsAlpha(cmd) && (mtree = mtree->pointers[cmd & (MAXPTRLEN - 1)]))
545			if (*++cmd == '\0')
546			return mtree->msg;
547	adx	30
548	michael	522	return NULL;
549	adx	30	}
550
551			/* mod_add_cmd()
552			*
553			* inputs - pointer to struct Message
554			* output - none
555			* side effects - load this one command name
556			*/
557			void
558			mod_add_cmd(struct Message *msg)
559			{
560	michael	1246	assert(msg && msg->cmd);
561	adx	30
562	michael	3250	/* Command already added? */
563	michael	1427	if (msg_tree_parse(msg->cmd))
564	adx	30	return;
565
566			add_msg_element(&msg_tree, msg, msg->cmd);
567			}
568
569			/* mod_del_cmd()
570			*
571			* inputs - pointer to struct Message
572			* output - none
573			* side effects - unload this one command name
574			*/
575			void
576			mod_del_cmd(struct Message *msg)
577			{
578	michael	1246	assert(msg && msg->cmd);
579	adx	30
580	michael	3614	if (!msg_tree_parse(msg->cmd))
581			return;
582
583	adx	30	del_msg_element(&msg_tree, msg->cmd);
584			}
585
586			/* find_command()
587			*
588			* inputs - command name
589			* output - pointer to struct Message
590			* side effects - none
591			*/
592			struct Message *
593			find_command(const char *cmd)
594			{
595	michael	1427	return msg_tree_parse(cmd);
596	adx	30	}
597
598	michael	1246	static void
599			recurse_report_messages(struct Client source_p, const struct MessageTree mtree)
600			{
601	michael	3235	if (mtree->msg)
602	michael	3109	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
603			mtree->msg->cmd,
604			mtree->msg->count, mtree->msg->bytes,
605			mtree->msg->rcount);
606	michael	1246
607	michael	3235	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
608			if (mtree->pointers[i])
609	michael	1246	recurse_report_messages(source_p, mtree->pointers[i]);
610			}
611
612	adx	30	/* report_messages()
613			*
614			* inputs - pointer to client to report to
615			* output - NONE
616			* side effects - client is shown list of commands
617			*/
618			void
619			report_messages(struct Client *source_p)
620			{
621	michael	4833	const struct MessageTree *const mtree = &msg_tree;
622	adx	30
623	michael	3235	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
624			if (mtree->pointers[i])
625	adx	30	recurse_report_messages(source_p, mtree->pointers[i]);
626			}
627
628			/* m_not_oper()
629	michael	2345	* inputs -
630	adx	30	* output -
631			* side effects - just returns a nastyogram to given user
632			*/
633	michael	2820	int
634	michael	3156	m_not_oper(struct Client source_p, int parc, char parv[])
635	adx	30	{
636	michael	3109	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
637	michael	2820	return 0;
638	adx	30	}
639
640	michael	2820	int
641	michael	3156	m_unregistered(struct Client source_p, int parc, char parv[])
642	adx	30	{
643	michael	3109	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
644	michael	2820	return 0;
645	adx	30	}
646
647	michael	2820	int
648	michael	3156	m_registered(struct Client source_p, int parc, char parv[])
649	adx	30	{
650	michael	3109	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
651	michael	2820	return 0;
652	adx	30	}
653
654	michael	2820	int
655	michael	3156	m_ignore(struct Client source_p, int parc, char parv[])
656	adx	30	{
657	michael	2820	return 0;
658	adx	30	}