void check_requests( )
{
char buf[MAX_STRING_LENGTH];
char buf2[MAX_STRING_LENGTH];
int c;
#ifdef REQUESTS
if( read( REQ, buf, sizeof( buf ) ) > 0 )
{
close( REQ );
init_request_pipe( );
for( c = 0; c < MAX_STRING_LENGTH; c++ )
if( buf[c] == '\n' || buf[c] == '\r' )
{
buf[c] = '\0';
break;
}
sprintf( buf2, "REQUEST: %s", buf );
log_string( buf2 );
if( strcmp( buf, "who" ) == 0 )
do_who( NULL, "" );
else if( strcmp( buf, "webwho" ) == 0 )
do_who( NULL, "www" );
}
#endif
}
/*
** m_who
** parv[0] = sender prefix
** parv[1] = nickname mask list
** parv[2] = additional selection flag, only 'o' for now.
*/
int m_who(struct Client *cptr,
struct Client *sptr,
int parc,
char *parv[])
{
struct Client *acptr;
char *mask = parc > 1 ? parv[1] : NULL;
Link *lp;
struct Channel *chptr;
struct Channel *mychannel = NULL;
char *channame = NULL;
int oper = parc > 2 ? (*parv[2] == 'o' ): 0; /* Show OPERS only */
int member;
int maxmatches = 500;
mychannel = NullChn;
if (sptr->user)
if ((lp = sptr->user->channel))
mychannel = lp->value.chptr;
/*
** Following code is some ugly hacking to preserve the
** functions of the old implementation. (Also, people
** will complain when they try to use masks like "12tes*"
** and get people on channel 12 ;) --msa
*/
if (mask)
{
if (!strcmp(mask, "**"))
mask = NULL;
else if (*mask == (char) 0)
mask = NULL;
else
(void)collapse(mask);
}
if (!mask || (*mask == (char) 0))
{
if (!HasUmode(sptr,UMODE_USER_AUSPEX))
{
sendto_one(sptr, form_str(RPL_ENDOFWHO), me.name, parv[0],
EmptyString(mask) ? "*" : mask);
return 0;
}
}
else if ((*(mask+1) == (char) 0) && (*mask == '*'))
{
if (!mychannel)
{
sendto_one(sptr, form_str(RPL_ENDOFWHO), me.name, parv[0],
EmptyString(mask) ? "*" : mask);
return 0;
}
channame = mychannel->chname;
}
else
channame = mask;
if (IsChannelName(channame))
{
/*
* List all users on a given channel
*/
if (!oper || SeesOpers(sptr)) /* If you're doing an oper search, you need SeesOpers() */
{
chptr = hash_find_channel(channame, NULL);
if (chptr)
{
member = IsMember(sptr, chptr) || IsLogger(sptr, chptr) || HasUmode(sptr,UMODE_USER_AUSPEX);
if (member || !SecretChannel(chptr))
for (lp = chptr->members; lp; lp = lp->next)
{
if (oper && !HasUmode(lp->value.cptr,UMODE_OPER))
continue;
if (IsInvisible(lp->value.cptr) && !member)
continue;
do_who(sptr, lp->value.cptr, chptr, lp);
}
}
}
}
else if (mask &&
((acptr = find_client(mask, NULL)) != NULL) &&
IsPerson(acptr) && (!oper || (HasUmode(acptr,UMODE_OPER) && SeesOpers(sptr))))
{
int isinvis = 0;
struct Channel *ch2ptr = NULL;
isinvis = IsInvisible(acptr);
for (lp = acptr->user->channel; lp; lp = lp->next)
{
chptr = lp->value.chptr;
member = IsMember(sptr, chptr) || HasUmode(sptr,UMODE_USER_AUSPEX);
if (isinvis && !member)
continue;
if (member || (!isinvis && PubChannel(chptr)))
{
ch2ptr = chptr;
break;
}
}
do_who(sptr, acptr, ch2ptr, NULL);
}
else if (!oper || SeesOpers(sptr))
for (acptr = GlobalClientList; acptr; acptr = acptr->next)
{
struct Channel *ch2ptr = NULL;
int showperson, isinvis;
if (!IsPerson(acptr))
continue;
if (oper && !HasUmode(acptr,UMODE_OPER))
continue;
showperson = 0;
/*
* Show user if they are on the same channel, or not
* invisible and on a non secret channel (if any).
* Do this before brute force match on all relevant fields
* since these are less cpu intensive (I hope :-) and should
* provide better/more shortcuts - avalon
*/
isinvis = IsInvisible(acptr);
for (lp = acptr->user->channel; lp; lp = lp->next)
{
chptr = lp->value.chptr;
member = IsMember(sptr, chptr) || HasUmode(sptr, UMODE_USER_AUSPEX);
if (isinvis && !member)
continue;
if (member || (!isinvis && PubChannel(chptr)))
{
ch2ptr = chptr;
showperson = 1;
break;
}
if (HiddenChannel(chptr) && !SecretChannel(chptr) &&
!isinvis)
showperson = 1;
}
if (!acptr->user->channel && !isinvis)
showperson = 1;
if ((HasUmode(sptr,UMODE_USER_AUSPEX) || showperson) &&
(!mask ||
match(mask, acptr->name) ||
match(mask, acptr->username) ||
match(mask, acptr->host) ||
(HasUmode(sptr, UMODE_AUSPEX) && match(mask, acptr->user->server)) ||
match(mask, acptr->info)))
{
do_who(sptr, acptr, ch2ptr, NULL);
if (!HasUmode(sptr,UMODE_USER_AUSPEX) && !--maxmatches)
{
sendto_one(sptr, form_str(RPL_ENDOFWHO), me.name, parv[0],
EmptyString(mask) ? "*" : mask);
return 0;
}
}
}
sendto_one(sptr, form_str(RPL_ENDOFWHO), me.name, parv[0],
EmptyString(mask) ? "*" : mask);
return 0;
}
/*
* m_who - generic message handler
*
* parv[0] = sender prefix
* parv[1] = nickname mask list
* parv[2] = additional selection flag, only 'o' for now.
* and %flags to specify what fields to output
* plus a ,querytype if the t flag is specified
* so the final thing will be like o%tnchu,777
* parv[3] = _optional_ parameter that overrides parv[1]
* This can be used as "/quote who foo % :The Black Hacker
* to find me, parv[3] _can_ contain spaces !.
*/
int m_who(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
char *mask; /* The mask we are looking for */
char ch; /* Scratch char register */
struct Channel *chptr; /* Channel to show */
struct Client *acptr; /* Client to show */
int bitsel; /* Mask of selectors to apply */
int matchsel; /* Wich fields the match should apply on */
int counter; /* Query size counter,
initially used to count fields */
int commas; /* Does our mask contain any comma ?
If so is a list.. */
int fields; /* Mask of fields to show */
int isthere = 0; /* When this set the user is member of chptr */
char *nick; /* Single element extracted from
the mask list */
char *p; /* Scratch char pointer */
char *qrt; /* Pointer to the query type */
static char mymask[512]; /* To save the mask before corrupting it */
unsigned int who_marker; /* Used to mark clients we've touched */
/* Let's find where is our mask, and if actually contains something */
mask = ((parc > 1) ? parv[1] : 0);
if (parc > 3 && parv[3])
mask = parv[3];
if (mask && ((mask[0] == '\0') ||
(mask[1] == '\0' && ((mask[0] == '0') || (mask[0] == '*')))))
mask = 0;
/* Evaluate the flags now, we consider the second parameter
as "matchFlags%fieldsToInclude,querytype" */
bitsel = fields = counter = matchsel = 0;
qrt = 0;
if (parc > 2 && parv[2] && *parv[2])
{
p = parv[2];
while (((ch = *(p++))) && (ch != '%') && (ch != ','))
switch (ch)
{
case 'o':
case 'O':
bitsel |= WHOSELECT_OPER;
continue;
case 'x':
case 'X':
if (HasPriv(sptr, PRIV_WHOX))
{
log_write(LS_WHO, L_INFO, LOG_NOSNOTICE, "%#C WHO %s %s", sptr,
(BadPtr(parv[3]) ? parv[1] : parv[3]), parv[2]);
bitsel |= WHOSELECT_EXTRA;
}
continue;
case 'n':
case 'N':
matchsel |= WHO_FIELD_NIC;
continue;
case 'u':
case 'U':
matchsel |= WHO_FIELD_UID;
continue;
case 'h':
case 'H':
matchsel |= WHO_FIELD_HOS;
continue;
case 'i':
case 'I':
matchsel |= WHO_FIELD_NIP;
continue;
case 's':
case 'S':
matchsel |= WHO_FIELD_SER;
continue;
case 'r':
case 'R':
matchsel |= WHO_FIELD_REN;
continue;
case 'a':
case 'A':
matchsel |= WHO_FIELD_ACC;
continue;
}
if (ch == '%')
while ((ch = *p++) && (ch != ','))
{
counter++;
switch (ch)
{
case 'c':
case 'C':
fields |= WHO_FIELD_CHA;
break;
case 'd':
case 'D':
fields |= WHO_FIELD_DIS;
break;
case 'f':
case 'F':
fields |= WHO_FIELD_FLA;
break;
case 'h':
case 'H':
fields |= WHO_FIELD_HOS;
break;
case 'i':
case 'I':
fields |= WHO_FIELD_NIP;
break;
case 'l':
case 'L':
fields |= WHO_FIELD_IDL;
case 'n':
case 'N':
fields |= WHO_FIELD_NIC;
break;
case 'r':
case 'R':
fields |= WHO_FIELD_REN;
break;
case 's':
case 'S':
fields |= WHO_FIELD_SER;
break;
case 't':
case 'T':
fields |= WHO_FIELD_QTY;
break;
case 'u':
case 'U':
fields |= WHO_FIELD_UID;
break;
case 'a':
case 'A':
fields |= WHO_FIELD_ACC;
break;
default:
break;
}
};
if (ch)
qrt = p;
}
if (!matchsel)
matchsel = WHO_FIELD_DEF;
if (!fields)
counter = 7;
if (feature_bool(FEAT_HIS_WHO_SERVERNAME) && !IsAnOper(sptr))
matchsel &= ~WHO_FIELD_SER;
if (qrt && (fields & WHO_FIELD_QTY))
{
p = qrt;
if (!((*p > '9') || (*p < '0')))
p++;
if (!((*p > '9') || (*p < '0')))
p++;
if (!((*p > '9') || (*p < '0')))
p++;
*p = '\0';
}
else
qrt = 0;
/* I'd love to add also a check on the number of matches fields per time */
counter = (2048 / (counter + 4));
if (mask && (strlen(mask) > 510))
mask[510] = '\0';
who_marker = get_client_marker();
commas = (mask && strchr(mask, ','));
/* First treat mask as a list of plain nicks/channels */
if (mask)
{
strcpy(mymask, mask);
for (p = 0, nick = ircd_strtok(&p, mymask, ","); nick;
nick = ircd_strtok(&p, 0, ","))
{
if (IsChannelName(nick) && (chptr = FindChannel(nick)))
{
isthere = (find_channel_member(sptr, chptr) != 0);
if (isthere || SEE_CHANNEL(sptr, chptr, bitsel))
{
struct Membership* member;
for (member = chptr->members; member; member = member->next_member)
{
acptr = member->user;
if ((bitsel & WHOSELECT_OPER) && !SeeOper(sptr,acptr))
continue;
if ((acptr != sptr) && (member->status & CHFL_ZOMBIE))
continue;
if (!(isthere || (SEE_USER(sptr, acptr, bitsel))))
continue;
if (!Process(acptr)) /* This can't be moved before other checks */
continue;
if (!(isthere ||
(IsOper(sptr) && (bitsel & WHOSELECT_EXTRA) && HasPriv(sptr, PRIV_SEE_CHAN)) ||
(SHOW_MORE(sptr, counter))))
break;
do_who(sptr, acptr, chptr, fields, qrt);
}
}
}
else
{
if ((acptr = FindUser(nick)) &&
((!(bitsel & WHOSELECT_OPER)) || SeeOper(sptr,acptr)) &&
Process(acptr) && SHOW_MORE(sptr, counter))
{
do_who(sptr, acptr, 0, fields, qrt);
}
}
}
}
/* If we didn't have any comma in the mask treat it as a
real mask and try to match all relevant fields */
if (!(commas || (counter < 1)))
{
int minlen, cset;
static struct in_mask imask;
if (mask)
{
matchcomp(mymask, &minlen, &cset, mask);
if (matchcompIP(&imask, mask))
matchsel &= ~WHO_FIELD_NIP;
if ((minlen > NICKLEN) || !(cset & NTL_IRCNK))
matchsel &= ~WHO_FIELD_NIC;
if ((matchsel & WHO_FIELD_SER) &&
((minlen > HOSTLEN) || (!(cset & NTL_IRCHN))
|| (!markMatchexServer(mymask, minlen))))
matchsel &= ~WHO_FIELD_SER;
if ((minlen > USERLEN) || !(cset & NTL_IRCUI))
matchsel &= ~WHO_FIELD_UID;
if ((minlen > HOSTLEN) || !(cset & NTL_IRCHN))
matchsel &= ~WHO_FIELD_HOS;
}
/* First of all loop through the clients in common channels */
if ((!(counter < 1)) && matchsel) {
struct Membership* member;
struct Membership* chan;
for (chan = cli_user(sptr)->channel; chan; chan = chan->next_channel) {
chptr = chan->channel;
for (member = chptr->members; member; member = member->next_member)
{
acptr = member->user;
if (!(IsUser(acptr) && Process(acptr)))
continue; /* Now Process() is at the beginning, if we fail
we'll never have to show this acptr in this query */
if ((bitsel & WHOSELECT_OPER) && !SeeOper(sptr,acptr))
continue;
if ((mask) &&
((!(matchsel & WHO_FIELD_NIC))
|| matchexec(cli_name(acptr), mymask, minlen))
&& ((!(matchsel & WHO_FIELD_UID))
|| matchexec(cli_user(acptr)->username, mymask, minlen))
&& ((!(matchsel & WHO_FIELD_SER))
|| (!HasFlag(cli_user(acptr)->server, FLAG_MAP)))
&& ((!(matchsel & WHO_FIELD_HOS))
|| matchexec(cli_user(acptr)->host, mymask, minlen))
&& ((!(matchsel & WHO_FIELD_HOS))
|| !HasSetHost(acptr)
|| !HasHiddenHost(acptr)
|| !IsAnOper(sptr)
|| matchexec(cli_user(acptr)->realhost, mymask, minlen))
&& ((!(matchsel & WHO_FIELD_REN))
|| matchexec(cli_info(acptr), mymask, minlen))
&& ((!(matchsel & WHO_FIELD_NIP))
|| ((HasHiddenHost(acptr) || HasSetHost(acptr)) && !IsAnOper(sptr))
|| ((((cli_ip(acptr).s_addr & imask.mask.s_addr) !=
imask.bits.s_addr)) || (imask.fall
&& matchexec(ircd_ntoa((const char*) &(cli_ip(acptr))), mymask, minlen)))))
continue;
if (!SHOW_MORE(sptr, counter))
break;
do_who(sptr, acptr, chptr, fields, qrt);
}
}
}
/* Loop through all clients :-\, if we still have something to match to
and we can show more clients */
if ((!(counter < 1)) && matchsel)
for (acptr = cli_prev(&me); acptr; acptr = cli_prev(acptr))
{
if (!(IsUser(acptr) && Process(acptr)))
continue;
if ((bitsel & WHOSELECT_OPER) && !SeeOper(sptr,acptr))
continue;
if (!(SEE_USER(sptr, acptr, bitsel)))
continue;
if ((mask) &&
((!(matchsel & WHO_FIELD_NIC))
|| matchexec(cli_name(acptr), mymask, minlen))
&& ((!(matchsel & WHO_FIELD_UID))
|| matchexec(cli_user(acptr)->username, mymask, minlen))
&& ((!(matchsel & WHO_FIELD_SER))
|| (!HasFlag(cli_user(acptr)->server, FLAG_MAP)))
&& ((!(matchsel & WHO_FIELD_HOS))
|| matchexec(cli_user(acptr)->host, mymask, minlen))
&& ((!(matchsel & WHO_FIELD_HOS))
|| !HasSetHost(acptr)
|| !HasHiddenHost(acptr)
|| !IsAnOper(sptr)
|| matchexec(cli_user(acptr)->realhost, mymask, minlen))
&& ((!(matchsel & WHO_FIELD_REN))
|| matchexec(cli_info(acptr), mymask, minlen))
&& ((!(matchsel & WHO_FIELD_NIP))
|| (HasHiddenHost(acptr) && !IsAnOper(sptr))
|| ((((cli_ip(acptr).s_addr & imask.mask.s_addr) != imask.bits.s_addr))
|| (imask.fall
&& matchexec(ircd_ntoa((const char*) &(cli_ip(acptr))), mymask, minlen)))))
continue;
if (!SHOW_MORE(sptr, counter))
break;
do_who(sptr, acptr, 0, fields, qrt);
}
}
/* Make a clean mask suitable to be sent in the "end of" */
if (mask && (p = strchr(mask, ' ')))
*p = '\0';
send_reply(sptr, RPL_ENDOFWHO, BadPtr(mask) ? "*" : mask);
/* Notify the user if we decided that his query was too long */
if (counter < 0)
send_reply(sptr, ERR_QUERYTOOLONG, "WHO");
return 0;
}
