static void
serv_info(aClient *cptr, char *name)
{
static char Lformat[] = ":%s %d %s %s %u %u %u %u %u :%u %u %s";
long sendK, receiveK, uptime;
aClient *acptr;
DLink *lp;
int i = 0;
sendK = receiveK = 0;
for (lp = server_list; lp; lp = lp->next)
{
acptr = lp->value.cptr;
#ifdef HIDEULINEDSERVS
if (IsULine(acptr) && !IsAnOper(cptr))
continue;
#endif
sendK += acptr->sendK;
receiveK += acptr->receiveK;
sendto_one(cptr, Lformat, me.name, RPL_STATSLINKINFO,
name, ( (MyClient(cptr) && IsAdmin(cptr))
? get_client_name(acptr, FALSE)
: get_client_name(acptr, HIDEME) ),
(int) SBufLength(&acptr->sendQ),
(int) acptr->sendM, (int) acptr->sendK,
(int) acptr->receiveM, (int) acptr->receiveK,
timeofday - acptr->firsttime, timeofday - acptr->since,
IsServer(acptr) ? (DoesTS(acptr) ? "TS" : "NoTS") : "-");
if(RC4EncLink(acptr))
sendto_one(cptr, ":%s %d %s : - RC4 encrypted", me.name,
RPL_STATSDEBUG, name);
if(ZipOut(acptr))
{
unsigned long ib, ob;
double rat;
zip_out_get_stats(acptr->serv->zip_out, &ib, &ob, &rat);
if(ib)
{
sendto_one(cptr, ":%s %d %s : - [O] Zip inbytes %lu, "
"outbytes %lu (%3.2f%%)", me.name, RPL_STATSDEBUG,
name, ib, ob, rat);
}
}
if(ZipIn(acptr))
{
unsigned long ib, ob;
double rat;
zip_in_get_stats(acptr->serv->zip_in, &ib, &ob, &rat);
if(ob)
{
sendto_one(cptr, ":%s %d %s : - [I] Zip inbytes %lu, "
"outbytes %lu (%3.2f%%)", me.name, RPL_STATSDEBUG,
name, ib, ob, rat);
}
}
i++;
}
sendto_one(cptr, ":%s %d %s :%u total server%s",
me.name, RPL_STATSDEBUG, name, i, (i == 1) ? "" : "s");
sendto_one(cptr, ":%s %d %s :Sent total : %7.2f %s",
me.name, RPL_STATSDEBUG, name, _GMKv(sendK), _GMKs(sendK));
sendto_one(cptr, ":%s %d %s :Recv total : %7.2f %s",
me.name, RPL_STATSDEBUG, name, _GMKv(receiveK),
_GMKs(receiveK));
uptime = (timeofday - me.since);
sendto_one(cptr, ":%s %d %s :Server send: %7.2f %s (%4.1f K/s total,"
" %4.1f K/s current)", me.name, RPL_STATSDEBUG, name,
_GMKv(me.sendK), _GMKs(me.sendK),
(float) ((float) me.sendK / (float) uptime), curSendK);
sendto_one(cptr, ":%s %d %s :Server recv: %7.2f %s (%4.1f K/s total,"
" %4.1f K/s current)", me.name, RPL_STATSDEBUG, name,
_GMKv(me.receiveK), _GMKs(me.receiveK),
(float) ((float) me.receiveK / (float) uptime), curRecvK);
}
static int
do_server_estab(aClient *cptr)
{
aClient *acptr;
aConnect *aconn;
aChannel *chptr;
int i;
/* "refresh" inpath with host */
char *inpath = get_client_name(cptr, HIDEME);
SetServer(cptr);
Count.unknown--;
Count.server++;
Count.myserver++;
if(IsZipCapable(cptr) && DoZipThis(cptr))
{
sendto_one(cptr, "SVINFO ZIP");
SetZipOut(cptr);
cptr->serv->zip_out = zip_create_output_session();
}
#ifdef MAXBUFFERS
/* let's try to bump up server sock_opts... -Taner */
reset_sock_opts(cptr->fd, 1);
#endif
/* adds to server list */
add_to_list(&server_list, cptr);
set_effective_class(cptr);
/* Check one more time for good measure... is it there? */
if ((acptr = find_name(cptr->name, NULL)))
{
char nbuf[HOSTLEN * 2 + USERLEN + 5];
aClient *bcptr;
/*
* While negotiating stuff, another copy of this server appeared.
*
* Rather than KILL the link which introduced it, KILL the
* youngest of the two links. -avalon
*/
bcptr = (cptr->firsttime > acptr->from->firsttime) ? cptr :
acptr->from;
sendto_one(bcptr, "ERROR :Server %s already exists", cptr->name);
if (bcptr == cptr)
{
sendto_gnotice("from %s: Link %s cancelled, server %s already "
"exists (final phase)", me.name,
get_client_name(bcptr, HIDEME), cptr->name);
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, "
"server %s already exists (final phase)",
me.name, get_client_name(bcptr, HIDEME),
cptr->name);
return exit_client(bcptr, bcptr, &me,
"Server Exists (final phase)");
}
/* inform all those who care (set +n) -epi */
strcpy(nbuf, get_client_name(bcptr, HIDEME));
sendto_gnotice("from %s: Link %s cancelled, server %s reintroduced "
"by %s (final phase)", me.name, nbuf, cptr->name,
get_client_name(cptr, HIDEME));
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, server %s "
"reintroduced by %s (final phase)", me.name, nbuf,
cptr->name, get_client_name(cptr, HIDEME));
exit_client(bcptr, bcptr, &me, "Server Exists (final phase)");
}
/* error, error, error! if a server is U:'d, and it connects to us,
* we need to figure that out! So, do it here. - lucas
*/
if (find_aUserver(cptr->name))
{
Count.myulined++;
cptr->flags |= FLAGS_ULINE;
/* If the server has special u:line flags, let's set them.. */
cptr->serv->uflags = cptr->serv->aconn->uflags;
}
fakelinkserver_update(cptr->name, cptr->info);
sendto_gnotice("from %s: Link with %s established, states:%s%s%s%s",
me.name, inpath, ZipOut(cptr) ? " Output-compressed" : "",
RC4EncLink(cptr) ? " encrypted" : "",
IsULine(cptr) ? " ULined" : "",
DoesTS(cptr) ? " TS" : " Non-TS");
/*
* Notify everyone of the fact that this has just linked: the entire
* network should get two of these, one explaining the link between
* me->serv and the other between serv->me
*/
sendto_serv_butone(NULL, ":%s GNOTICE :Link with %s established: %s",
me.name, inpath,
DoesTS(cptr) ? "TS link" : "Non-TS link!");
add_to_client_hash_table(cptr->name, cptr);
/* add it to scache */
find_or_add(cptr->name);
/*
* Old sendto_serv_but_one() call removed because we now need to
* send different names to different servers (domain name
* matching) Send new server to other servers.
*/
for (i = 0; i <= highest_fd; i++)
{
if (!(acptr = local[i]) || !IsServer(acptr) || acptr == cptr ||
IsMe(acptr))
continue;
if ((aconn = acptr->serv->aconn) &&
!match(my_name_for_link(me.name, aconn), cptr->name))
continue;
sendto_one(acptr, ":%s SERVER %s 2 :%s", me.name, cptr->name,
cptr->info);
}
/*
* Pass on my client information to the new server
*
* First, pass only servers (idea is that if the link gets
* cancelled beacause the server was already there, there are no
* NICK's to be cancelled...). Of course, if cancellation occurs,
* all this info is sent anyway, and I guess the link dies when a
* read is attempted...? --msa
*
* Note: Link cancellation to occur at this point means that at
* least two servers from my fragment are building up connection
* this other fragment at the same time, it's a race condition,
* not the normal way of operation...
*
* ALSO NOTE: using the get_client_name for server names-- see
* previous *WARNING*!!! (Also, original inpath is
* destroyed...)
*/
aconn = cptr->serv->aconn;
for (acptr = &me; acptr; acptr = acptr->prev)
{
if (acptr->from == cptr)
continue;
if (IsServer(acptr))
{
if (match(my_name_for_link(me.name, aconn), acptr->name) == 0)
continue;
sendto_one(cptr, ":%s SERVER %s %d :%s",
acptr->serv->up, acptr->name,
acptr->hopcount + 1, acptr->info);
}
}
/* send out our SQLINES and SGLINES too */
send_simbans(cptr, SBAN_CHAN|SBAN_NETWORK);
send_simbans(cptr, SBAN_NICK|SBAN_NETWORK);
send_simbans(cptr, SBAN_GCOS|SBAN_NETWORK);
/* Send out fake server list and other 'fake' stuff */
fakeserver_sendserver(cptr);
/* Send UHM (user host-masking) type */
if(confopts & FLAGS_HUB)
sendto_one(cptr, "SVSUHM %d", uhm_type);
/* send clone list */
clones_send(cptr);
/* Bursts are about to start.. send a BURST */
if (IsBurst(cptr))
sendto_one(cptr, "BURST");
/*
* * Send it in the shortened format with the TS, if it's a TS
* server; walk the list of channels, sending all the nicks that
* haven't been sent yet for each channel, then send the channel
* itself -- it's less obvious than sending all nicks first, but
* on the receiving side memory will be allocated more nicely
* saving a few seconds in the handling of a split -orabidoo
*/
{
chanMember *cm;
static char nickissent = 1;
nickissent = 3 - nickissent;
/*
* flag used for each nick to check if we've sent it yet - must
* be different each time and !=0, so we alternate between 1 and
* 2 -orabidoo
*/
for (chptr = channel; chptr; chptr = chptr->nextch)
{
for (cm = chptr->members; cm; cm = cm->next)
{
acptr = cm->cptr;
if (acptr->nicksent != nickissent)
{
acptr->nicksent = nickissent;
if (acptr->from != cptr)
sendnick_TS(cptr, acptr);
}
}
send_channel_modes(cptr, chptr);
}
/* also send out those that are not on any channel */
for (acptr = &me; acptr; acptr = acptr->prev)
if (acptr->nicksent != nickissent)
{
acptr->nicksent = nickissent;
if (acptr->from != cptr)
sendnick_TS(cptr, acptr);
}
}
if(confopts & FLAGS_HUB)
fakelusers_sendlock(cptr);
if(ZipOut(cptr))
{
unsigned long inb, outb;
double rat;
zip_out_get_stats(cptr->serv->zip_out, &inb, &outb, &rat);
if(inb)
{
sendto_gnotice("from %s: Connect burst to %s: %lu bytes normal, "
"%lu compressed (%3.2f%%)", me.name,
get_client_name(cptr, HIDEME), inb, outb, rat);
sendto_serv_butone(cptr, ":%s GNOTICE :Connect burst to %s: %lu "
"bytes normal, %lu compressed (%3.2f%%)",
me.name, get_client_name(cptr, HIDEME), inb,
outb, rat);
}
}
/* stuff a PING at the end of this burst so we can figure out when
the other side has finished processing it. */
cptr->flags |= FLAGS_BURST|FLAGS_PINGSENT;
if (IsBurst(cptr)) cptr->flags |= FLAGS_SOBSENT;
sendto_one(cptr, "PING :%s", me.name);
return 0;
}
