void checkServer(struct Client *sptr, struct Client *acptr)
{
char outbuf[BUFSIZE];
/* Header */
send_reply(sptr, RPL_DATASTR, " ");
send_reply(sptr, RPL_CHKHEAD, "server", acptr->cli_name);
send_reply(sptr, RPL_DATASTR, " ");
ircd_snprintf(0, outbuf, sizeof(outbuf), " Connected at:: %s (%Tu)", myctime(acptr->cli_serv->timestamp), acptr->cli_serv->timestamp);
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " Server name:: %s", acptr->cli_name);
send_reply(sptr, RPL_DATASTR, outbuf);
if (cli_sslclifp(acptr) && (strlen(cli_sslclifp(acptr)) > 0)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), "SSL Fingerprint:: %s", cli_sslclifp(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
ircd_snprintf(0, outbuf, sizeof(outbuf), " Numeric:: %s --> %d", NumServ(acptr), base64toint(acptr->cli_yxx));
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " Users:: %d / %d", (acptr == &me) ? UserStats.local_clients : cli_serv(acptr)->clients,
base64toint(cli_serv(acptr)->nn_capacity));
send_reply(sptr, RPL_DATASTR, outbuf);
if (IsBurst(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: Bursting");
else if (IsBurstAck(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: Awaiting EOB Ack");
else if (IsService(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: Network Service");
else if (IsHub(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: Network Hub");
ircd_snprintf(0, outbuf, sizeof(outbuf), " Class:: %s", get_client_class(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
if (feature_bool(FEAT_CHECK_EXTENDED)) {
int dlinkc = 0;
struct DLink* slink = NULL;
send_reply(sptr, RPL_DATASTR, " ");
send_reply(sptr, RPL_DATASTR, "Downlinks::");
for (slink = cli_serv(acptr)->down; slink; slink = slink->next) {
ircd_snprintf(0, outbuf, sizeof(outbuf), "[%d] - %s%s", ++dlinkc,
IsBurst(slink->value.cptr) ? "*" : IsBurstAck(slink->value.cptr) ? "!" : IsService(slink->value.cptr) ? "=" : IsHub(slink->value.cptr) ? "+" : " ",
cli_name(slink->value.cptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
if (!dlinkc)
send_reply(sptr, RPL_DATASTR, "<none>");
}
/* Send 'END OF CHECK' message */
send_reply(sptr, RPL_ENDOFCHECK, " ");
}
/** Find the first matching MOTD block for a user.
* If the user is remote, always use remote MOTD.
* Otherwise, if there is a hostmask- or class-based MOTD that matches
* the user, use it.
* Otherwise, use the local MOTD.
* @param[in] cptr Client to find MOTD for.
* @return Pointer to first matching MOTD for the client.
*/
static struct Motd *
motd_lookup(struct Client *cptr)
{
struct Motd *ptr;
char *c_class = NULL;
assert(0 != cptr);
if (!MyUser(cptr)) /* not my user, always return remote motd */
return MotdList.remote;
c_class = get_client_class(cptr);
assert(c_class != NULL);
/* check the motd blocks first */
for (ptr = MotdList.other; ptr; ptr = ptr->next)
{
if (ptr->type == MOTD_CLASS
&& !match(ptr->hostmask, c_class))
return ptr;
else if (ptr->type == MOTD_HOSTMASK
&& !match(ptr->hostmask, cli_sockhost(cptr)))
return ptr;
else if (ptr->type == MOTD_IPMASK
&& ipmask_check(&cli_ip(cptr), &ptr->address, ptr->addrbits))
return ptr;
else if (ptr->type == MOTD_COUNTRY
&& !match(ptr->hostmask, cli_countrycode(cptr)))
return ptr;
else if (ptr->type == MOTD_CONTINENT
&& !match(ptr->hostmask, cli_continentcode(cptr)))
return ptr;
}
return MotdList.local; /* Ok, return the default motd */
}
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);
}
void checkClient(struct Client *sptr, struct Client *acptr)
{
struct Channel *chptr;
struct Membership *lp;
char outbuf[BUFSIZE];
char *privs;
time_t nowr;
/* Header */
send_reply(sptr, RPL_DATASTR, " ");
send_reply(sptr, RPL_CHKHEAD, "user", acptr->cli_name);
send_reply(sptr, RPL_DATASTR, " ");
ircd_snprintf(0, outbuf, sizeof(outbuf), " Nick:: %s (%s%s)", acptr->cli_name, NumNick(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
if (MyUser(acptr))
{
ircd_snprintf(0, outbuf, sizeof(outbuf), " Signed on:: %s", myctime(acptr->cli_firsttime));
send_reply(sptr, RPL_DATASTR, outbuf);
}
ircd_snprintf(0, outbuf, sizeof(outbuf), " Timestamp:: %s (%d)", myctime(acptr->cli_lastnick), acptr->cli_lastnick);
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " User/Hostmask:: %s@%s (%s)", acptr->cli_user->username, acptr->cli_user->host,
ircd_ntoa((const char*) &(cli_ip(acptr))));
send_reply(sptr, RPL_DATASTR, outbuf);
if (((feature_int(FEAT_HOST_HIDING_STYLE) == 1) ? HasHiddenHost(acptr) : IsHiddenHost(acptr)) || IsSetHost(acptr))
{
ircd_snprintf(0, outbuf, sizeof(outbuf), " Real User/Host:: %s@%s", acptr->cli_user->realusername, acptr->cli_user->realhost);
send_reply(sptr, RPL_DATASTR, outbuf);
}
ircd_snprintf(0, outbuf, sizeof(outbuf), " Real Name:: %s%c", cli_info(acptr), COLOR_OFF);
send_reply(sptr, RPL_DATASTR, outbuf);
if (IsService(cli_user(acptr)->server)) {
if (acptr)
send_reply(sptr, RPL_DATASTR, " Status:: Network Service");
else if (IsAdmin(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: IRC Administrator (service)");
else if (IsAnOper(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: IRC Operator (service)");
else
send_reply(sptr, RPL_DATASTR, " Status:: Client (service)");
} else if (IsAdmin(acptr)) {
send_reply(sptr, RPL_DATASTR, " Status:: IRC Administrator");
} else if (IsAnOper(acptr)) {
send_reply(sptr, RPL_DATASTR, " Status:: IRC Operator");
} else {
send_reply(sptr, RPL_DATASTR, " Status:: Client");
}
if (MyUser(acptr)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " Class:: %s", get_client_class(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
privs = client_print_privs(acptr);
if (strlen(privs) > 1)
client_check_privs(acptr, sptr);
ircd_snprintf(0, outbuf, sizeof(outbuf), " Connected to:: %s", cli_name(acptr->cli_user->server));
send_reply(sptr, RPL_DATASTR, outbuf);
if (cli_version(acptr)) {
if (strlen(cli_version(acptr)) > 0) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " CTCP Version:: %s", cli_version(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
}
if (cli_user(acptr) && !EmptyString(cli_user(acptr)->swhois)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " SWHOIS:: %s", cli_user(acptr)->swhois);
send_reply(sptr, RPL_DATASTR, outbuf);
}
if (cli_webirc(acptr)) {
if (strlen(cli_webirc(acptr)) > 0) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " WebIRC:: %s", cli_webirc(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
}
if (cli_sslclifp(acptr) && (strlen(cli_sslclifp(acptr)) > 0)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), "SSL Fingerprint:: %s", cli_sslclifp(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
if (MyUser(acptr))
get_eflags(sptr, acptr);
/* +s (SERV_NOTICE) is not relayed to us from remote servers,
* so we cannot tell if a remote client has that mode set.
* And hacking it onto the end of the output of umode_str is EVIL BAD AND WRONG
* (and breaks if the user is +r) so we won't do that either.
*/
if (strlen(umode_str(acptr)) < 1)
strcpy(outbuf, " Umode(s):: <none>");
else
ircd_snprintf(0, outbuf, sizeof(outbuf), " Umode(s):: +%s", umode_str(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
if (acptr->cli_user->joined == 0)
send_reply(sptr, RPL_DATASTR, " Channel(s):: <none>");
else if (acptr->cli_user->joined > 50)
{
/* NB. As a sanity check, we DO NOT show the individual channels the
* client is on if it is on > 50 channels. This is to prevent the ircd
* barfing ala Uworld when someone does /quote check Q :).. (I shouldn't imagine
* an Oper would want to see every single channel 'x' client is on anyway if
* they are on *that* many).
*/
ircd_snprintf(0, outbuf, sizeof(outbuf), " Channel(s):: - (total: %u)", acptr->cli_user->joined);
send_reply(sptr, RPL_DATASTR, outbuf);
}
else
{
char chntext[BUFSIZE];
int len = strlen(" Channel(s):: ");
int mlen = strlen(me.cli_name) + len + strlen(sptr->cli_name);
*chntext = '\0';
strcpy(chntext, " Channel(s):: ");
for (lp = acptr->cli_user->channel; lp; lp = lp->next_channel) {
chptr = lp->channel;
if (len + strlen(chptr->chname) + mlen > BUFSIZE - 5) {
send_reply(sptr, RPL_DATASTR, chntext);
*chntext = '\0';
strcpy(chntext, " Channel(s):: ");
len = strlen(chntext);
}
if (IsDeaf(acptr))
*(chntext + len++) = '-';
if (is_chan_op(acptr, chptr))
*(chntext + len++) = '@';
if (is_half_op(acptr, chptr))
*(chntext + len++) = '%';
if (IsOper(sptr) && !ShowChannel(sptr,chptr))
*(chntext + len++) = '*';
if (IsZombie(lp))
*(chntext + len++) = '!';
if (len)
*(chntext + len) = '\0';
strcpy(chntext + len, chptr->chname);
len += strlen(chptr->chname);
strcat(chntext + len, " ");
len++;
}
if (chntext[0] != '\0')
send_reply(sptr, RPL_DATASTR, chntext);
}
/* If client processing command ISN'T target (or a registered
* Network Service), show idle time since the last time we
* parsed something.
*/
if (MyUser(acptr) && !(IsService(acptr) == -1) && !(strCasediff(acptr->cli_name, sptr->cli_name) == 0)) {
nowr = CurrentTime - acptr->cli_user->last;
ircd_snprintf(0, outbuf, sizeof(outbuf), " Idle for:: %d days, %02ld:%02ld:%02ld",
nowr / 86400, (nowr / 3600) % 24, (nowr / 60) % 60, nowr % 60);
send_reply(sptr, RPL_DATASTR, outbuf);
}
/* Away message (if applicable) */
if (acptr->cli_user->away) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " Away message:: %s", acptr->cli_user->away);
send_reply(sptr, RPL_DATASTR, outbuf);
}
/* If local user.. */
if (MyUser(acptr)) {
send_reply(sptr, RPL_DATASTR, " ");
ircd_snprintf(0, outbuf, sizeof(outbuf), " Ports:: %d -> %d (client -> server)",
cli_port(acptr), cli_listener(acptr)->port);
send_reply(sptr, RPL_DATASTR, outbuf);
if (feature_bool(FEAT_CHECK_EXTENDED)) {
/* Note: sendq = receiveq for a client (it makes sense really) */
ircd_snprintf(0, outbuf, sizeof(outbuf), " Data sent:: %u.%0.3u Kb (%u protocol messages)",
cli_receiveK(acptr), cli_receiveB(acptr), cli_receiveM(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " Data received:: %u.%0.3u Kb (%u protocol messages)",
cli_sendK(acptr), cli_sendB(acptr), cli_sendM(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " receiveQ size:: %d bytes (max. %d bytes)",
DBufLength(&(cli_recvQ(acptr))), feature_int(FEAT_CLIENT_FLOOD));
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " sendQ size:: %d bytes (max. %d bytes)",
DBufLength(&(cli_sendQ(acptr))), get_sendq(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
}
/* Send 'END OF CHECK' message */
send_reply(sptr, RPL_ENDOFCHECK, " ");
}
/*
** 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;
}