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, " ");
}
/*
* Envio un comando a otro servidor o usuario
*/
void sendcmdto_one(struct Client *to, struct Client *from, char *cmd, char *token, const char *pattern, ...)
{
va_list vl;
/* Evito que el mensaje vuelva al origen */
if(cli_from(from)==cli_from(to))
return;
#if !defined(NO_PROTOCOL9)
if (Protocol(cli_from(to)) > 9)
{
#endif
if (IsUser(from)) {
if(IsUser(to))
sprintf_irc(sendbuf, "%s%s %s %s%s ", NumNick(from), token, NumNick(to));
else
sprintf_irc(sendbuf, "%s%s %s %s ", NumNick(from), token, NumServ(to));
} else {
if(IsUser(to))
sprintf_irc(sendbuf, "%s %s %s%s ", NumServ(from), token, NumNick(to));
else
sprintf_irc(sendbuf, "%s %s %s ", NumServ(from), token, NumServ(to));
}
#if !defined(NO_PROTOCOL9)
} else
sprintf_irc(sendbuf, ":%s %s %s ", from->name, cmd, to->name);
#endif
if(!pattern || !*pattern)
sendbuf[strlen(sendbuf)-1]='\0';
else
{
va_start(vl, pattern);
vsprintf_irc(sendbuf + strlen(sendbuf), pattern, vl);
va_end(vl);
}
sendbufto_one(to);
}
static void
stats_servers_verbose(struct Client* sptr, struct StatDesc* sd, int stat,
char* param)
{
struct Client *acptr;
/* lowercase 'v' is for human-readable,
* uppercase 'V' is for machine-readable */
if (stat == 'v')
send_reply(sptr, SND_EXPLICIT | RPL_STATSVERBOSE,
"%-20s %-20s Flags Hops Numeric Lag RTT Up Down "
"Clients/Max Proto %-10s :Info", "Servername", "Uplink",
"LinkTS");
for (acptr = GlobalClientList; acptr; acptr = cli_next(acptr)) {
if (!IsServer(acptr) && !IsMe(acptr))
continue;
if (param && match(param, cli_name(acptr))) /* narrow search */
continue;
send_reply(sptr, SND_EXPLICIT | RPL_STATSVERBOSE, stat == 'v' ?
"%-20s %-20s %c%c%c%c %4i %s %-4i %5i %4i %4i %4i %5i %5i "
"P%-2i %Tu :%s" :
"%s %s %c%c%c%c %i %s %i %i %i %i %i %i %i P%i %Tu :%s",
cli_name(acptr),
cli_name(cli_serv(acptr)->up),
IsBurst(acptr) ? 'B' : '-',
IsBurstAck(acptr) ? 'A' : '-',
IsHub(acptr) ? 'H' : '-',
IsService(acptr) ? 'S' : '-',
cli_hopcount(acptr),
NumServ(acptr),
base64toint(cli_yxx(acptr)),
cli_serv(acptr)->lag,
cli_serv(acptr)->asll_rtt,
cli_serv(acptr)->asll_to,
cli_serv(acptr)->asll_from,
cli_serv(acptr)->clients,
cli_serv(acptr)->nn_mask,
cli_serv(acptr)->prot,
cli_serv(acptr)->timestamp,
cli_info(acptr));
}
}
/** Check whether the introduction of a new server would cause a loop
* or be disallowed by leaf and hub configuration directives.
* @param[in] cptr Neighbor who sent the message.
* @param[in] sptr Client that originated the message.
* @param[out] ghost If non-NULL, receives ghost timestamp for new server.
* @param[in] host Name of new server.
* @param[in] numnick Numnick mask of new server.
* @param[in] timestamp Claimed link timestamp of new server.
* @param[in] hop Number of hops to the new server.
* @param[in] junction Non-zero if the new server is still bursting.
* @return CPTR_KILLED if \a cptr was SQUIT. 0 if some other server
* was SQUIT. 1 if the new server is allowed.
*/
static int
check_loop_and_lh(struct Client* cptr, struct Client *sptr, time_t *ghost, const char *host, const char *numnick, time_t timestamp, unsigned int hop, int junction)
{
struct Client* acptr;
struct Client* LHcptr = NULL;
struct ConfItem* lhconf;
enum lh_type active_lh_line = ALLOWED;
int ii;
if (ghost)
*ghost = 0;
/*
* Calculate type of connect limit and applicable config item.
*/
lhconf = find_conf_byname(cli_confs(cptr), cli_name(cptr), CONF_SERVER);
assert(lhconf != NULL);
if (ghost)
{
if (!feature_bool(FEAT_HUB))
for (ii = 0; ii <= HighestFd; ii++)
if (LocalClientArray[ii] && IsServer(LocalClientArray[ii])) {
active_lh_line = I_AM_NOT_HUB;
break;
}
}
else if (hop > lhconf->maximum)
{
/* Because "maximum" should be 0 for non-hub links, check whether
* there is a hub mask -- if not, complain that the server isn't
* allowed to hub.
*/
active_lh_line = lhconf->hub_limit ? MAX_HOPS_EXCEEDED : NOT_ALLOWED_TO_HUB;
}
else if (lhconf->hub_limit && match(lhconf->hub_limit, host))
{
struct Client *ac3ptr;
active_lh_line = NOT_ALLOWED_TO_HUB;
if (junction)
for (ac3ptr = sptr; ac3ptr != &me; ac3ptr = cli_serv(ac3ptr)->up)
if (IsJunction(ac3ptr)) {
LHcptr = ac3ptr;
break;
}
}
/*
* We want to find IsConnecting() and IsHandshake() too,
* use FindClient().
* The second finds collisions with numeric representation of existing
* servers - these shouldn't happen anymore when all upgraded to 2.10.
* -- Run
*/
while ((acptr = FindClient(host))
|| (numnick && (acptr = FindNServer(numnick))))
{
/*
* This link is trying feed me a server that I already have
* access through another path
*
* Do not allow Uworld to do this.
* Do not allow servers that are juped.
* Do not allow servers that have older link timestamps
* then this try.
* Do not allow servers that use the same numeric as an existing
* server, but have a different name.
*
* If my ircd.conf sucks, I can try to connect to myself:
*/
if (acptr == &me)
return exit_client_msg(cptr, cptr, &me, "nick collision with me (%s), check server number in M:?", host);
/*
* Detect wrong numeric.
*/
if (0 != ircd_strcmp(cli_name(acptr), host))
{
sendcmdto_serv(&me, CMD_WALLOPS, cptr,
":SERVER Numeric Collision: %s != %s",
cli_name(acptr), host);
return exit_client_msg(cptr, cptr, &me,
"NUMERIC collision between %s and %s."
" Is your server numeric correct ?", host, cli_name(acptr));
}
/*
* Kill our try, if we had one.
*/
if (IsConnecting(acptr))
{
if (active_lh_line == ALLOWED && exit_client(cptr, acptr, &me,
"Just connected via another link") == CPTR_KILLED)
return CPTR_KILLED;
/*
* We can have only ONE 'IsConnecting', 'IsHandshake' or
* 'IsServer', because new 'IsConnecting's are refused to
* the same server if we already had it.
*/
break;
}
/*
* Avoid other nick collisions...
* This is a doubtful test though, what else would it be
* when it has a server.name ?
*/
else if (!IsServer(acptr) && !IsHandshake(acptr))
return exit_client_msg(cptr, cptr, &me,
"Nickname %s already exists!", host);
/*
* Our new server might be a juped server:
*/
else if (IsServer(acptr) && (0 == ircd_strncmp(cli_info(acptr), "JUPE", 4)))
{
if (!IsServer(sptr))
return exit_client(cptr, sptr, &me, cli_info(acptr));
sendcmdto_serv(&me, CMD_WALLOPS, cptr,
":Received :%s SERVER %s from %s !?!",
NumServ(cptr), host, cli_name(cptr));
return exit_new_server(cptr, sptr, host, timestamp, "%s", cli_info(acptr));
}
/*
* Of course we find the handshake this link was before :)
*/
else if (IsHandshake(acptr) && acptr == cptr)
break;
/*
* Here we have a server nick collision...
* We don't want to kill the link that was last /connected,
* but we neither want to kill a good (old) link.
* Therefor we kill the second youngest link.
*/
if (1)
{
struct Client* c2ptr = 0;
struct Client* c3ptr = acptr;
struct Client* ac2ptr;
struct Client* ac3ptr;
/* Search youngest link: */
for (ac3ptr = acptr; ac3ptr != &me; ac3ptr = cli_serv(ac3ptr)->up)
if (cli_serv(ac3ptr)->timestamp > cli_serv(c3ptr)->timestamp)
c3ptr = ac3ptr;
if (IsServer(sptr))
{
for (ac3ptr = sptr; ac3ptr != &me; ac3ptr = cli_serv(ac3ptr)->up)
if (cli_serv(ac3ptr)->timestamp > cli_serv(c3ptr)->timestamp)
c3ptr = ac3ptr;
}
if (timestamp > cli_serv(c3ptr)->timestamp)
{
c3ptr = 0;
c2ptr = acptr; /* Make sure they differ */
}
/* Search second youngest link: */
for (ac2ptr = acptr; ac2ptr != &me; ac2ptr = cli_serv(ac2ptr)->up)
if (ac2ptr != c3ptr &&
cli_serv(ac2ptr)->timestamp >
(c2ptr ? cli_serv(c2ptr)->timestamp : timestamp))
c2ptr = ac2ptr;
if (IsServer(sptr))
{
for (ac2ptr = sptr; ac2ptr != &me; ac2ptr = cli_serv(ac2ptr)->up)
if (ac2ptr != c3ptr &&
cli_serv(ac2ptr)->timestamp >
(c2ptr ? cli_serv(c2ptr)->timestamp : timestamp))
c2ptr = ac2ptr;
}
if (c3ptr && timestamp > (c2ptr ? cli_serv(c2ptr)->timestamp : timestamp))
c2ptr = 0;
/* If timestamps are equal, decide which link to break
* by name.
*/
if ((c2ptr ? cli_serv(c2ptr)->timestamp : timestamp) ==
(c3ptr ? cli_serv(c3ptr)->timestamp : timestamp))
{
const char *n2, *n2up, *n3, *n3up;
if (c2ptr)
{
n2 = cli_name(c2ptr);
n2up = MyConnect(c2ptr) ? cli_name(&me) : cli_name(cli_serv(c2ptr)->up);
}
else
{
n2 = host;
n2up = IsServer(sptr) ? cli_name(sptr) : cli_name(&me);
}
if (c3ptr)
{
n3 = cli_name(c3ptr);
n3up = MyConnect(c3ptr) ? cli_name(&me) : cli_name(cli_serv(c3ptr)->up);
}
else
{
n3 = host;
n3up = IsServer(sptr) ? cli_name(sptr) : cli_name(&me);
}
if (strcmp(n2, n2up) > 0)
n2 = n2up;
if (strcmp(n3, n3up) > 0)
n3 = n3up;
if (strcmp(n3, n2) > 0)
{
ac2ptr = c2ptr;
c2ptr = c3ptr;
c3ptr = ac2ptr;
}
}
/* Now squit the second youngest link: */
if (!c2ptr)
return exit_new_server(cptr, sptr, host, timestamp,
"server %s already exists and is %ld seconds younger.",
host, (long)cli_serv(acptr)->timestamp - (long)timestamp);
else if (cli_from(c2ptr) == cptr || IsServer(sptr))
{
struct Client *killedptrfrom = cli_from(c2ptr);
if (active_lh_line != ALLOWED)
{
/*
* If the L: or H: line also gets rid of this link,
* we sent just one squit.
*/
if (LHcptr && a_kills_b_too(LHcptr, c2ptr))
break;
/*
* If breaking the loop here solves the L: or H:
* line problem, we don't squit that.
*/
if (cli_from(c2ptr) == cptr || (LHcptr && a_kills_b_too(c2ptr, LHcptr)))
active_lh_line = ALLOWED;
else
{
/*
* If we still have a L: or H: line problem,
* we prefer to squit the new server, solving
* loop and L:/H: line problem with only one squit.
*/
LHcptr = 0;
break;
}
}
/*
* If the new server was introduced by a server that caused a
* Ghost less then 20 seconds ago, this is probably also
* a Ghost... (20 seconds is more then enough because all
* SERVER messages are at the beginning of a net.burst). --Run
*/
if (CurrentTime - cli_serv(cptr)->ghost < 20)
{
killedptrfrom = cli_from(acptr);
if (exit_client(cptr, acptr, &me, "Ghost loop") == CPTR_KILLED)
return CPTR_KILLED;
}
else if (exit_client_msg(cptr, c2ptr, &me,
"Loop <-- %s (new link is %ld seconds younger)", host,
(c3ptr ? (long)cli_serv(c3ptr)->timestamp : timestamp) -
(long)cli_serv(c2ptr)->timestamp) == CPTR_KILLED)
return CPTR_KILLED;
/*
* Did we kill the incoming server off already ?
*/
if (killedptrfrom == cptr)
return 0;
}
else
{
if (active_lh_line != ALLOWED)
{
if (LHcptr && a_kills_b_too(LHcptr, acptr))
break;
if (cli_from(acptr) == cptr || (LHcptr && a_kills_b_too(acptr, LHcptr)))
active_lh_line = ALLOWED;
else
{
LHcptr = 0;
break;
}
}
/*
* We can't believe it is a lagged server message
* when it directly connects to us...
* kill the older link at the ghost, rather then
* at the second youngest link, assuming it isn't
* a REAL loop.
*/
if (ghost)
*ghost = CurrentTime; /* Mark that it caused a ghost */
if (exit_client(cptr, acptr, &me, "Ghost") == CPTR_KILLED)
return CPTR_KILLED;
break;
}
}
}
if (active_lh_line != ALLOWED)
{
if (!LHcptr)
LHcptr = sptr;
if (active_lh_line == MAX_HOPS_EXCEEDED)
{
return exit_client_msg(cptr, LHcptr, &me,
"Maximum hops exceeded for %s at %s",
cli_name(cptr), host);
}
else if (active_lh_line == NOT_ALLOWED_TO_HUB)
{
return exit_client_msg(cptr, LHcptr, &me,
"%s is not allowed to hub for %s",
cli_name(cptr), host);
}
else /* I_AM_NOT_HUB */
{
ServerStats->is_ref++;
return exit_client(cptr, LHcptr, &me, "I'm a leaf, define the HUB feature");
}
}
return 1;
}
static void dump_map(struct Client *cptr, struct Client *server, char *mask, int prompt_length)
{
static char prompt[64];
struct DLink *lp;
char *p = &prompt[prompt_length];
int cnt = 0;
*p = '\0';
if (prompt_length > 60)
send_reply(cptr, RPL_MAPMORE, prompt, cli_name(server));
else {
char lag[512];
int showserv = 1;
unsigned int totalusers = UserStats.clients;
unsigned int percentage;
unsigned int serv_clients;
if (totalusers == 0)
totalusers = 1; /* ¿? NO deberia ocurrir nunca... */
percentage = (10000 * (IsMe(server) ? UserStats.local_clients : cli_serv(server)->clients)) / totalusers;
if (IsMe(server))
strcpy(lag,"(0s)");
else if (cli_serv(server)->lag>10000)
lag[0]=0;
else if (cli_serv(server)->lag<0)
strcpy(lag,"(0s)");
else
sprintf(lag,"(%is)",cli_serv(server)->lag);
if (IsHiddenserv(server) && !feature_bool(FEAT_SHOWSERVON_MAP))
if (!IsAnOper(cptr) && !es_representante(cptr))
showserv = 0;
serv_clients = (server == &me) ? UserStats.local_clients : cli_serv(server)->clients;
send_reply(cptr, RPL_MAP, prompt, (
(IsBurst(server)) ? "*" : (IsBurstAck(server) ? "!" : "")),
showserv ? cli_name(server) : feature_str(FEAT_HIS_SERVERNAME),
lag, NumServ(server), base64toint(NumServ(server)), serv_clients,
(serv_clients == 1) ? "" : "s",
(percentage / 100), (percentage % 100));
}
if (prompt_length > 0)
{
p[-1] = ' ';
if (p[-2] == '`')
p[-2] = ' ';
}
if (prompt_length > 60)
return;
strcpy(p, "|-");
for (lp = cli_serv(server)->down; lp; lp = lp->next)
if (match(mask, cli_name(lp->value.cptr)))
cli_flags(lp->value.cptr) &= ~FLAGS_MAP;
else
{
cli_flags(lp->value.cptr) |= FLAGS_MAP;
cnt++;
}
for (lp = cli_serv(server)->down; lp; lp = lp->next)
{
if ((cli_flags(lp->value.cptr) & FLAGS_MAP) == 0)
continue;
if (--cnt == 0)
*p = '`';
dump_map(cptr, lp->value.cptr, mask, prompt_length + 2);
}
if (prompt_length > 0)
p[-1] = '-';
}
