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., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  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
 */

#define MAXPTRLEN 32
                                /* Must be a power of 2, and
                                 * larger than 26 [a-z]|[A-Z]
                                 * its 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
                                 */

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];
};

static struct MessageTree msg_tree;

static void cancel_clients(struct Client *, struct Client *, char *);
static void remove_unknown(struct Client *, char *, char *);
static void handle_numeric(unsigned int, struct Client *, int, char *[]);
static void handle_command(struct Message *, struct Client *, unsigned int, char *[]);


/*
 * 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 *msg_ptr = 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->localClient->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).
     */
    char *sender = ++ch;

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

    if (*sender && IsServer(client_p))
    {
      if ((from = find_person(client_p, sender)) == NULL)
        from = hash_find_server(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;
        remove_unknown(client_p, sender, pbuffer);
        return;
      }

      if (from->from != client_p)
      {
        ++ServerStats.is_wrdi;
        cancel_clients(client_p, from, pbuffer);
        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, lets see if its 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 ii = 0;

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

    if ((msg_ptr = 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(msg_ptr->cmd);

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

  /*
   * 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 (s)
  {
    if (paramcount > MAXPARA)
      paramcount = MAXPARA;

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

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

       if (*s == ':')
       {
         /* The rest is a single parameter */
         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 (msg_ptr)
    handle_command(msg_ptr, from, parc, para);
  else
    handle_numeric(numeric, from, parc, para);
}

/* 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
handle_command(struct Message *mptr, struct Client *source_p,
               unsigned int i, char *para[])
{
  if (IsServer(source_p->from))
    ++mptr->rcount;

  ++mptr->count;

  /* Check right amount of parameters is passed... --is */
  if (i < mptr->args_min)
    sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
  else
    mptr->handlers[source_p->from->handler](source_p, i, 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 its 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 *mtree = &msg_tree;

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

/* cancel_clients()
 *
 * inputs       -
 * output       -
 * side effects -
 */
static void
cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
{
  if (IsServer(source_p) || IsMe(source_p))
  {
    sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
                         "Message for %s[%s] from %s",
                         source_p->name, source_p->from->name,
                         get_client_name(client_p, SHOW_IP));
    sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
                         "Message for %s[%s] from %s",
                         source_p->name, source_p->from->name,
                         get_client_name(client_p, MASK_IP));
    sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
                         "Not dropping server %s (%s) for Fake Direction",
                         client_p->name, source_p->name);
    return;
  }

  sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
                       "Message for %s[%s@%s!%s] from %s (TS, ignored)",
                       source_p->name, source_p->username, source_p->host,
                       source_p->from->name, get_client_name(client_p, SHOW_IP));
  sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
                       "Message for %s[%s@%s!%s] from %s (TS, ignored)",
                       source_p->name, source_p->username, source_p->host,
                       source_p->from->name, get_client_name(client_p, MASK_IP));
}

/* remove_unknown()
 *
 * inputs       -
 * output       -
 * side effects -
 */
static void
remove_unknown(struct Client *client_p, 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
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 && 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->chname, parv[2]);
}

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