cql::cql_stream_id_t
cql::cql_client_pool_impl_t::execute(cql::cql_execute_t* message,
cql::cql_client_t::cql_message_callback_t callback,
cql::cql_client_t::cql_message_errback_t errback)
{
cql_client_t* client = next_client();
if (client) {
return client->execute(message, callback, errback);
}
return 0;
}
cql::cql_stream_id_t
cql::cql_client_pool_impl_t::prepare(const std::string& query,
cql::cql_client_t::cql_message_callback_t callback,
cql::cql_client_t::cql_message_errback_t errback)
{
cql_client_t* client = next_client();
if (client) {
return client->prepare(query, callback, errback);
}
return 0;
}
int handle_uevents(fd_set *rset)
{
struct client *citer;
if(lsock == -1) {
return -1;
}
if(FD_ISSET(lsock, rset)) {
/* got an incoming connection */
int s;
if((s = accept(lsock, 0, 0)) == -1) {
perror("error while accepting connection on the UNIX socket");
} else {
if(!add_client(CLIENT_UNIX, &s)) {
perror("failed to add client");
}
}
}
/* all the UNIX socket clients */
citer = first_client();
while(citer) {
struct client *c = citer;
citer = next_client();
if(get_client_type(c) == CLIENT_UNIX) {
int s = get_client_socket(c);
if(FD_ISSET(s, rset)) {
int rdbytes;
float sens;
/* got a request from a client, decode and execute it */
/* XXX currently only sensitivity comes from clients */
while((rdbytes = read(s, &sens, sizeof sens)) <= 0 && errno == EINTR);
if(rdbytes <= 0) { /* something went wrong... disconnect client */
close(get_client_socket(c));
remove_client(c);
continue;
}
set_client_sensitivity(c, sens);
}
}
}
return 0;
}
/*
* mo_squit (oper)
*
* parv[0] = sender prefix
* parv[1] = server name
* parv[2] = comment (optional)
*
*/
int mo_squit(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
const char* server;
struct Client *acptr;
struct Client *acptr2;
char *comment;
if (parc < 2)
return need_more_params(sptr, "SQUIT");
if (parc < 3 || BadPtr(parv[2]))
comment = cli_name(sptr);
else
comment = parv[2];
server = parv[1];
/*
* The following allows wild cards in SQUIT. Only useful
* when the command is issued by an oper.
*/
for (acptr = GlobalClientList; (acptr = next_client(acptr, server));
acptr = cli_next(acptr)) {
if (IsServer(acptr) || IsMe(acptr))
break;
}
/* Not found? Bugger. */
if (!acptr || IsMe(acptr))
return send_reply(sptr, ERR_NOSUCHSERVER, server);
/*
* Look for a matching server that is closer,
* that way we won't accidentally squit two close
* servers like davis.* and davis-r.* when typing
* /SQUIT davis*
*/
for (acptr2 = cli_serv(acptr)->up; acptr2 != &me;
acptr2 = cli_serv(acptr2)->up)
if (!match(server, cli_name(acptr2)))
acptr = acptr2;
/* Disallow local opers to squit remote servers */
if (IsLocOp(sptr) && !MyConnect(acptr))
return send_reply(sptr, ERR_NOPRIVILEGES);
return exit_client(cptr, acptr, sptr, comment);
}
static void dispatch_event(spnav_event *ev)
{
struct client *c, *citer;
static struct timeval prev_motion_time;
if(ev->type == EVENT_MOTION) {
struct timeval tv;
gettimeofday(&tv, 0);
ev->motion.period = msec_dif(tv, prev_motion_time);
prev_motion_time = tv;
}
citer = first_client();
while(citer) {
c = citer;
citer = next_client();
send_event(ev, c);
}
}
int main(int argc, char **argv)
{
int i, ret, become_daemon = 1;
for(i=1; i<argc; i++) {
if(argv[i][0] == '-' && argv[i][2] == 0) {
switch(argv[i][1]) {
case 'd':
become_daemon = !become_daemon;
break;
case 'v':
verbose = 1;
break;
case 'h':
printf("usage: %s [options]\n", argv[0]);
printf("options:\n");
printf(" -d\tdo not daemonize\n");
printf(" -v\tverbose output\n");
printf(" -h\tprint this usage information\n");
return 0;
default:
fprintf(stderr, "unrecognized argument: %s\n", argv[i]);
return 1;
}
} else {
fprintf(stderr, "unexpected argument: %s\n", argv[i]);
return 1;
}
}
if(become_daemon) {
daemonize();
}
write_pid_file();
puts("Spacenav daemon " VERSION);
read_cfg("/etc/spnavrc", &cfg);
if(init_clients() == -1) {
return 1;
}
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
signal(SIGSEGV, sig_handler);
signal(SIGHUP, sig_handler);
signal(SIGUSR1, sig_handler);
signal(SIGUSR2, sig_handler);
if(init_dev() == -1) {
init_hotplug();
}
init_unix();
#ifdef USE_X11
init_x11();
#endif
atexit(cleanup);
for(;;) {
fd_set rset;
int fd, max_fd = 0;
struct client *c;
FD_ZERO(&rset);
/* set the device fd if it's open, otherwise set the hotplug fd */
if((fd = get_dev_fd()) != -1 || (fd = get_hotplug_fd()) != -1) {
FD_SET(fd, &rset);
if(fd > max_fd) max_fd = fd;
}
/* the UNIX domain socket listening for connections */
if((fd = get_unix_socket()) != -1) {
FD_SET(fd, &rset);
if(fd > max_fd) max_fd = fd;
}
/* all the UNIX socket clients */
c = first_client();
while(c) {
if(get_client_type(c) == CLIENT_UNIX) {
int s = get_client_socket(c);
assert(s >= 0);
FD_SET(s, &rset);
if(s > max_fd) max_fd = s;
}
c = next_client();
}
/* and the X server socket */
#ifdef USE_X11
if((fd = get_x11_socket()) != -1) {
FD_SET(fd, &rset);
if(fd > max_fd) max_fd = fd;
}
#endif
do {
ret = select(max_fd + 1, &rset, 0, 0, 0);
} while(ret == -1 && errno == EINTR);
if(ret > 0) {
handle_events(&rset);
}
}
return 0; /* unreachable */
}
/*
* m_squit - SQUIT message handler
* parv[0] = sender prefix
* parv[1] = server name
* parv[2] = comment
*/
int m_squit(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct ConfItem* aconf;
char* server;
struct Client* acptr;
char *comment = (parc > 2 && parv[2]) ? parv[2] : cptr->name;
if (!(IsServer(sptr) || HasUmode(sptr,UMODE_REMOTE)))
{
if (SeesOperMessages(sptr))
sendto_one(sptr,":%s NOTICE %s :You have no R umode", me.name, parv[0]);
else
sendto_one(sptr, form_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (parc > 1)
{
server = parv[1];
/*
** To accomodate host masking, a squit for a masked server
** name is expanded if the incoming mask is the same as
** the server name for that link to the name of link.
*/
while ((*server == '*') && IsServer(cptr))
{
aconf = cptr->serv->nline;
if (!aconf)
break;
if (!irccmp(server, my_name_for_link(me.name, aconf)))
server = cptr->name;
break; /* WARNING is normal here */
/* NOTREACHED */
}
/*
** The following allows wild cards in SQUIT. Only useful
** when the command is issued by an oper.
*/
for (acptr = GlobalClientList; (acptr = next_client(acptr, server));
acptr = acptr->next)
if (IsServer(acptr) || IsMe(acptr))
break;
if (acptr && IsMe(acptr))
{
acptr = cptr;
server = cptr->name;
}
}
else
{
/*
** This is actually protocol error. But, well, closing
** the link is very proper answer to that...
**
** Closing the client's connection probably wouldn't do much
** good.. any oper out there should know that the proper way
** to disconnect is /QUIT :)
**
** its still valid if its not a local client, its then
** a protocol error for sure -Dianora
*/
if(MyClient(sptr))
{
sendto_one(sptr, form_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "SQUIT");
return 0;
}
else
{
server = cptr->host;
acptr = cptr;
}
}
/*
** SQUIT semantics is tricky, be careful...
**
** The old (irc2.2PL1 and earlier) code just cleans away the
** server client from the links (because it is never true
** "cptr == acptr".
**
** This logic here works the same way until "SQUIT host" hits
** the server having the target "host" as local link. Then it
** will do a real cleanup spewing SQUIT's and QUIT's to all
** directions, also to the link from which the orinal SQUIT
** came, generating one unnecessary "SQUIT host" back to that
** link.
**
** One may think that this could be implemented like
** "hunt_server" (e.g. just pass on "SQUIT" without doing
** nothing until the server having the link as local is
** reached). Unfortunately this wouldn't work in the real life,
** because either target may be unreachable or may not comply
** with the request. In either case it would leave target in
** links--no command to clear it away. So, it's better just
** clean out while going forward, just to be sure.
**
** ...of course, even better cleanout would be to QUIT/SQUIT
** dependant users/servers already on the way out, but
** currently there is not enough information about remote
** clients to do this... --msa
*/
if (!acptr)
{
sendto_one(sptr, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], server);
return 0;
}
if (MyClient(sptr) && !HasUmode(sptr,UMODE_REMOTE) && !MyConnect(acptr))
{
sendto_one(sptr,":%s NOTICE %s :You have no R umode",me.name,parv[0]);
return 0;
}
/*
** Notify all opers, if my local link is remotely squitted
*/
if (MyConnect(acptr) && IsServer(cptr))
{
sendto_ops_flag(UMODE_AUSPEX,
"%s received SQUIT %s from %s (%s)",
me.name, server, get_client_name(sptr,FALSE), comment);
logprintf(L_TRACE, "SQUIT From %s : %s (%s)", parv[0], server, comment);
}
else if (MyConnect(acptr))
sendto_ops_flag(UMODE_SERVNOTICE, "Received SQUIT %s from %s (%s)",
acptr->name, get_client_name(sptr,FALSE), comment);
return exit_client(cptr, acptr, sptr, comment);
}
static
void do_trace(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
int i;
struct Client *acptr;
struct Client *acptr2;
const struct ConnectionClass* cl;
char* tname;
int doall;
int *link_s;
int *link_u;
int cnt = 0;
int wilds;
int dow;
if (parc < 2 || BadPtr(parv[1]))
{
/* just "TRACE" without parameters. Must be from local client */
parc = 1;
acptr = &me;
tname = cli_name(&me);
i = HUNTED_ISME;
}
else if (parc < 3 || BadPtr(parv[2]))
{
/* No target specified. Make one before propagating. */
parc = 2;
tname = parv[1];
if ((acptr = find_match_server(parv[1])) ||
((acptr = FindClient(parv[1])) && !MyUser(acptr)))
{
if (IsUser(acptr))
parv[2] = cli_name(cli_user(acptr)->server);
else
parv[2] = cli_name(acptr);
parc = 3;
parv[3] = 0;
if ((i = hunt_server_cmd(sptr, CMD_TRACE, cptr, IsServer(acptr),
"%s :%C", 2, parc, parv)) == HUNTED_NOSUCH)
return;
}
else
i = HUNTED_ISME;
} else {
/* Got "TRACE <tname> :<target>" */
parc = 3;
if (MyUser(sptr) || Protocol(cptr) < 10)
acptr = find_match_server(parv[2]);
else
acptr = FindNServer(parv[2]);
if ((i = hunt_server_cmd(sptr, CMD_TRACE, cptr, 0, "%s :%C", 2, parc,
parv)) == HUNTED_NOSUCH)
return;
tname = parv[1];
}
if (i == HUNTED_PASS) {
if (!acptr)
acptr = next_client(GlobalClientList, tname);
else
acptr = cli_from(acptr);
send_reply(sptr, RPL_TRACELINK,
version, debugmode, tname,
acptr ? cli_name(cli_from(acptr)) : "<No_match>");
return;
}
doall = (parv[1] && (parc > 1)) ? !match(tname, cli_name(&me)) : 1;
wilds = !parv[1] || strchr(tname, '*') || strchr(tname, '?');
dow = wilds || doall;
/* Don't give (long) remote listings to lusers */
if (dow && !MyConnect(sptr) && !IsAnOper(sptr)) {
send_reply(sptr, RPL_TRACEEND);
return;
}
link_s = MyCalloc(2 * maxconnections, sizeof(link_s[0]));
link_u = link_s + maxconnections;
if (doall) {
for (acptr = GlobalClientList; acptr; acptr = cli_next(acptr)) {
if (IsUser(acptr))
link_u[cli_fd(cli_from(acptr))]++;
else if (IsServer(acptr))
link_s[cli_fd(cli_from(acptr))]++;
}
}
/* report all direct connections */
for (i = 0; i <= HighestFd; i++) {
const char *conClass;
if (!(acptr = LocalClientArray[i])) /* Local Connection? */
continue;
if (IsInvisible(acptr) && dow && !(MyConnect(sptr) && IsOper(sptr)) &&
!IsAnOper(acptr) && (acptr != sptr))
continue;
if (!doall && wilds && match(tname, cli_name(acptr)))
continue;
if (!dow && 0 != ircd_strcmp(tname, cli_name(acptr)))
continue;
conClass = get_client_class(acptr);
switch (cli_status(acptr)) {
case STAT_CONNECTING:
send_reply(sptr, RPL_TRACECONNECTING, conClass, cli_name(acptr));
cnt++;
break;
case STAT_HANDSHAKE:
send_reply(sptr, RPL_TRACEHANDSHAKE, conClass, cli_name(acptr));
cnt++;
break;
case STAT_ME:
break;
case STAT_UNKNOWN:
case STAT_UNKNOWN_USER:
send_reply(sptr, RPL_TRACEUNKNOWN, conClass,
get_client_name(acptr, HIDE_IP));
cnt++;
break;
case STAT_UNKNOWN_SERVER:
send_reply(sptr, RPL_TRACEUNKNOWN, conClass, "Unknown Server");
cnt++;
break;
case STAT_USER:
/* Only opers see users if there is a wildcard
but anyone can see all the opers. */
if ((IsAnOper(sptr) && (MyUser(sptr) ||
!(dow && IsInvisible(acptr)))) || !dow || IsAnOper(acptr)) {
if (IsAnOper(acptr))
send_reply(sptr, RPL_TRACEOPERATOR, conClass,
get_client_name(acptr, SHOW_IP),
CurrentTime - cli_lasttime(acptr));
else
send_reply(sptr, RPL_TRACEUSER, conClass,
get_client_name(acptr, SHOW_IP),
CurrentTime - cli_lasttime(acptr));
cnt++;
}
break;
/*
* Connection is a server
*
* Serv <class> <nS> <nC> <name> <ConnBy> <last> <age>
*
* class Class the server is in
* nS Number of servers reached via this link
* nC Number of clients reached via this link
* name Name of the server linked
* ConnBy Who established this link
* last Seconds since we got something from this link
* age Seconds this link has been alive
*
* Additional comments etc...... -Cym-<*****@*****.**>
*/
case STAT_SERVER:
if (cli_serv(acptr)->user) {
if (!cli_serv(acptr)->by[0]
|| !(acptr2 = findNUser(cli_serv(acptr)->by))
|| (cli_user(acptr2) != cli_serv(acptr)->user))
acptr2 = NULL;
send_reply(sptr, RPL_TRACESERVER, conClass, link_s[i],
link_u[i], cli_name(acptr),
acptr2 ? cli_name(acptr2) : "*",
cli_serv(acptr)->user->username,
cli_serv(acptr)->user->host,
CurrentTime - cli_lasttime(acptr),
CurrentTime - cli_serv(acptr)->timestamp);
} else
send_reply(sptr, RPL_TRACESERVER, conClass, link_s[i],
link_u[i], cli_name(acptr),
(*(cli_serv(acptr))->by) ? cli_serv(acptr)->by : "*", "*",
cli_name(&me), CurrentTime - cli_lasttime(acptr),
CurrentTime - cli_serv(acptr)->timestamp);
cnt++;
break;
default: /* We actually shouldn't come here, -msa */
send_reply(sptr, RPL_TRACENEWTYPE, get_client_name(acptr, HIDE_IP));
cnt++;
break;
}
}
/*
* Add these lines to summarize the above which can get rather long
* and messy when done remotely - Avalon
*/
if (IsAnOper(sptr) && doall) {
for (cl = get_class_list(); cl; cl = cl->next) {
if (Links(cl) > 1)
send_reply(sptr, RPL_TRACECLASS, ConClass(cl), Links(cl) - 1);
}
}
send_reply(sptr, RPL_TRACEEND);
MyFree(link_s);
}
/*
** m_ltrace - LimitedTRACE... like m_trace() but doesn't return TRACEUSER, TRACEUNKNOWN, or TRACECLASS
** parv[0] = sender prefix
** parv[1] = servername
*/
int m_ltrace(struct Client *cptr,
struct Client *sptr,
int parc,
char *parv[])
{
int i;
struct Client *acptr = NULL;
char *tname;
int doall, link_s[MAXCONNECTIONS], link_u[MAXCONNECTIONS];
int cnt = 0, wilds, dow;
static time_t now;
if (check_registered(sptr))
return 0;
#ifdef SERVERHIDE
if (!IsAnOper(sptr))
return 0;
#endif
if (parc > 2)
if (hunt_server(cptr, sptr, ":%s LTRACE %s :%s",
2, parc, parv))
return 0;
if (parc > 1)
tname = parv[1];
else
tname = me.name;
switch (hunt_server(cptr, sptr, ":%s LTRACE :%s", 1, parc, parv))
{
case HUNTED_PASS: /* note: gets here only if parv[1] exists */
{
struct Client *ac2ptr;
ac2ptr = next_client(GlobalClientList, tname);
if (ac2ptr)
sendto_one(sptr, form_str(RPL_TRACELINK), me.name, parv[0],
ircd_version, debugmode, tname, ac2ptr->from->name);
else
sendto_one(sptr, form_str(RPL_TRACELINK), me.name, parv[0],
ircd_version, debugmode, tname, "ac2ptr_is_NULL!!");
return 0;
}
case HUNTED_ISME:
break;
default:
return 0;
}
if(MyClient(sptr))
sendto_realops_flags(FLAGS_SPY, "ltrace requested by %s (%s@%s) [%s]",
sptr->name, sptr->username, sptr->host,
sptr->user->server);
doall = (parv[1] && (parc > 1)) ? match(tname, me.name): TRUE;
wilds = !parv[1] || strchr(tname, '*') || strchr(tname, '?');
dow = wilds || doall;
if(!IsAnOper(sptr) || !dow) /* non-oper traces must be full nicks */
/* lets also do this for opers tracing nicks */
{
const char* name;
const char* ip;
int c_class;
acptr = hash_find_client(tname,(struct Client *)NULL);
if(!acptr || !IsPerson(acptr))
{
/* this should only be reached if the matching
target is this server */
sendto_one(sptr, form_str(RPL_ENDOFTRACE),me.name,
parv[0], tname);
return 0;
}
name = get_client_name(acptr, FALSE);
ip = inetntoa((char*) &acptr->ip);
c_class = get_client_class(acptr);
if (IsAnOper(acptr))
{
sendto_one(sptr, form_str(RPL_TRACEOPERATOR),
me.name, parv[0], c_class,
name,
IsAnOper(sptr)?ip:(IsIPHidden(acptr)?"255.255.255.255":ip),
now - acptr->lasttime,
(acptr->user)?(now - acptr->user->last):0);
}
sendto_one(sptr, form_str(RPL_ENDOFTRACE),me.name,
parv[0], tname);
return 0;
}
for (i = 0; i < MAXCONNECTIONS; i++)
link_s[i] = 0, link_u[i] = 0;
if (dow && LIFESUX && !IsOper(sptr))
{
sendto_one(sptr,form_str(RPL_LOAD2HI),me.name,parv[0]);
return 0;
}
/*
* Count up all the servers and clients in a downlink.
*/
if (doall) {
for (acptr = GlobalClientList; acptr; acptr = acptr->next) {
if (IsServer(acptr))
++link_s[acptr->from->fd];
}
}
/* report all direct connections */
now = time(NULL);
for (i = 0; i <= highest_fd; i++)
{
const char* name;
const char* ip;
int c_class;
if (!(acptr = local[i])) /* Local Connection? */
continue;
if (IsInvisible(acptr) && dow &&
!(MyConnect(sptr) && IsAnOper(sptr)) &&
!IsAnOper(acptr) && (acptr != sptr))
continue;
if (!doall && wilds && !match(tname, acptr->name))
continue;
if (!dow && irccmp(tname, acptr->name))
continue;
name = get_client_name(acptr, FALSE);
ip = inetntoa((const char*) &acptr->ip);
c_class = get_client_class(acptr);
switch(acptr->status)
{
case STAT_HANDSHAKE:
#ifdef HIDE_SERVERS_IPS
name=get_client_name(acptr, MASK_IP);
#endif
sendto_one(sptr, form_str(RPL_TRACEHANDSHAKE), me.name,
parv[0], c_class, name);
cnt++;
break;
case STAT_CONNECTING:
#ifdef HIDE_SERVERS_IPS
name=get_client_name(acptr, MASK_IP);
#endif
sendto_one(sptr, form_str(RPL_TRACECONNECTING), me.name,
parv[0], c_class, name);
cnt++;
break;
case STAT_ME:
break;
case STAT_CLIENT:
/* Well, most servers don't have a LOT of OPERs... let's show them too */
if ((IsAnOper(sptr) &&
(MyClient(sptr) || !(dow && IsInvisible(acptr))))
|| !dow || IsAnOper(acptr))
{
if (IsAnOper(acptr))
sendto_one(sptr,
form_str(RPL_TRACEOPERATOR),
me.name, parv[0], c_class,
name,
IsAnOper(sptr)?ip:(IsIPHidden(acptr)?"255.255.255.255":ip),
now - acptr->lasttime,
(acptr->user)?(now - acptr->user->last):0);
cnt++;
}
break;
case STAT_SERVER:
#if 0
if (acptr->serv->user)
sendto_one(sptr, form_str(RPL_TRACESERVER),
me.name, parv[0], c_class, link_s[i],
link_u[i], name, acptr->serv->by,
acptr->serv->user->username,
acptr->serv->user->host, now - acptr->lasttime);
else
#endif
#ifdef HIDE_SERVERS_IPS
name=get_client_name(acptr, MASK_IP);
#endif
sendto_one(sptr, form_str(RPL_TRACESERVER),
me.name, parv[0], c_class, link_s[i],
link_u[i], name, *(acptr->serv->by) ?
acptr->serv->by : "*", "*",
me.name, now - acptr->lasttime);
cnt++;
break;
default: /* ...we actually shouldn't come here... --msa */
sendto_one(sptr, form_str(RPL_TRACENEWTYPE), me.name,
parv[0], name);
cnt++;
break;
}
}
/*
* Add these lines to summarize the above which can get rather long
* and messy when done remotely - Avalon
*/
if (!IsAnOper(sptr) || !cnt)
{
if (cnt)
return 0;
/* let the user have some idea that its at the end of the
* trace
*/
sendto_one(sptr, form_str(RPL_TRACESERVER),
me.name, parv[0], 0, link_s[me.fd],
link_u[me.fd], me.name, "*", "*", me.name);
sendto_one(sptr, form_str(RPL_ENDOFTRACE),me.name,
parv[0],tname);
return 0;
}
sendto_one(sptr, form_str(RPL_ENDOFTRACE),me.name, parv[0],tname);
return 0;
}
/*
* Search and return as many people as matched by the wild 'nick'.
* returns the number of people found (or, obviously, 0, if none where
* found).
*/
static int do_wilds(struct Client* sptr, char *nick, int count, int parc)
{
struct Client *acptr; /* Current client we're considering */
struct User *user; /* the user portion of the client */
const char *name; /* the name of this client */
struct Membership* chan;
int invis; /* does +i apply? */
int member; /* Is this user on any channels? */
int showperson; /* Should we show this person? */
int found = 0 ; /* How many were found? */
/* Ech! This is hideous! */
for (acptr = GlobalClientList; (acptr = next_client(acptr, nick));
acptr = cli_next(acptr))
{
if (!IsRegistered(acptr))
continue;
if (IsServer(acptr))
continue;
/*
* I'm always last :-) and acptr->next == 0!!
*
* Isomer: Does this strike anyone else as being a horrible hideous
* hack?
*/
if (IsMe(acptr)) {
assert(!cli_next(acptr));
break;
}
/*
* 'Rules' established for sending a WHOIS reply:
*
* - if wildcards are being used don't send a reply if
* the querier isn't any common channels and the
* client in question is invisible.
*
* - only send replies about common or public channels
* the target user(s) are on;
*/
user = cli_user(acptr);
name = (!*(cli_name(acptr))) ? "?" : cli_name(acptr);
assert(user);
invis = (acptr != sptr) && IsInvisible(acptr);
member = (user && user->channel) ? 1 : 0;
showperson = !invis && !member;
/* Should we show this person now? */
if (showperson) {
found++;
do_whois(sptr, acptr, parc);
if (count+found>MAX_WHOIS_LINES)
return found;
continue;
}
/* Step through the channels this user is on */
for (chan = user->channel; chan; chan = chan->next_channel)
{
struct Channel *chptr = chan->channel;
/* If this is a public channel, show the person */
if (!invis && PubChannel(chptr)) {
showperson = 1;
break;
}
/* if this channel is +p and not +s, show them */
if (!invis && HiddenChannel(chptr) && !SecretChannel(chptr)) {
showperson = 1;
break;
}
member = find_channel_member(sptr, chptr) ? 1 : 0;
if (invis && !member)
continue;
/* If sptr isn't really on this channel, skip it */
if (IsZombie(chan))
continue;
/* Is this a common channel? */
if (member) {
showperson = 1;
break;
}
} /* of for (chan in channels) */
/* Don't show this person */
if (!showperson)
continue;
do_whois(sptr, acptr, parc);
found++;
if (count+found>MAX_WHOIS_LINES)
return found;
} /* of global client list */
return found;
}
void loop() {
next_sensor();
next_client();
}
