Protocol GetProtocolByIndex(int index)
{
std::vector<PROTOACCOUNT *> protos;
GetAccounts(&protos);
int protosSize = protos.size();
if (protosSize < 1)
return Protocol(NULL);
index = (index % protosSize + protosSize) % protosSize;
return Protocol(protos[index]->szModuleName);
}
Protocol GetProtocolByName(const char *moduleName)
{
std::vector<PROTOACCOUNT *> protos;
GetAccounts(&protos);
int protosSize = (int) protos.size();
for(int i = 0; i < protosSize; ++i)
{
if (strcmp(protos[i]->szModuleName, moduleName) == 0)
return Protocol(protos[i]->szModuleName);
}
return Protocol(NULL);
}
int testPinging() {
Protocol p;
p = Protocol();
std::vector<ProtocolPacket> out;
#define T(STATE) \
p.state = STATE;\
out = p._timerEvent(p.pingInterval);\
ASSERT(out.size() == 0);\
ASSERT(p.lastPingSendTime == 0);\
out = p._timerEvent(p.pingInterval + 1);\
if (STATE == STATE_CONNECTED) { \
ASSERT(out.size() == 1);\
ASSERT(out[0].type == TYPE_PING);\
ASSERT(p.lastPingSendTime == (p.pingInterval + 1));\
} else { \
ASSERT(out.size() == 0);\
ASSERT(p.lastPingSendTime == 0);\
}
T(STATE_UNINIT);
T(STATE_LISTENING);
T(STATE_CONNECTING);
T(STATE_CONNECTED);
#undef T
return 0;
}
int testProtocolConstructors() {
Protocol p = Protocol();
ASSERT(p.state == STATE_UNINIT);
ASSERT(p.lastKeepAlive == 0);
ASSERT(p.lastPingSendTime == 0);
return 0;
}
void GetProtocols(std::vector<Protocol> *result)
{
std::vector<PROTOACCOUNT *> accs;
GetAccounts(&accs);
unsigned int accsSize = accs.size();
for (unsigned int i = 0; i < accsSize ; ++i)
result->push_back(Protocol(accs[i]->szModuleName));
}
void setup()
{
p = Protocol();
//movement_api
initialize();
attachInterrupt(1, interrupt_handler_explore, FALLING);
}
std::future<error_code> WorldServer::Connect(
const uint32_t port,
const time_duration timeout) {
if (!IsPortValid(port)) {
return GetInvalidPortResult(port);
}
_port = port;
_timeout = timeout;
auto result = _world_server.Connect(_port, _timeout);
ExecuteProtocol(Protocol(_timeout));
return result;
}
int testAck() {
char hello[] = "hello";
Protocol p;
std::vector<ProtocolPacket> out;
p = Protocol();
p.state = STATE_CONNECTED;
p.seqnum = 5;
p.outgoingDataPacket = std::tr1::shared_ptr<ProtocolPacket>(new ProtocolPacket(TYPE_DATA,5,hello,5));
ProtocolPacket pp = ProtocolPacket(TYPE_ACK,4);
out = p._packetEvent(pp,8).first;
ASSERT(p.lastKeepAlive == 0);
ASSERT(p.seqnum == 5);
ASSERT(out.size() == 0);
ASSERT(p.outgoingDataPacket);
pp = ProtocolPacket(TYPE_ACK,5);
out = p._packetEvent(pp,8).first;
ASSERT(p.lastKeepAlive == 8);
ASSERT(p.seqnum == 6);
ASSERT(out.size() == 0);
ASSERT(!(p.outgoingDataPacket));
p = Protocol();
p.state = STATE_CONNECTED;
p.seqnum = 5;
p.outgoingDataPacket = std::tr1::shared_ptr<ProtocolPacket>(new ProtocolPacket(TYPE_DATA,5,hello,5));
pp = ProtocolPacket(TYPE_DATA,5);
out = p._packetEvent(pp,8).first;
ASSERT(p.lastKeepAlive != 8);
ASSERT(p.seqnum == 5);
ASSERT(out.size() == 0);
ASSERT(p.outgoingDataPacket);
return 0;
}
/* {{{ MySQL_Uri::Host() -I- */
const sql::SQLString & MySQL_Uri::Host()
{
static const sql::SQLString hostValue4Pipe(".");
const sql::SQLString & hostValue4sock= util::LOCALHOST;
switch (Protocol())
{
case NativeAPI::PROTOCOL_TCP:
return host;
case NativeAPI::PROTOCOL_PIPE:
return hostValue4Pipe;
case NativeAPI::PROTOCOL_SOCKET:
return hostValue4sock;
}
// throw smoething maybe?
return host;
}
/* {{{ MySQL_Uri::Host() -I- */
const sql::SQLString & MySQL_Uri::Host()
{
static const sql::SQLString hostValue4Pipe(".");
static const sql::SQLString hostValue4sock(util::LOCALHOST);
switch (Protocol())
{
case NativeAPI::PROTOCOL_TCP:
return host;
case NativeAPI::PROTOCOL_PIPE:
return hostValue4Pipe;
case NativeAPI::PROTOCOL_SOCKET:
return hostValue4sock;
case NativeAPI::PROTOCOL_COUNT:
throw sql::InvalidArgumentException("NativeAPI::PROTOCOL_COUNT shouldn't be used.");
break;
}
// throw smoething maybe?
return host;
}
void CSocket::Connect(const tchar* pszHost, uint nPort)
{
ASSERT(m_hSocket == INVALID_SOCKET);
ASSERT(pszHost != nullptr);
ASSERT(nPort <= USHRT_MAX);
// Save parameters.
m_strHost = pszHost;
m_nPort = nPort;
sockaddr_in addr = { 0 };
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(T2A(pszHost));
addr.sin_port = htons(static_cast<ushort>(nPort));
// Host name isn't an IP Address?
if (addr.sin_addr.s_addr == INADDR_NONE)
{
// Resolve host name.
hostent* pHost = gethostbyname(T2A(pszHost));
if (pHost == nullptr)
throw CSocketException(CSocketException::E_RESOLVE_FAILED, CWinSock::LastError());
memcpy(&addr.sin_addr, pHost->h_addr_list[0], pHost->h_length);
}
// Create the socket.
Create(AF_INET, Type(), Protocol());
// Connect to host.
if (connect(m_hSocket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == SOCKET_ERROR)
throw CSocketException(CSocketException::E_CONNECT_FAILED, CWinSock::LastError());
// If async mode, do select.
if (m_eMode == ASYNC)
CWinSock::BeginAsyncSelect(this, (FD_READ | FD_WRITE | FD_CLOSE));
}
/*
* 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);
}
// -----------------------------------------------------------------------------
// CNATTraversalControllerExample::RefreshNATBindingL
// From CSIPNATTraversalController
// -----------------------------------------------------------------------------
//
TBool CNATTraversalControllerExample::RefreshNATBindingL(
RSocket& aSocket,
const MSIPNATBindingObserver* /*aBindingObserver*/)
{
TBool maintainPersistentConnection = EFalse;
// If it was detected that the terminal is behind a NAT,
// some kind of NAT binding keepalive should be started.
// Some suggestions about the keepalive mechanisms can be found from
// http://www.ietf.org/internet-drafts/draft-ietf-sip-outbound-04.txt
// aBindingObserver can be used for notifying flow failures
// specified in the above draft.
if (Protocol(aSocket) == KProtocolInetTcp)
{
// If it was found that the terminal is behind a NAT
// and the protocol of aSocket is TCP,
// then maintainPersistentConnection should be set to ETrue
// to keep the TCP connection open for NAT binding keepalive.
}
return maintainPersistentConnection;
}
/** Handle a connection that has sent a valid PASS and SERVER.
* @param cptr New peer server.
* @param aconf Connect block for \a cptr.
* @return Zero.
*/
int server_estab(struct Client *cptr, struct ConfItem *aconf)
{
struct Client* acptr = 0;
const char* inpath;
int i;
assert(0 != cptr);
assert(0 != cli_local(cptr));
inpath = cli_name(cptr);
if (IsUnknown(cptr)) {
if (aconf->passwd[0])
sendrawto_one(cptr, MSG_PASS " :%s", aconf->passwd);
/*
* Pass my info to the new server
*/
sendrawto_one(cptr, MSG_SERVER " %s 1 %Tu %Tu J%s %s%s +%s6 :%s",
cli_name(&me), cli_serv(&me)->timestamp,
cli_serv(cptr)->timestamp, MAJOR_PROTOCOL, NumServCap(&me),
feature_bool(FEAT_HUB) ? "h" : "",
*(cli_info(&me)) ? cli_info(&me) : "IRCers United");
}
det_confs_butmask(cptr, CONF_SERVER);
if (!IsHandshake(cptr))
hAddClient(cptr);
SetServer(cptr);
cli_handler(cptr) = SERVER_HANDLER;
Count_unknownbecomesserver(UserStats);
SetBurst(cptr);
/* nextping = CurrentTime; */
/*
* NOTE: check for acptr->user == cptr->serv->user is necessary to insure
* that we got the same one... bleah
*/
if (cli_serv(cptr)->user && *(cli_serv(cptr))->by &&
(acptr = findNUser(cli_serv(cptr)->by))) {
if (cli_user(acptr) == cli_serv(cptr)->user) {
sendcmdto_one(&me, CMD_NOTICE, acptr, "%C :Link with %s established.",
acptr, inpath);
}
else {
/*
* if not the same client, set by to empty string
*/
acptr = 0;
*(cli_serv(cptr))->by = '\0';
}
}
sendto_opmask(acptr, SNO_OLDSNO, "Link with %s established.", inpath);
cli_serv(cptr)->up = &me;
cli_serv(cptr)->updown = add_dlink(&(cli_serv(&me))->down, cptr);
sendto_opmask(0, SNO_NETWORK, "Net junction: %s %s", cli_name(&me),
cli_name(cptr));
SetJunction(cptr);
/*
* 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 <= HighestFd; i++)
{
if (!(acptr = LocalClientArray[i]) || !IsServer(acptr) ||
acptr == cptr || IsMe(acptr))
continue;
if (!match(cli_name(&me), cli_name(cptr)))
continue;
sendcmdto_one(&me, CMD_SERVER, acptr,
"%s 2 0 %Tu J%02u %s%s +%s%s%s :%s", cli_name(cptr),
cli_serv(cptr)->timestamp, Protocol(cptr), NumServCap(cptr),
IsHub(cptr) ? "h" : "", IsService(cptr) ? "s" : "",
IsIPv6(cptr) ? "6" : "", cli_info(cptr));
}
/* Send these as early as possible so that glined users/juped servers can
* be removed from the network while the remote server is still chewing
* our burst.
*/
gline_burst(cptr);
jupe_burst(cptr);
/*
* Pass on my client information to the new server
*
* First, pass only servers (idea is that if the link gets
* canceled because the server was already there,
* there are no NICK's to be canceled...). 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...
*/
for (acptr = &me; acptr; acptr = cli_prev(acptr)) {
/* acptr->from == acptr for acptr == cptr */
if (cli_from(acptr) == cptr)
continue;
if (IsServer(acptr)) {
const char* protocol_str;
if (Protocol(acptr) > 9)
protocol_str = IsBurst(acptr) ? "J" : "P";
else
protocol_str = IsBurst(acptr) ? "J0" : "P0";
if (0 == match(cli_name(&me), cli_name(acptr)))
continue;
sendcmdto_one(cli_serv(acptr)->up, CMD_SERVER, cptr,
"%s %d 0 %Tu %s%u %s%s +%s%s%s :%s", cli_name(acptr),
cli_hopcount(acptr) + 1, cli_serv(acptr)->timestamp,
protocol_str, Protocol(acptr), NumServCap(acptr),
IsHub(acptr) ? "h" : "", IsService(acptr) ? "s" : "",
IsIPv6(acptr) ? "6" : "", cli_info(acptr));
}
}
for (acptr = &me; acptr; acptr = cli_prev(acptr))
{
/* acptr->from == acptr for acptr == cptr */
if (cli_from(acptr) == cptr)
continue;
if (IsUser(acptr))
{
char xxx_buf[25];
char *s = umode_str(acptr);
sendcmdto_one(cli_user(acptr)->server, CMD_NICK, cptr,
"%s %d %Tu %s %s %s%s%s%s %s%s :%s",
cli_name(acptr), cli_hopcount(acptr) + 1, cli_lastnick(acptr),
cli_user(acptr)->username, cli_user(acptr)->realhost,
*s ? "+" : "", s, *s ? " " : "",
iptobase64(xxx_buf, &cli_ip(acptr), sizeof(xxx_buf), IsIPv6(cptr)),
NumNick(acptr), cli_info(acptr));
}
}
/*
* Last, send the BURST.
* (Or for 2.9 servers: pass all channels plus statuses)
*/
{
struct Channel *chptr;
for (chptr = GlobalChannelList; chptr; chptr = chptr->next)
send_channel_modes(cptr, chptr);
}
sendcmdto_one(&me, CMD_END_OF_BURST, cptr, "");
return 0;
}
void FileManagerAPI::initializePaths() {
mProtocols.clear();
/*
* Defines paths
*/
// Internal
boost::filesystem::path internalPath = FB::BrowserPlugin::getFSPath();
internalPath = internalPath.parent_path();
internalPath /= std::string(PLUGIN_SHAREDIR);
// Temp
boost::filesystem::path tempPath = boost::filesystem::path(FB::System::getTempPath());
tempPath /= FBSTRING_ProductDomain;
tempPath /= boost::filesystem::unique_path();
// Local
boost::filesystem::path localPath = tempPath; // fallback
FB::PluginCorePtr plugin = getFactory()->getPlugin();
FB::URI loc = FB::URI::fromString(plugin->getHost()->getDOMWindow()->getLocation());
if(!loc.domain.empty()) {
std::string localPathString = FB::System::getLocalAppDataPath(FBSTRING_ProductDomain);
if(!localPathString.empty()) {
localPath = boost::filesystem::path(localPathString);
localPath /= std::string(loc.domain);
} else {
FBLOG_WARN("FileManagerAPI::setFactory", "Can't find local path: using temp path");
}
} else {
FBLOG_WARN("FileManagerAPI::setFactory", "Can't find browser url: using temp path");
}
// Create directories
// boost::filesystem::create_directories(internalPath);
boost::filesystem::create_directories(tempPath);
boost::filesystem::create_directories(localPath);
// Normalize
internalPath = boost::filesystem::canonical(internalPath);
tempPath = boost::filesystem::canonical(tempPath);
localPath = boost::filesystem::canonical(localPath);
// Make generics
internalPath = boost::filesystem::path(internalPath.generic_string());
tempPath = boost::filesystem::path(tempPath.generic_string());
localPath = boost::filesystem::path(localPath.generic_string());
mProtocols.push_back(Protocol(Protocol::internal, internalPath));
mProtocols.push_back(Protocol(Protocol::temp, tempPath));
mProtocols.push_back(Protocol(Protocol::local, localPath));
// Order bigger path first
mProtocols.sort(boost::bind(std::greater<std::size_t>(),
boost::bind(&std::string::length, boost::bind(&boost::filesystem::path::string<std::string>, boost::bind(&Protocol::getPath, _1))),
boost::bind(&std::string::length, boost::bind(&boost::filesystem::path::string<std::string>, boost::bind(&Protocol::getPath, _2)))
)
);
for(std::list<Protocol>::iterator it = mProtocols.begin(); it != mProtocols.end(); ++it) {
FBLOG_DEBUG("FileManagerAPI::setFactory", it->getProtocol() << "=" << it->getPath());
}
}
cString cServerConnection::ToText() const
{ return cString::sprintf("%s\t%s:%d", Protocol(), RemoteIp().c_str(), RemotePort()); }
bool cServerConnection::Close()
{
if (IsOpen())
isyslog("streamdev-server: closing %s connection to %s:%d", Protocol(), RemoteIp().c_str(), RemotePort());
return cTBSocket::Close();
}
/** Handle a SERVER message from another server.
*
* \a parv has the following elements:
* \li \a parv[1] is the server name
* \li \a parv[2] is the hop count to the server
* \li \a parv[3] is the start timestamp for the server
* \li \a parv[4] is the link timestamp
* \li \a parv[5] is the protocol version (P10 or J10)
* \li \a parv[6] is the numnick mask for the server
* \li \a parv[7] is a string of flags like +hs to mark hubs and services
* \li \a parv[\a parc - 1] is the server description
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int ms_server(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
int i;
char* host;
struct Client* acptr;
struct Client* bcptr;
int hop;
int ret;
unsigned short prot;
time_t start_timestamp;
time_t timestamp;
if (parc < 8)
{
return need_more_params(sptr, "SERVER");
return exit_client(cptr, cptr, &me, "Need more parameters");
}
host = clean_servername(parv[1]);
if (!host)
{
sendto_opmask_butone(0, SNO_OLDSNO, "Bogus server name (%s) from %s",
host, cli_name(cptr));
return exit_client_msg(cptr, cptr, &me, "Bogus server name (%s)", host);
}
/*
* Detect protocol
*/
hop = atoi(parv[2]);
start_timestamp = atoi(parv[3]);
timestamp = atoi(parv[4]);
prot = parse_protocol(parv[5]);
if (!prot)
return exit_client_msg(cptr, sptr, &me, "Bogus protocol (%s)", parv[5]);
else if (prot < atoi(MINOR_PROTOCOL))
return exit_new_server(cptr, sptr, host, timestamp,
"Incompatible protocol: %s", parv[5]);
Debug((DEBUG_INFO, "Got SERVER %s with timestamp [%s] age %Tu (%Tu)",
host, parv[4], start_timestamp, cli_serv(&me)->timestamp));
if (timestamp < OLDEST_TS)
return exit_client_msg(cptr, sptr, &me,
"Bogus timestamps (%s %s)", parv[3], parv[4]);
if (parv[parc - 1][0] == '\0')
return exit_client_msg(cptr, cptr, &me,
"No server info specified for %s", host);
ret = check_loop_and_lh(cptr, sptr, NULL, host, (parc > 7 ? parv[6] : NULL), timestamp, hop, parv[5][0] == 'J');
if (ret != 1)
return ret;
/*
* Server is informing about a new server behind
* this link. Create REMOTE server structure,
* add it to list and propagate word to my other
* server links...
*/
acptr = make_client(cptr, STAT_SERVER);
make_server(acptr);
cli_serv(acptr)->prot = prot;
cli_serv(acptr)->timestamp = timestamp;
cli_hopcount(acptr) = hop;
ircd_strncpy(cli_name(acptr), host, HOSTLEN);
ircd_strncpy(cli_info(acptr), parv[parc-1], REALLEN);
cli_serv(acptr)->up = sptr;
cli_serv(acptr)->updown = add_dlink(&(cli_serv(sptr))->down, acptr);
/* Use cptr, because we do protocol 9 -> 10 translation
for numeric nicks ! */
SetServerYXX(cptr, acptr, parv[6]);
/* Attach any necessary UWorld config items. */
attach_confs_byhost(cptr, host, CONF_UWORLD);
if (*parv[7] == '+')
set_server_flags(acptr, parv[7] + 1);
Count_newremoteserver(UserStats);
if (Protocol(acptr) < 10)
SetFlag(acptr, FLAG_TS8);
add_client_to_list(acptr);
hAddClient(acptr);
if (*parv[5] == 'J')
{
SetBurst(acptr);
SetJunction(acptr);
for (bcptr = cli_serv(acptr)->up; !IsMe(bcptr); bcptr = cli_serv(bcptr)->up)
if (IsBurstOrBurstAck(bcptr))
break;
if (IsMe(bcptr))
sendto_opmask_butone(0, SNO_NETWORK, "Net junction: %s %s",
cli_name(sptr), cli_name(acptr));
}
/*
* Old sendto_serv_but_one() call removed because we now need to send
* different names to different servers (domain name matching).
*/
for (i = 0; i <= HighestFd; i++)
{
if (!(bcptr = LocalClientArray[i]) || !IsServer(bcptr) ||
bcptr == cptr || IsMe(bcptr))
continue;
if (0 == match(cli_name(&me), cli_name(acptr)))
continue;
sendcmdto_one(sptr, CMD_SERVER, bcptr, "%s %d 0 %s %s %s%s +%s%s%s :%s",
cli_name(acptr), hop + 1, parv[4], parv[5],
NumServCap(acptr), IsHub(acptr) ? "h" : "",
IsService(acptr) ? "s" : "", IsIPv6(acptr) ? "6" : "",
cli_info(acptr));
}
return 0;
}
#include "Tank.h"
Protocol Tank::protocol = Protocol();
Tank::Tank(){}
Tank::Tank(int i){
idx = i;
}
Tank::Tank(const Tank& orig){}
Tank::~Tank(){}
void Tank::evalPfield(GameConstants &gc,
Polygon &base,
vector<Tank*> &tanks,
vector<Flag*> &flags,
vector<Tank*> &enemy_tanks,
vector<Flag*> &enemy_flags,
vector<Polygon*> &obstacles
){
double pi = 3.1415926435;
Vector2d result = Vector2d(0);
for (int i=0; i < obstacles.size(); i++){
result += 0.4*obstacles[i]->potentialField(loc,dir);
}
/*for (int i=0; i < enemy_tanks.size(); i++)
{
result += enemy_tanks[i]->potentialField(loc,dir);
}
for (int i=0; i < enemy_flags.size(); i++)
{
result -= 30 * enemy_flags[i]->potentialField(loc,dir);
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);
}
Protocol Protocol::v6()
{
return Protocol(0);
}
