/**
* Handle NOTICE commands
*
* @param source is the nick of the person whom sent the notice
* @param receiver is the nick whom it was sent to
* @param msg is the message that was sent
*
* @return always returns MOD_CONT
*/
int m_notice(char *source, char *receiver, char *msg)
{
char *temp = NULL;
char *version;
char *clean;
if (BadPtr(source) || BadPtr(receiver) || BadPtr(msg)) {
return MOD_CONT;
}
if (!stricmp(receiver, s_StatServ)
|| (s_StatServ_alias && !stricmp(receiver, s_StatServ_alias))) {
clean = normalizeBuffer(msg);
doCleanBuffer((char *) clean);
temp = myStrGetToken(clean, ' ', 0);
if (!temp) {
free(clean);
return MOD_CONT;
}
if (!stricmp(temp, "VERSION")) {
version = myStrGetTokenRemainder(clean, ' ', 1);
handle_ctcp_version(source, version);
free(version);
}
free(clean);
free(temp);
}
return MOD_CONT;
}
/*
* SVSLOGIN message
*
* parv[0]: source
* parv[1]: propagation mask
* parv[2]: target PUID
* parv[3]: ESVID
*/
static int m_svslogin(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
if (!SASL_SERVER || MyClient(sptr) || (parc < 3) || !parv[3])
return 0;
if (!stricmp(parv[1], me.name))
{
aClient *target_p;
/* is the PUID valid? */
if ((target_p = decode_puid(parv[2])) == NULL)
return 0;
if (target_p->user == NULL)
make_user(target_p);
strlcpy(target_p->user->svid, parv[3], sizeof(target_p->user->svid));
sendto_one(target_p, err_str(RPL_LOGGEDIN), me.name,
BadPtr(target_p->name) ? "*" : target_p->name,
BadPtr(target_p->name) ? "*" : target_p->name,
BadPtr(target_p->user->username) ? "*" : target_p->user->username,
BadPtr(target_p->user->realhost) ? "*" : target_p->user->realhost,
target_p->user->svid, target_p->user->svid);
return 0;
}
/* not for us; propagate. */
sendto_serv_butone_token(cptr, parv[0], MSG_SVSLOGIN, TOK_SVSLOGIN, "%s %s %s",
parv[1], parv[2], parv[3]);
return 0;
}
/*
* ms_links - server message handler
*
* parv[0] = sender prefix
* parv[1] = servername mask
*
* or
*
* parv[0] = sender prefix
* parv[1] = server to query
* parv[2] = servername mask
*/
int
ms_links(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
char *mask;
struct Client *acptr;
if (parc > 2)
{
if (hunt_server_cmd(sptr, CMD_LINKS, cptr, 1, "%C :%s", 1, parc, parv) !=
HUNTED_ISME)
return 0;
mask = parv[2];
}
else
mask = parc < 2 ? 0 : parv[1];
for (acptr = GlobalClientList, collapse(mask); acptr; acptr = cli_next(acptr))
{
if (!IsServer(acptr) && !IsMe(acptr))
continue;
if (!BadPtr(mask) && match(mask, cli_name(acptr)))
continue;
send_reply(sptr, RPL_LINKS, cli_name(acptr), cli_name(cli_serv(acptr)->up),
cli_hopcount(acptr), cli_serv(acptr)->prot,
((cli_info(acptr))[0] ? cli_info(acptr) : "(Unknown Location)"));
}
send_reply(sptr, RPL_ENDOFLINKS, BadPtr(mask) ? "*" : mask);
return 0;
}
void
parse_d_file(FBFILE * file)
{
struct ConfItem *aconf;
char *reason_field = (char *) NULL;
char *host_field = (char *) NULL;
char line[BUFSIZE];
char *p;
while (fbgets(line, sizeof(line), file))
{
if((p = strchr(line, '\n')))
*p = '\0';
if((*line == '\0') || (line[0] == '#'))
continue;
host_field = getfield(line);
if(BadPtr(host_field))
continue;
reason_field = getfield(NULL);
if(BadPtr(reason_field))
continue;
aconf = make_conf();
aconf->status = CONF_DLINE;
conf_add_fields(aconf, host_field, reason_field, "", 0, NULL);
conf_add_d_conf(aconf);
}
}
void
parse_resv_file(FBFILE * file)
{
char *reason_field;
char *host_field;
char line[BUFSIZE];
char *p;
while (fbgets(line, sizeof(line), file))
{
if((p = strchr(line, '\n')))
*p = '\0';
if((*line == '\0') || (line[0] == '#'))
continue;
host_field = getfield(line);
if(BadPtr(host_field))
continue;
reason_field = getfield(NULL);
if(BadPtr(reason_field))
continue;
if(IsChannelName(host_field))
create_resv(host_field, reason_field, RESV_CHANNEL);
else if(clean_resv_nick(host_field))
create_resv(host_field, reason_field, RESV_NICK);
}
}
inline char *
get_listener_name(aListener *lptr)
{
static char nbuf[HOSTLEN * 2 + USERLEN + 5];
ircsprintf(nbuf, "%s[@%s.%d][%s]", me.name, BadPtr(lptr->vhost_string) ?
"0.0.0.0" : lptr->vhost_string, lptr->port,
BadPtr(lptr->allow_string) ? "*" : lptr->allow_string);
return nbuf;
}
DLLFUNC CMD_FUNC(m_starttls)
{
if (!MyConnect(sptr) || !IsUnknown(sptr))
return 0;
#ifndef USE_SSL
/* sendnotice(sptr, "This server does not support SSL"); */
/* or numeric 691? */
/* actually... it's probably best to just act like we don't know this command...? */
sendto_one(sptr, err_str(ERR_NOTREGISTERED), me.name, "STARTTLS");
return 0;
#else
if (iConf.ssl_options & SSLFLAG_NOSTARTTLS)
{
sendto_one(sptr, err_str(ERR_NOTREGISTERED), me.name, "STARTTLS");
return 0;
}
if (IsSecure(sptr))
{
sendto_one(sptr, err_str(ERR_STARTTLS), me.name, !BadPtr(sptr->name) ? sptr->name : "*", "STARTTLS failed. Already using TLS.");
return 0;
}
dbuf_delete(&sptr->recvQ, 1000000); /* Clear up any remaining plaintext commands */
sendto_one(sptr, rpl_str(RPL_STARTTLS), me.name, !BadPtr(sptr->name) ? sptr->name : "*");
send_queued(sptr);
SetSSLStartTLSHandshake(sptr);
Debug((DEBUG_DEBUG, "Starting SSL handshake (due to STARTTLS) for %s", sptr->sockhost));
if ((sptr->ssl = SSL_new(ctx_server)) == NULL)
goto fail;
sptr->flags |= FLAGS_SSL;
SSL_set_fd(sptr->ssl, sptr->fd);
SSL_set_nonblocking(sptr->ssl);
if (!ircd_SSL_accept(sptr, sptr->fd)) {
Debug((DEBUG_DEBUG, "Failed SSL accept handshake in instance 1: %s", sptr->sockhost));
SSL_set_shutdown(sptr->ssl, SSL_RECEIVED_SHUTDOWN);
SSL_smart_shutdown(sptr->ssl);
SSL_free(sptr->ssl);
goto fail;
}
/* HANDSHAKE IN PROGRESS */
return 0;
fail:
/* Failure */
sendto_one(sptr, err_str(ERR_STARTTLS), me.name, !BadPtr(sptr->name) ? sptr->name : "*", "STARTTLS failed");
sptr->ssl = NULL;
sptr->flags &= ~FLAGS_SSL;
SetUnknown(sptr);
return 0;
#endif
}
static int do_jumpserver_exit_client(aClient *sptr)
{
#ifdef USE_SSL
if (IsSecure(sptr) && jss->ssl_server)
sendto_one(sptr, rpl_str(RPL_REDIR), me.name,
BadPtr(sptr->name) ? "*" : sptr->name,
jss->ssl_server, jss->ssl_port);
else
#endif
sendto_one(sptr, rpl_str(RPL_REDIR), me.name,
BadPtr(sptr->name) ? "*" : sptr->name,
jss->server, jss->port);
return exit_client(sptr, sptr, sptr, jss->reason);
}
/*
* exit_banned_client()
*
* Sends an appropriate ban message and disconnects a client.
*/
int
exit_banned_client(aClient *cptr, int loc, char type, char *banmsg, int fast)
{
char rbuf[512];
char *target = "*";
char *reason = "<no reason specified>";
if (cptr->name[0])
target = cptr->name;
if (!BadPtr(banmsg))
reason = banmsg;
ircsnprintf(rbuf, sizeof(rbuf), "%c-banned: %s", type, reason);
if (!fast)
{
sendto_one(&me, cptr, "NOTICE %s :*** You are banned from %s", target,
loc ? me.name : Network_Name);
sendto_one(&me, cptr, "NOTICE %s :*** Reason: %s", target, reason);
sendto_one(&me, cptr, "NOTICE %s :*** Connection info: %s [%s]", target,
get_client_name(cptr, FALSE),
cipntoa(cptr));
sendto_one(&me, cptr, "NOTICE %s :*** Ban contact: %s", target,
loc ? Local_Kline_Address : Network_Kline_Address);
sendto_one(&me, cptr, "NOTICE %s :*** When contacting %s, please include "
"all of the information shown above", target, Network_Name);
sendto_one(&me, cptr, err_str(ERR_YOUREBANNEDCREEP), me.name, target, rbuf);
throttle_force(cipntoa(cptr));
}
return exit_client(cptr, cptr, &me, rbuf);
}
/*
** Get Channel block for i (and allocate a new channel
** block, if it didn't exists before).
*/
aChannel *get_channel(aClient *cptr, char *chname, int flag)
{
aChannel *chptr;
int len;
if (BadPtr(chname))
return NULL;
len = strlen(chname);
if (MyClient(cptr) && len > CHANNELLEN)
{
len = CHANNELLEN;
*(chname + CHANNELLEN) = '\0';
}
if ((chptr = find_channel(chname, (aChannel *)NULL)))
return (chptr);
if (flag == CREATE)
{
chptr = (aChannel *)MyMalloc(sizeof(aChannel) + len);
bzero((char *)chptr, sizeof(aChannel));
strncpyzt(chptr->chname, chname, len + 1);
if (channel)
channel->prevch = chptr;
chptr->topic = NULL;
chptr->topic_nick = NULL;
chptr->prevch = NULL;
chptr->nextch = channel;
chptr->creationtime = MyClient(cptr) ? TStime() : (TS)0;
channel = chptr;
(void)add_to_channel_hash_table(chname, chptr);
IRCstats.channels++;
RunHook2(HOOKTYPE_CHANNEL_CREATE, cptr, chptr);
}
return chptr;
}
/*
** mo_list
** parv[0] = sender prefix
** parv[1] = channel
*/
static void mo_list(struct Client *client_p,
struct Client *source_p,
int parc,
char *parv[])
{
/* If its a LazyLinks connection, let uplink handle the list
* even for opers!
*/
if( uplink && IsCapable( uplink, CAP_LL) )
{
if(parc < 2)
sendto_one( uplink, ":%s LIST", source_p->name );
else
sendto_one( uplink, ":%s LIST %s", source_p->name, parv[1] );
return;
}
/* If no arg, do all channels *whee*, else just one channel */
if (parc < 2 || BadPtr(parv[1]))
{
list_all_channels(source_p);
}
else
{
list_named_channel(source_p,parv[1]);
}
}
/*
** collapse a pattern string into minimal components.
** This particular version is "in place", so that it changes the pattern
** which is to be reduced to a "minimal" size.
*/
char *collapse(char *pattern)
{
char *s = pattern, *s1, *t;
if (BadPtr(pattern))
return pattern;
/*
* Collapse all \** into \*, \*[?]+\** into \*[?]+
*/
for (; *s; s++)
if (*s == '\\')
if (!*(s + 1))
break;
else
s++;
else if (*s == '*')
{
if (*(t = s1 = s + 1) == '*')
while (*t == '*')
t++;
else if (*t == '?')
for (t++, s1++; *t == '*' || *t == '?'; t++)
if (*t == '?')
*s1++ = *t;
while ((*s1++ = *t++))
;
}
return pattern;
}
/*
** m_whowas
** parv[0] = sender prefix
** parv[1] = nickname queried
*/
static void
m_whowas(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
static time_t last_used = 0L;
if(parc < 2 || BadPtr(parv[1]))
{
sendto_one(source_p, form_str(ERR_NONICKNAMEGIVEN), me.name, parv[0]);
return;
}
if((last_used + ConfigFileEntry.pace_wait_simple) > CurrentTime)
{
sendto_one(source_p, form_str(RPL_LOAD2HI),
me.name, source_p->name, "WHOWAS");
sendto_one(source_p, form_str(RPL_ENDOFWHOWAS), me.name, parv[0], parv[1]);
return;
}
else
{
last_used = CurrentTime;
}
whowas_do(client_p, source_p, parc, parv);
}
/*
* SASL message
*
* parv[0]: prefix
* parv[1]: distribution mask
* parv[2]: target PUID
* parv[3]: mode/state
* parv[4]: data
* parv[5]: out-of-bound data
*/
static int m_sasl(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
if (!SASL_SERVER || MyClient(sptr) || (parc < 4) || !parv[4])
return 0;
if (!stricmp(parv[1], me.name))
{
aClient *target_p;
/* is the PUID valid? */
if ((target_p = decode_puid(parv[2])) == NULL)
return 0;
if (target_p->user == NULL)
make_user(target_p);
/* reject if another SASL agent is answering */
if (*target_p->sasl_agent && stricmp(parv[0], target_p->sasl_agent))
return 0;
else
strlcpy(target_p->sasl_agent, parv[0], sizeof(target_p->sasl_agent));
if (*parv[3] == 'C')
sendto_one(target_p, "AUTHENTICATE %s", parv[4]);
else if (*parv[3] == 'D')
{
if (*parv[4] == 'F')
sendto_one(target_p, err_str(ERR_SASLFAIL), me.name, BadPtr(target_p->name) ? "*" : target_p->name);
else if (*parv[4] == 'S')
{
target_p->sasl_complete++;
sendto_one(target_p, err_str(RPL_SASLSUCCESS), me.name, BadPtr(target_p->name) ? "*" : target_p->name);
}
*target_p->sasl_agent = '\0';
}
return 0;
}
/* not for us; propagate. */
sendto_serv_butone_token(cptr, parv[0], MSG_SASL, TOK_SASL, "%s %s %c %s %s",
parv[1], parv[2], *parv[3], parv[4], parc > 5 ? parv[5] : "");
return 0;
}
/*
* m_quit - client message handler
*
* parv[0] = sender prefix
* parv[parc - 1] = comment
*/
int m_quit(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
char *quitnocolour = 0;
int quittype = 0;
int ret = 0;
assert(0 != cptr);
assert(0 != sptr);
assert(cptr == sptr);
ret = find_fline(cptr, sptr, parv[parc-1], WFFLAG_QUIT, parv[1]);
if (ret != 0) {
if (ret == 2)
return CPTR_KILLED;
else
parv[parc - 1] = "";
}
if (cli_user(sptr)) {
struct Membership* chan;
for (chan = cli_user(sptr)->channel; chan; chan = chan->next_channel) {
if (!IsZombie(chan) && !member_can_send_to_channel(chan))
quittype |= 1;
if (chan->channel->mode.mode & MODE_NOQUITPARTS)
quittype |= 2;
if (parc > 1 && !BadPtr(parv[parc - 1]) && HasColour(parv[parc - 1])) {
if (chan->channel->mode.mode & MODE_NOCOLOUR)
quittype |= 2;
else if (chan->channel->mode.mode & MODE_STRIP)
quittype |= 4;
}
}
}
if (parc > 1 && !BadPtr(parv[parc - 1])) {
if (quittype & 1)
return exit_client(cptr, sptr, sptr, "Signed off");
else if (quittype & 2)
return exit_client(cptr, sptr, sptr, "Quit");
else if (quittype & 4 ) {
if (!quitnocolour) quitnocolour = (char*)StripColour(parv[parc - 1]);
return exit_client_msg(cptr, sptr, sptr, "Quit: %s", quitnocolour);
} else
return exit_client_msg(cptr, sptr, sptr, "Quit: %s", parv[parc - 1]);
} else
return exit_client(cptr, sptr, sptr, "Quit");
}
/** Handle a JOIN message from a client connection.
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int m_join(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct JoinBuf join;
struct JoinBuf create;
char *p = 0;
char *chanlist;
char *name;
char *keys;
if (parc < 2 || *parv[1] == '\0')
return need_more_params(sptr, "JOIN");
if (!IsAnOper(sptr) && IsRestrictJoin(sptr)) {
send_reply(sptr, ERR_BANNEDFROMCHAN, parv[1]);
return 0;
}
joinbuf_init(&join, sptr, cptr, JOINBUF_TYPE_JOIN, 0, 0);
joinbuf_init(&create, sptr, cptr, JOINBUF_TYPE_CREATE, 0, TStime());
chanlist = last0(cptr, sptr, parv[1]); /* find last "JOIN 0" */
keys = parv[2]; /* remember where keys are */
for (name = ircd_strtok(&p, chanlist, ","); name;
name = ircd_strtok(&p, 0, ",")) {
char *key = 0;
/* If we have any more keys, take the first for this channel. */
if (!BadPtr(keys)
&& (keys = strchr(key = keys, ',')))
*keys++ = '\0';
/* Empty keys are the same as no keys. */
if (key && !key[0])
key = 0;
if (!IsChannelName(name) || !strIsIrcCh(name))
{
/* bad channel name */
send_reply(sptr, ERR_NOSUCHCHANNEL, name);
continue;
}
if (cli_user(sptr)->joined >= get_client_maxchans(sptr)
&& !HasPriv(sptr, PRIV_CHAN_LIMIT)) {
send_reply(sptr, ERR_TOOMANYCHANNELS, name);
break; /* no point processing the other channels */
}
do_join(cptr, sptr, &join, &create, name, key, 0);
}
joinbuf_flush(&join); /* must be first, if there's a JOIN 0 */
joinbuf_flush(&create);
return 0;
}
static int
whowas_do(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
struct Whowas *temp;
int cur = 0;
int max = -1, found = 0;
char *p, *nick;
if(parc < 2 || BadPtr(parv[1]))
{
sendto_one(source_p, form_str(ERR_NONICKNAMEGIVEN), me.name, parv[0]);
return 0;
}
if(parc > 2)
max = atoi(parv[2]);
if(parc > 3)
if(hunt_server(client_p, source_p, ":%s WHOWAS %s %s :%s", 3, parc, parv))
return 0;
if((p = strchr(parv[1], ',')))
*p = '\0';
nick = parv[1];
temp = WHOWASHASH[hash_whowas_name(nick)];
found = 0;
for (; temp; temp = temp->next)
{
if(!irccmp(nick, temp->name))
{
sendto_one(source_p, form_str(RPL_WHOWASUSER),
me.name, parv[0], temp->name,
temp->username,
(IsOperAdmin(source_p))? temp->hostname : temp->rhostname, temp->realname);
if(ConfigServerHide.hide_servers && !IsOper(source_p))
sendto_one(source_p, form_str(RPL_WHOISSERVER),
me.name, parv[0], temp->name,
ServerInfo.network_name, myctime(temp->logoff));
else
sendto_one(source_p, form_str(RPL_WHOISSERVER),
me.name, parv[0], temp->name,
temp->servername, myctime(temp->logoff));
cur++;
found++;
}
if(max > 0 && cur >= max)
break;
}
if(!found)
sendto_one(source_p, form_str(ERR_WASNOSUCHNICK), me.name, parv[0], nick);
sendto_one(source_p, form_str(RPL_ENDOFWHOWAS), me.name, parv[0], parv[1]);
return 0;
}
/**
* Handle PRIVMSG commands
*
* @param source is the nick of the person whom sent the privmsg
* @param receiver is the nick whom it was sent to
* @param msg is the message that was sent
*
* @return always returns MOD_CONT
*/
int m_privmsg(char *source, char *receiver, char *msg)
{
char *s;
User *u;
PrivMsg *p;
if (BadPtr(source) || BadPtr(receiver) || BadPtr(msg)) {
return MOD_CONT;
}
u = user_find(source);
if (!u) {
alog(LOG_NONEXISTANT, "%s: user record for %s not found", msg,
source);
denora_cmd_notice(receiver, source,
getstring(NULL, USER_RECORD_NOT_FOUND));
return MOD_CONT;
}
if (*receiver == '#') {
if (denora->do_sql && !LargeNet) {
if (stricmp(u->nick, s_StatServ)
|| stricmp(u->nick, s_StatServ_alias)) {
do_cstats(u, receiver, msg);
}
}
} else {
/* If a server is specified (nick@server format), make sure it matches
* us, and strip it off. */
s = strchr(receiver, '@');
if (s) {
*s++ = 0;
if (stricmp(s, ServerName) != 0)
return MOD_CONT;
}
p = findPrivMsg(receiver);
if (p) {
p->handler(u, msg);
SET_SEGV_LOCATION();
}
}
return MOD_CONT;
}
/*
** m_nospoof - allows clients to respond to no spoofing patch
** parv[0] = prefix
** parv[1] = code
*/
DLLFUNC int m_nospoof(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
#ifdef NOSPOOF
unsigned long result;
#endif
Debug((DEBUG_NOTICE, "NOSPOOF"));
#ifdef NOSPOOF
if (IsNotSpoof(cptr))
return 0;
if (IsRegistered(cptr))
return 0;
if (!*sptr->name)
return 0;
if (BadPtr(parv[1]))
goto temp;
result = strtoul(parv[1], NULL, 16);
/* Accept code in second parameter (ircserv) */
if (result != sptr->nospoof)
{
if (BadPtr(parv[2]))
goto temp;
result = strtoul(parv[2], NULL, 16);
if (result != sptr->nospoof)
goto temp;
}
sptr->nospoof = 0;
if (USE_BAN_VERSION && MyConnect(sptr))
sendto_one(sptr, ":IRC!IRC@%s PRIVMSG %s :\1VERSION\1",
me.name, sptr->name);
if (sptr->user && sptr->name[0])
return register_user(cptr, sptr, sptr->name,
sptr->user->username, NULL, NULL, NULL);
return 0;
temp:
/* Homer compatibility */
sendto_one(cptr, ":%X!nospoof@%s PRIVMSG %s :\1VERSION\1",
cptr->nospoof, me.name, cptr->name);
#endif
return 0;
}
/*
* 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 int
handle_command(struct Message *mptr, struct Client *client_p,
struct Client *from, int i, char *hpara[MAXPARA])
{
MessageHandler handler = 0;
if(IsServer(client_p))
mptr->rcount++;
mptr->count++;
/* New patch to avoid server flooding from unregistered connects
- Pie-Man 07/27/2000 */
if(!IsRegistered(client_p))
{
/* if its from a possible server connection
* ignore it.. more than likely its a header thats sneaked through
*/
if(IsAnyServer(client_p) && !(mptr->flags & MFLG_UNREG))
return (1);
}
handler = mptr->handlers[client_p->handler];
/* check right amount of params is passed... --is */
if(i < (int)mptr->parameters)
{
if(!IsServer(client_p))
{
sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
me.name, BadPtr(hpara[0]) ? "*" : hpara[0], mptr->cmd);
if(MyClient(client_p))
return (1);
else
return (-1);
}
sendto_realops_flags(UMODE_ALL, L_ALL,
"Dropping server %s due to (invalid) command '%s'"
"with only %d arguments (expecting %d).",
client_p->name, mptr->cmd, i, mptr->parameters);
ilog(L_CRIT, "Insufficient parameters (%d) for command '%s' from %s.",
i, mptr->cmd, client_p->name);
exit_client(client_p, client_p, client_p,
"Not enough arguments to server command.");
return (-1);
}
(*handler) (client_p, from, i, hpara);
return (1);
}
void alog(int type, const char *fmt, ...)
{
va_list args;
int errno_save = errno;
char str[BUFSIZE];
char *buf;
*str = '\0';
if (!fmt) {
return;
}
if ((type == LOG_DEBUG || type == LOG_EXTRADEBUG
|| type == LOG_NONEXISTANT) && !denora->debug) {
return;
}
if ((type == LOG_PROTOCOL) && !denora->protocoldebug) {
return;
}
if (type == LOG_SQLDEBUG && !denora->sqldebug) {
return;
}
if (LOG_EXTRADEBUG == type && denora->debug <= 1) {
return;
}
if ((type == LOG_DEBUGSOCK || type == LOG_ADNS)
&& !denora->socketdebug) {
return;
}
checkday();
va_start(args, fmt);
ircvsnprintf(str, sizeof(str), fmt, args);
va_end(args);
buf = log_gettimestamp();
if (!NoLogs && logfile) {
fprintf(logfile, "%s %s\n", buf, str);
}
if (denora->nofork) {
fprintf(stderr, "%s %s\n", buf, str);
}
if (!BadPtr(LogChannel) && denora->debug < 2 && findchan(LogChannel)) {
if (type == LOG_NORMAL || type == LOG_NONEXISTANT
|| type == LOG_ERROR) {
privmsg(s_StatServ, LogChannel, "%s", str);
}
}
errno = errno_save;
}
/*
** m_pong
** parv[0] = sender prefix
** parv[1] = origin
** parv[2] = destination
*/
DLLFUNC int m_pong(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
aClient *acptr;
char *origin, *destination;
#ifdef NOSPOOF
if (!IsRegistered(cptr))
return m_nospoof(cptr, sptr, parc, parv);
#endif
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(sptr, err_str(ERR_NOORIGIN), me.name, parv[0]);
return 0;
}
origin = parv[1];
destination = parv[2];
cptr->flags &= ~FLAGS_PINGSENT;
sptr->flags &= ~FLAGS_PINGSENT;
/* Remote pongs for clients? uhh... */
if (MyClient(sptr) || !IsRegistered(sptr))
destination = NULL;
if (!BadPtr(destination) && mycmp(destination, me.name) != 0)
{
if ((acptr = find_client(destination, NULL)) ||
(acptr = find_server_quick(destination)))
{
if (!IsServer(cptr) && !IsServer(acptr))
{
sendto_one(sptr, err_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return 0;
}
else
sendto_one(acptr, ":%s PONG %s %s",
parv[0], origin, destination);
}
else
{
sendto_one(sptr, err_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return 0;
}
}
#ifdef DEBUGMODE
else
Debug((DEBUG_NOTICE, "PONG: %s %s", origin,
destination ? destination : "*"));
#endif
return 0;
}
/*
* mr_nick()
*
* parv[0] = sender prefix
* parv[1] = nickname
*/
static void
mr_nick(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
struct Client *target_p;
char nick[NICKLEN];
char *s;
if(parc < 2 || BadPtr(parv[1]))
{
sendto_one(source_p, form_str(ERR_NONICKNAMEGIVEN),
me.name, BadPtr(parv[0]) ? "*" : parv[0]);
return;
}
/* Terminate the nick at the first ~ */
if((s = strchr(parv[1], '~')))
*s = '\0';
/* and if the first ~ was the first letter.. */
if(BadPtr(parv[1]))
{
sendto_one(source_p, form_str(ERR_ERRONEUSNICKNAME),
me.name, BadPtr(parv[0]) ? "*" : parv[0], parv[1]);
return;
}
/* copy the nick and terminate it */
strlcpy(nick, parv[1], sizeof(nick));
/* check the nickname is ok */
if(!clean_nick_name(nick))
{
sendto_one(source_p, form_str(ERR_ERRONEUSNICKNAME),
me.name, BadPtr(parv[0]) ? "*" : parv[0], parv[1]);
return;
}
/* check if the nick is resv'd */
if(find_nick_resv(nick))
{
sendto_one(source_p, form_str(ERR_ERRONEUSNICKNAME),
me.name, BadPtr(parv[0]) ? "*" : parv[0], nick);
return;
}
if((target_p = find_client(nick)) == NULL)
{
set_initial_nick(client_p, source_p, nick);
return;
}
else if(source_p == target_p)
{
strcpy(source_p->name, nick);
return;
}
else
{
sendto_one(source_p, form_str(ERR_NICKNAMEINUSE), me.name, "*", nick);
}
}
static void
stats_configured_links(struct Client* sptr, struct StatDesc* sd, int stat,
char* param)
{
static char null[] = "<NULL>";
struct ConfItem *tmp;
int mask;
unsigned int *p;
unsigned short int port;
char c, *host, *pass, *name;
mask = sd->sd_funcdata;
for (tmp = GlobalConfList; tmp; tmp = tmp->next) {
if ((tmp->status & mask)) {
for (p = &report_array[0][0]; *p; p += 3)
if (*p == tmp->status)
break;
if (!*p)
continue;
c = (char)*(p + 2);
host = BadPtr(tmp->host) ? null : tmp->host;
pass = BadPtr(tmp->passwd) ? null : tmp->passwd;
name = BadPtr(tmp->name) ? null : tmp->name;
port = tmp->port;
/*
* On K line the passwd contents can be
* displayed on STATS reply. -Vesa
*/
/* Special-case 'k' or 'K' lines as appropriate... -Kev */
if ((tmp->status & CONF_UWORLD))
send_reply(sptr, p[1], c, host, pass, name, port, get_conf_class(tmp));
else if ((tmp->status & (CONF_SERVER | CONF_HUB)))
send_reply(sptr, p[1], c, "*", name, port, get_conf_class(tmp));
else
send_reply(sptr, p[1], c, host, name, port, get_conf_class(tmp));
}
}
}
/* set_channel_mlock()
*
* inputs - client, source, channel, params
* output -
* side effects - channel mlock is changed / MLOCK is propagated
*/
void set_channel_mlock(aClient *cptr, aClient *sptr, aChannel *chptr, const char *newmlock, int propagate)
{
if (chptr->mode_lock)
MyFree(chptr->mode_lock);
chptr->mode_lock = (newmlock != NULL) ? strdup(newmlock) : NULL;
if (propagate)
{
sendto_server(cptr,0, 0, ":%s MLOCK %lu %s :%s",
cptr->name, chptr->creationtime, chptr->chname,
BadPtr(chptr->mode_lock) ? "" : chptr->mode_lock);
}
}
/*
* AUTHENTICATE message
*
* parv[0]: prefix
* parv[1]: data
*/
static int m_authenticate(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
aClient *agent_p = NULL;
/* Failing to use CAP REQ for sasl is a protocol violation. */
if (!SASL_SERVER || !MyConnect(sptr) || BadPtr(parv[1]) || !CHECKPROTO(sptr, PROTO_SASL))
return 0;
if (sptr->sasl_complete)
{
sendto_one(sptr, err_str(ERR_SASLALREADY), me.name, BadPtr(sptr->name) ? "*" : sptr->name);
return 0;
}
if ((parv[1][0] == ':') || strchr(parv[1], ' '))
{
sendto_one(sptr, err_str(ERR_CANNOTDOCOMMAND), me.name, "*", "AUTHENTICATE", "Invalid parameter");
return 0;
}
if (strlen(parv[1]) > 400)
{
sendto_one(sptr, err_str(ERR_SASLTOOLONG), me.name, BadPtr(sptr->name) ? "*" : sptr->name);
return 0;
}
if (*sptr->sasl_agent)
agent_p = find_client(sptr->sasl_agent, NULL);
if (agent_p == NULL)
sendto_serv_butone_token(NULL, me.name, MSG_SASL, TOK_SASL, "%s %s S %s",
SASL_SERVER, encode_puid(sptr), parv[1]);
else
sendto_serv_butone_token(NULL, me.name, MSG_SASL, TOK_SASL, "%s %s C %s", AGENT_SID(agent_p), encode_puid(sptr), parv[1]);
sptr->sasl_out++;
return 0;
}
/*
* m_links - generic message handler
*
* parv[0] = sender prefix
* parv[1] = servername mask
*
* or
*
* parv[0] = sender prefix
* parv[1] = server to query
* parv[2] = servername mask
*/
int m_links(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
char *mask;
struct Client *acptr;
if (feature_bool(FEAT_HIS_LINKS) && !IsAnOper(sptr))
{
send_reply(sptr, RPL_ENDOFLINKS, parc < 2 ? "*" : parv[1]);
sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :%s %s", sptr,
"/LINKS has been disabled, from CFV-165. Visit ",
feature_str(FEAT_HIS_URLSERVERS));
return 0;
}
if (parc > 2)
{
if (hunt_server_cmd(sptr, CMD_LINKS, cptr, 1, "%C :%s", 1, parc, parv) !=
HUNTED_ISME)
return 0;
mask = parv[2];
}
else
mask = parc < 2 ? 0 : parv[1];
for (acptr = GlobalClientList, collapse(mask); acptr; acptr = cli_next(acptr))
{
if (!IsServer(acptr) && !IsMe(acptr))
continue;
if (!BadPtr(mask) && match(mask, cli_name(acptr)))
continue;
send_reply(sptr, RPL_LINKS, cli_name(acptr), cli_name(cli_serv(acptr)->up),
cli_hopcount(acptr), cli_serv(acptr)->prot,
((cli_info(acptr))[0] ? cli_info(acptr) : "(Unknown Location)"));
}
send_reply(sptr, RPL_ENDOFLINKS, BadPtr(mask) ? "*" : mask);
return 0;
}
void asuka_cmd_connect(void)
{
if (!BadPtr(Numeric)) {
inttobase64(p10id, atoi(Numeric), 2);
me_server =
do_server(NULL, ServerName, (char *) "0", ServerDesc, p10id);
asuka_cmd_pass(RemotePassword);
asuka_cmd_server(ServerName, 1, ServerDesc);
} else {
alog(LOG_NORMAL, "Numeric is required for P10 ircds");
exit(1);
}
}
static int crule_parsearglist(CRuleNodePtr argrootp, int *next_tokp, const char** ruleptr)
{
int errcode = CR_NOERR;
char *argelemp = NULL;
char currarg[CR_MAXARGLEN];
int arglen = 0;
char word[CR_MAXARGLEN];
int wordlen = 0;
argrootp->numargs = 0;
currarg[0] = '\0';
while (errcode == CR_NOERR)
{
switch (*next_tokp)
{
case CR_WORD:
crule_getword(word, &wordlen, CR_MAXARGLEN - 1, ruleptr);
if (currarg[0] != '\0')
{
if ((arglen + wordlen) < (CR_MAXARGLEN - 1))
{
strcat(currarg, " ");
strcat(currarg, word);
arglen += wordlen + 1;
}
}
else
{
strcpy(currarg, word);
arglen = wordlen;
}
errcode = crule_gettoken(next_tokp, ruleptr);
break;
default:
#if !defined(CR_DEBUG) && !defined(CR_CHKCONF)
collapse(currarg);
#endif
if (!BadPtr(currarg))
{
DupString(argelemp, currarg);
argrootp->arg[argrootp->numargs++] = (void *)argelemp;
}
if (*next_tokp != CR_COMMA)
return (CR_NOERR);
currarg[0] = '\0';
errcode = crule_gettoken(next_tokp, ruleptr);
break;
}
}
return (errcode);
}
void
parse_k_file(FBFILE * file)
{
struct ConfItem *aconf;
char *user_field = (char *) NULL;
char *reason_field = (char *) NULL;
char *host_field = (char *) NULL;
char line[BUFSIZE];
char *p;
while (fbgets(line, sizeof(line), file))
{
if((p = strchr(line, '\n')) != NULL)
*p = '\0';
if((*line == '\0') || (*line == '#'))
continue;
user_field = getfield(line);
if(BadPtr(user_field))
continue;
host_field = getfield(NULL);
if(BadPtr(host_field))
continue;
reason_field = getfield(NULL);
if(BadPtr(reason_field))
continue;
aconf = make_conf();
aconf->status = CONF_KILL;
conf_add_fields(aconf, host_field, reason_field, user_field, 0, NULL);
if(aconf->host != NULL)
add_conf_by_address(aconf->host, CONF_KILL, aconf->user, aconf);
}
}
