/*
* m_nick - message handler for local clients
* parv[0] = sender prefix
* parv[1] = nickname
*/
int m_nick(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Client* acptr;
char nick[NICKLEN + 2];
char* arg;
char* s;
assert(0 != cptr);
assert(cptr == sptr);
if (IsServerPort(cptr))
return exit_client(cptr, cptr, &me, "Use a different port");
if (*(cli_name(sptr)))
if ((*parv[0] != '\0') && shun_lookup(sptr, 0))
return 0;
if (parc < 2) {
send_reply(sptr, ERR_NONICKNAMEGIVEN);
return 0;
}
/*
* Don't let them send make us send back a really long string of
* garbage
*/
arg = parv[1];
if (strlen(arg) > IRCD_MIN(NICKLEN, feature_int(FEAT_NICKLEN)))
arg[IRCD_MIN(NICKLEN, feature_int(FEAT_NICKLEN))] = '\0';
if ((s = strchr(arg, '~')))
*s = '\0';
strcpy(nick, arg);
/*
* If do_nick_name() returns a null name then reject it.
*/
if (0 == do_nick_name(nick)) {
send_reply(sptr, ERR_ERRONEUSNICKNAME, arg);
return 0;
}
/*
* Check if this is a LOCAL user trying to use a reserved (Juped)
* nick, if so tell him that it's a nick in use...
*/
if (isNickJuped(nick)) {
send_reply(sptr, ERR_NICKNAMEINUSE, nick);
return 0; /* NICK message ignored */
}
if (!(acptr = SeekClient(nick))) {
/*
* No collisions, all clear...
*/
return set_nick_name(cptr, sptr, nick, parc, parv, 0);
}
if (IsServer(acptr)) {
send_reply(sptr, ERR_NICKNAMEINUSE, nick);
return 0; /* NICK message ignored */
}
/*
* If acptr == sptr, then we have a client doing a nick
* change between *equivalent* nicknames as far as server
* is concerned (user is changing the case of his/her
* nickname or somesuch)
*/
if (acptr == sptr) {
/*
* If acptr == sptr, then we have a client doing a nick
* change between *equivalent* nicknames as far as server
* is concerned (user is changing the case of his/her
* nickname or somesuch)
*/
if (0 != strcmp(cli_name(acptr), nick)) {
/*
* Allows change of case in his/her nick
*/
return set_nick_name(cptr, sptr, nick, parc, parv, 0);
}
/*
* This is just ':old NICK old' type thing.
* Just forget the whole thing here. There is
* no point forwarding it to anywhere,
* especially since servers prior to this
* version would treat it as nick collision.
*/
return 0;
}
/*
* Note: From this point forward it can be assumed that
* acptr != sptr (point to different client structures).
*/
assert(acptr != sptr);
/*
* If the older one is "non-person", the new entry is just
* allowed to overwrite it. Just silently drop non-person,
* and proceed with the nick. This should take care of the
* "dormant nick" way of generating collisions...
*
* XXX - hmmm can this happen after one is registered?
*
* Yes, client 1 connects to IRC and registers, client 2 connects and
* sends "NICK foo" but doesn't send anything more. client 1 now does
* /nick foo, they should succeed and client 2 gets disconnected with
* the message below.
*/
if (IsUnknown(acptr) && MyConnect(acptr)) {
ServerStats->is_ref++;
if (!find_except_conf(acptr, EFLAG_IPCHECK))
IPcheck_connect_fail(acptr, 0);
exit_client(cptr, acptr, &me, "Overridden by other sign on");
return set_nick_name(cptr, sptr, nick, parc, parv, 0);
}
/*
* NICK is coming from local client connection. Just
* send error reply and ignore the command.
*/
send_reply(sptr, ERR_NICKNAMEINUSE, nick);
return 0; /* NICK message ignored */
}
/** Parse a line of data from a user.
* NOTE: parse_*() should not be called recursively by any other
* functions!
* @param[in] cptr Client that sent the data.
* @param[in] buffer Start of input line.
* @param[in] bufend End of input line.
* @return 0 on success, -1 on parse error, or CPTR_KILLED if message
* handler returns it.
*/
int
parse_client(struct Client *cptr, char *buffer, char *bufend)
{
struct Client* from = cptr;
char* ch;
char* s;
int i;
int paramcount;
int isshun = 0;
int lagmin = -1;
int lagfactor = -1;
struct Message* mptr;
MessageHandler handler = 0;
Debug((DEBUG_DEBUG, "Client Parsing: %s", buffer));
if (IsDead(cptr))
return 0;
para[0] = cli_name(from);
for (ch = buffer; *ch == ' '; ch++); /* Eat leading spaces */
if (*ch == ':') /* Is any client doing this ? */
{
for (++ch; *ch && *ch != ' '; ++ch)
; /* Ignore sender prefix from client */
while (*ch == ' ')
ch++; /* Advance to command */
}
if (*ch == '\0')
{
ServerStats->is_empt++;
Debug((DEBUG_NOTICE, "Empty message from host %s:%s",
cli_name(cptr), cli_name(from)));
return (-1);
}
if ((s = strchr(ch, ' ')))
*s++ = '\0';
expire_shuns();
if (IsRegistered(cptr)) {
if (cli_user(cptr)->username && cli_user(cptr)->host) {
if (shun_lookup(cptr, 0))
isshun = 1;
}
}
if ((mptr = msg_tree_parse(ch, &msg_tree)) == 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 (buffer[0] != '\0' && !isshun)
{
if (IsUser(from))
send_reply(from, ERR_UNKNOWNCOMMAND, ch);
Debug((DEBUG_ERROR, "Unknown (%s) from %s",
ch, get_client_name(cptr, HIDE_IP)));
}
ServerStats->is_unco++;
return (-1);
}
if (isshun && !(mptr->flags & MFLG_NOSHUN))
return 0;
paramcount = mptr->parameters;
i = bufend - ((s) ? s : ch);
mptr->bytes += i;
lagmin = get_lag_min(cptr);
lagfactor = get_lag_factor(cptr);
if (lagmin < 0)
lagmin = 2;
if (lagfactor < 0)
lagfactor = 120;
if (((mptr->flags & MFLG_SLOW) || !IsAnOper(cptr)) && lagfactor > 0)
cli_since(cptr) += (lagmin + i / lagfactor);
/*
* Allow only 1 msg per 2 seconds
* (on average) to prevent dumping.
* to keep the response rate up,
* bursts of up to 5 msgs are allowed
* -SRB
*/
/*
* 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' !! */
if (mptr->flags & MFLG_EXTRA) {
/* This is a horrid kludge to avoid changing the command handler
* argument list. */
para[1] = (char*)mptr->extra;
i = 1;
} else {
i = 0;
}
if (s)
{
if (paramcount > MAXPARA)
paramcount = MAXPARA;
for (;;)
{
/*
* Never "FRANCE " again!! ;-) Clean
* out *all* blanks.. --msa
*/
while (*s == ' ')
*s++ = '\0';
if (*s == '\0')
break;
if (*s == ':')
{
/*
* The rest is single parameter--can
* include blanks also.
*/
para[++i] = s + 1;
break;
}
para[++i] = s;
if (i >= paramcount)
break;
for (; *s != ' ' && *s; s++);
}
}
para[++i] = NULL;
++mptr->count;
handler = mptr->handlers[cli_handler(cptr)];
assert(0 != handler);
if (!feature_bool(FEAT_IDLE_FROM_MSG) && IsUser(cptr) &&
handler != m_ping && handler != m_ignore)
cli_user(from)->last = CurrentTime;
return (*handler) (cptr, from, i, para);
}
