// serverbrowser.cpp: eihrul's concurrent resolver, and server browser window management
#include "cube.h"
#include "SDL_thread.h"
extern bool isdedicated;
struct resolverthread
{
SDL_Thread *thread;
const char *query;
int starttime;
};
struct resolverresult
{
const char *query;
ENetAddress address;
};
vector<resolverthread> resolverthreads;
vector<const char *> resolverqueries;
vector<resolverresult> resolverresults;
SDL_mutex *resolvermutex;
SDL_cond *querycond, *resultcond;
#define RESOLVERTHREADS 1
#define RESOLVERLIMIT 3000
int resolverloop(void * data)
{
resolverthread *rt = (resolverthread *)data;
SDL_LockMutex(resolvermutex);
SDL_Thread *thread = rt->thread;
SDL_UnlockMutex(resolvermutex);
if(!thread || SDL_GetThreadID(thread) != SDL_ThreadID())
return 0;
while(thread == rt->thread)
{
SDL_LockMutex(resolvermutex);
while(resolverqueries.empty()) SDL_CondWait(querycond, resolvermutex);
rt->query = resolverqueries.pop();
rt->starttime = totalmillis;
SDL_UnlockMutex(resolvermutex);
ENetAddress address = { ENET_HOST_ANY, ENET_PORT_ANY };
enet_address_set_host(&address, rt->query);
SDL_LockMutex(resolvermutex);
if(rt->query && thread == rt->thread)
{
resolverresult &rr = resolverresults.add();
rr.query = rt->query;
rr.address = address;
rt->query = NULL;
rt->starttime = 0;
SDL_CondSignal(resultcond);
}
SDL_UnlockMutex(resolvermutex);
}
return 0;
}
void resolverinit()
{
resolvermutex = SDL_CreateMutex();
querycond = SDL_CreateCond();
resultcond = SDL_CreateCond();
SDL_LockMutex(resolvermutex);
loopi(RESOLVERTHREADS)
{
resolverthread &rt = resolverthreads.add();
rt.query = NULL;
rt.starttime = 0;
rt.thread = SDL_CreateThread(resolverloop, &rt);
}
SDL_UnlockMutex(resolvermutex);
}
void resolverstop(resolverthread &rt)
{
SDL_LockMutex(resolvermutex);
if(rt.query)
{
#ifndef __APPLE__
SDL_KillThread(rt.thread);
#endif
rt.thread = SDL_CreateThread(resolverloop, &rt);
}
rt.query = NULL;
rt.starttime = 0;
SDL_UnlockMutex(resolvermutex);
}
void resolverclear()
{
if(resolverthreads.empty()) return;
SDL_LockMutex(resolvermutex);
resolverqueries.shrink(0);
resolverresults.shrink(0);
loopv(resolverthreads)
{
resolverthread &rt = resolverthreads[i];
resolverstop(rt);
}
SDL_UnlockMutex(resolvermutex);
}
void resolverquery(const char *name)
{
if(resolverthreads.empty()) resolverinit();
SDL_LockMutex(resolvermutex);
resolverqueries.add(name);
SDL_CondSignal(querycond);
SDL_UnlockMutex(resolvermutex);
}
bool resolvercheck(const char **name, ENetAddress *address)
{
bool resolved = false;
SDL_LockMutex(resolvermutex);
if(!resolverresults.empty())
{
resolverresult &rr = resolverresults.pop();
*name = rr.query;
address->host = rr.address.host;
resolved = true;
}
else loopv(resolverthreads)
{
resolverthread &rt = resolverthreads[i];
if(rt.query && totalmillis - rt.starttime > RESOLVERLIMIT)
{
resolverstop(rt);
*name = rt.query;
resolved = true;
}
}
SDL_UnlockMutex(resolvermutex);
return resolved;
}
extern bool isdedicated;
bool resolverwait(const char *name, ENetAddress *address)
{
if(isdedicated) return enet_address_set_host(address, name) >= 0;
if(resolverthreads.empty()) resolverinit();
defformatstring(text)("resolving %s... (esc to abort)", name);
show_out_of_renderloop_progress(0, text);
SDL_LockMutex(resolvermutex);
resolverqueries.add(name);
SDL_CondSignal(querycond);
int starttime = SDL_GetTicks(), timeout = 0;
bool resolved = false;
for(;;)
{
SDL_CondWaitTimeout(resultcond, resolvermutex, 250);
loopv(resolverresults) if(resolverresults[i].query == name)
{
address->host = resolverresults[i].address.host;
resolverresults.remove(i);
resolved = true;
break;
}
if(resolved) break;
timeout = SDL_GetTicks() - starttime;
show_out_of_renderloop_progress(min(float(timeout)/RESOLVERLIMIT, 1.0f), text);
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE) timeout = RESOLVERLIMIT + 1;
}
if(timeout > RESOLVERLIMIT) break;
}
if(!resolved && timeout > RESOLVERLIMIT)
{
loopv(resolverthreads)
{
resolverthread &rt = resolverthreads[i];
if(rt.query == name) { resolverstop(rt); break; }
}
}
SDL_UnlockMutex(resolvermutex);
return resolved;
}
SDL_Thread *connthread = NULL;
SDL_mutex *connmutex = NULL;
SDL_cond *conncond = NULL;
struct connectdata
{
ENetSocket sock;
ENetAddress address;
int result;
};
// do this in a thread to prevent timeouts
// could set timeouts on sockets, but this is more reliable and gives more control
int connectthread(void *data)
{
SDL_LockMutex(connmutex);
if(!connthread || SDL_GetThreadID(connthread) != SDL_ThreadID())
{
SDL_UnlockMutex(connmutex);
return 0;
}
connectdata cd = *(connectdata *)data;
SDL_UnlockMutex(connmutex);
int result = enet_socket_connect(cd.sock, &cd.address);
SDL_LockMutex(connmutex);
if(!connthread || SDL_GetThreadID(connthread) != SDL_ThreadID())
{
enet_socket_destroy(cd.sock);
SDL_UnlockMutex(connmutex);
return 0;
}
((connectdata *)data)->result = result;
SDL_CondSignal(conncond);
SDL_UnlockMutex(connmutex);
return 0;
}
#define CONNLIMIT 20000
int connectwithtimeout(ENetSocket sock, const char *hostname, ENetAddress &address)
{
if(isdedicated)
{
int result = enet_socket_connect(sock, &address);
if(result<0) enet_socket_destroy(sock);
return result;
}
defformatstring(text)("connecting to %s:%d... (esc to abort)", hostname, address.port);
show_out_of_renderloop_progress(0, text);
if(!connmutex) connmutex = SDL_CreateMutex();
if(!conncond) conncond = SDL_CreateCond();
SDL_LockMutex(connmutex);
connectdata cd = { sock, address, -1 };
connthread = SDL_CreateThread(connectthread, &cd);
int starttime = SDL_GetTicks(), timeout = 0;
for(;;)
{
if(!SDL_CondWaitTimeout(conncond, connmutex, 250))
{
if(cd.result<0) enet_socket_destroy(sock);
break;
}
timeout = SDL_GetTicks() - starttime;
show_out_of_renderloop_progress(min(float(timeout)/CONNLIMIT, 1.0f), text);
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE) timeout = CONNLIMIT + 1;
}
if(timeout > CONNLIMIT) break;
}
/* thread will actually timeout eventually if its still trying to connect
* so just leave it (and let it destroy socket) instead of causing problems on some platforms by killing it
*/
connthread = NULL;
SDL_UnlockMutex(connmutex);
return cd.result;
}
vector<serverinfo *> servers;
ENetSocket pingsock = ENET_SOCKET_NULL;
int lastinfo = 0;
char *getservername(int n) { return servers[n]->name; }
serverinfo *findserverinfo(ENetAddress address)
{
loopv(servers) if(servers[i]->address.host == address.host && servers[i]->port == address.port) return servers[i];
return NULL;
}
serverinfo *getconnectedserverinfo()
{
extern ENetPeer *curpeer;
if(!curpeer) return NULL;
return findserverinfo(curpeer->address);
}
static serverinfo *newserver(const char *name, uint ip = ENET_HOST_ANY, int port = CUBE_DEFAULT_SERVER_PORT, int weight = 0)
{
serverinfo *si = new serverinfo;
si->address.host = ip;
si->address.port = CUBE_SERVINFO_PORT(port);
si->msweight = weight;
if(ip!=ENET_HOST_ANY) si->resolved = serverinfo::RESOLVED;
if(name) copystring(si->name, name);
else if(ip==ENET_HOST_ANY || enet_address_get_host_ip(&si->address, si->name, sizeof(si->name)) < 0)
{
delete si;
return NULL;
}
si->port = port;
servers.insert(0, si);
return si;
}
void addserver(const char *servername, int serverport, int weight)
{
if(serverport <= 0) serverport = CUBE_DEFAULT_SERVER_PORT;
loopv(servers) if(strcmp(servers[i]->name, servername)==0 && servers[i]->port == serverport) return;
newserver(servername, ENET_HOST_ANY, serverport, weight);
}
VARP(servpingrate, 1000, 5000, 60000);
VARP(maxservpings, 0, 10, 1000);
VAR(searchlan, 0, 1, 2);
#define PINGBUFSIZE 100
static int pingbuf[PINGBUFSIZE], curpingbuf = 0;
int chooseextping(serverinfo *si)
{
if(si->getinfo != EXTPING_NOP) return si->getinfo;
if(!si->uplinkqual_age || totalmillis - si->uplinkqual_age > 60 * 1000) return EXTPING_UPLINKSTATS;
return EXTPING_NOP;
}
void pingservers(bool issearch, serverinfo *onlyconnected)
{
if(pingsock == ENET_SOCKET_NULL)
{
pingsock = enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM);
if(pingsock == ENET_SOCKET_NULL)
{
lastinfo = totalmillis;
return;
}
enet_socket_set_option(pingsock, ENET_SOCKOPT_NONBLOCK, 1);
enet_socket_set_option(pingsock, ENET_SOCKOPT_BROADCAST, 1);
}
ENetBuffer buf;
static uchar ping[MAXTRANS];
ucharbuf p(ping, sizeof(ping));
curpingbuf = (curpingbuf + 1) % PINGBUFSIZE;
pingbuf[(curpingbuf + PINGBUFSIZE / 2) % PINGBUFSIZE] = 0;
pingbuf[curpingbuf] = onlyconnected ? 0 : totalmillis;
putint(p, curpingbuf + 1); // offset by 1 to avoid extinfo trigger
int baselen = p.length();
if(onlyconnected)
{
serverinfo *si = onlyconnected;
//p.len = baselen;
if(si->getinfo == EXTPING_SERVERINFO)
{
putint(p, EXTPING_SERVERINFO);
const char *silang;
if(strlen(lang) != 2) silang = "en";
else silang = lang;
loopi(2) putint(p, silang[i]);
}
else putint(p, issearch ? EXTPING_NAMELIST : chooseextping(si));
buf.data = ping;
buf.dataLength = p.length();
enet_socket_send(pingsock, &si->address, &buf, 1);
}
else if(searchlan < 2)
{
static int lastping = 0;
if(lastping >= servers.length()) lastping = 0;
loopi(maxservpings ? min(servers.length(), maxservpings) : servers.length())
{
serverinfo &si = *servers[lastping];
if(++lastping >= servers.length()) lastping = 0;
if(si.address.host == ENET_HOST_ANY) continue;
p.len = baselen;
putint(p, issearch ? EXTPING_NAMELIST : chooseextping(&si));
buf.data = ping;
buf.dataLength = p.length();
enet_socket_send(pingsock, &si.address, &buf, 1);
}
}
if(searchlan && !onlyconnected)
{
ENetAddress address;
address.host = ENET_HOST_BROADCAST;
address.port = CUBE_SERVINFO_PORT_LAN;
p.len = baselen;
putint(p, issearch ? EXTPING_NAMELIST : EXTPING_UPLINKSTATS);
buf.data = ping;
buf.dataLength = p.length();
enet_socket_send(pingsock, &address, &buf, 1);
}
lastinfo = totalmillis;
}
void checkresolver()
{
int resolving = 0;
loopv(servers)
{
serverinfo &si = *servers[i];
if(si.resolved == serverinfo::RESOLVED) continue;
if(si.address.host == ENET_HOST_ANY)
{
if(si.resolved == serverinfo::UNRESOLVED) { si.resolved = serverinfo::RESOLVING; resolverquery(si.name); }
resolving++;
}
}
if(!resolving) return;
const char *name = NULL;
ENetAddress addr = { ENET_HOST_ANY, ENET_PORT_ANY };
while(resolvercheck(&name, &addr))
{
loopv(servers)
{
serverinfo &si = *servers[i];
if(name == si.name)
{
si.resolved = serverinfo::RESOLVED;
si.address.host = addr.host;
addr.host = ENET_HOST_ANY;
break;
}
}
}
}
#define MAXINFOLINELEN 100 // including color codes
void checkpings()
{
if(pingsock == ENET_SOCKET_NULL) return;
enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
ENetBuffer buf;
ENetAddress addr;
static uchar ping[MAXTRANS];
static char text[MAXTRANS];
buf.data = ping;
buf.dataLength = sizeof(ping);
while(enet_socket_wait(pingsock, &events, 0) >= 0 && events)
{
int len = enet_socket_receive(pingsock, &addr, &buf, 1);
if(len <= 0) return;
serverinfo *si = NULL;
loopv(servers) if(addr.host == servers[i]->address.host && addr.port == servers[i]->address.port)
{
si = servers[i];
break;
}
if(!si && searchlan) si = newserver(NULL, addr.host, CUBE_SERVINFO_TO_SERV_PORT(addr.port));
if(!si) continue;
ucharbuf p(ping, len);
si->lastpingmillis = totalmillis;
int pingtm = pingbuf[(getint(p) - 1) % PINGBUFSIZE];
if(pingtm) si->ping = totalmillis - pingtm;
int query = getint(p);
switch(query)
{ // cleanup additional query info
case EXTPING_SERVERINFO:
loopi(2) getint(p);
break;
}
si->protocol = getint(p);
if(si->protocol!=PROTOCOL_VERSION) si->ping = 9998;
si->mode = getint(p);
si->muts = getint(p);
si->numplayers = getint(p);
si->minremain = getint(p);
getstring(text, p);
filtertext(si->map, text, 1);
getstring(text, p);
filterservdesc(si->sdesc, text);
copystring(si->description, si->sdesc);
si->maxclients = getint(p);
if(p.remaining())
{
si->pongflags = getint(p);
if(p.remaining() && getint(p) == query)
{
switch(query)
{
#define RESETINFOLINES() si->infotexts.setsize(0); \
ucharbuf q(si->textdata, sizeof(si->textdata))
#define ADDINFOLINE(msg) si->infotexts.add((char *)si->textdata + q.length()); \
sendstring(msg, q)
case EXTPING_NAMELIST:
{
si->playernames.setsize(0);
ucharbuf q(si->namedata, sizeof(si->namedata));
loopi(si->numplayers)
{
getstring(text, p);
filtertext(text, text, 0);
if(text[0] && !p.overread())
{
si->playernames.add((const char *)si->namedata + q.length());
sendstring(text, q);
}
else break;
}
break;
}
case EXTPING_SERVERINFO:
{
RESETINFOLINES();
getstring(text, p);
if(strlen(text) != 2)
{
ADDINFOLINE("this server does not provide additional information");
break;
}
strcpy(si->lang, text);
while(p.remaining())
{
getstring(text, p);
if(*text && !p.overread())
{
text[MAXINFOLINELEN] = '\0';
cutcolorstring(text, 80);
ADDINFOLINE(strcmp(text, ".") ? text : "");
}
else break;
}
break;
}
case EXTPING_MAPROT:
{
RESETINFOLINES();
int n = getint(p);
ADDINFOLINE("\f1server map rotation:");
ADDINFOLINE("");
while(p.remaining())
{
getstring(text, p);
filtertext(text, text, 0);
if(*text && !p.overread())
{
text[MAXINFOLINELEN] = '\0';
loopi(n) concatformatstring(text, ", %d", getint(p));
ADDINFOLINE(text );
}
else break;
}
break;
}
case EXTPING_UPLINKSTATS:
{
si->uplinkqual_age = totalmillis;
//if(si->maxclients > 3)
{
int maxs = 0, maxc = 0, ts, tc;
loopi(min(si->maxclients, MAXCLIENTS))
{
ts = tc = si->uplinkstats[i] = p.get();
if(si->maxclients < 8 || i > 2)
{
ts &= 0xF0; tc &= 0x0F;
if(ts > maxs) maxs = ts;
if(ts > 0x40 && tc > maxc) maxc = tc; // spent time = 2 ^ ((ts >> 4) - 1) * 30 sec, so 0x50 is 8..15 minutes
}
}
if(maxs < 0x90) maxc -= 2; // go easy on fresh started servers
if(maxs < 0x50) si->uplinkqual = 3;
else if(maxc < 3) si->uplinkqual = 5; // choke_percentage = 1 / 2 ^ (15 - tc), so 0x03 is 0.02%
else if(maxc < 6) si->uplinkqual = 4; // 0.2%
else if(maxc == 6) si->uplinkqual = 3;
else if(maxc < 9) si->uplinkqual = 2; // 1.6% (yep, that IS bad)
else si->uplinkqual = 1;
}
if(si->getinfo == EXTPING_UPLINKSTATS)
{
RESETINFOLINES();
/*
if(si->maxclients < 4)
{
ADDINFOLINE("server is too small for uplink quality statistics");
}
else
*/
{
ADDINFOLINE("\f1server uplink quality and usage statistics:");
ADDINFOLINE("");
ADDINFOLINE("players:\terrors/time");
loopi(min(si->maxclients, MAXCLIENTS))
{
defformatstring(msg)(" %d\t", i + 1);
loopj(15) concatformatstring(msg, "\a%c ", '0' + ((si->uplinkstats[i] & 0x0F) > j) + 2 * ((si->uplinkstats[i] & 0xF0) > (j << 4)));
concatformatstring(msg, "\t\t [%02X]", si->uplinkstats[i]);
ADDINFOLINE(msg);
}
ADDINFOLINE("");
ADDINFOLINE("\f4red bar: error rate, green bar: time played");
}
}
break;
}
#undef RESETINFOLINES
#undef ADDINFOLINE
}
}
}
else
{
si->pongflags = 0;
}
if(si->getinfo == query) si->getinfo = EXTPING_NOP;
if(si->pongflags > 0 || si->protocol!=PROTOCOL_VERSION)
{
formatstring(si->description)("%s \f1(", si->sdesc);
bool first = true;
#define addserverdesc(sp) { if(first) first = false; else concatstring(si->description, ", "); concatstring(si->description, sp); }
if(si->protocol!=PROTOCOL_VERSION)
{
if(si->protocol < 0)
addserverdesc("modded");
if(si->protocol != -PROTOCOL_VERSION)
addserverdesc(abs(si->protocol) < PROTOCOL_VERSION ? "older protocol" : "newer protocol")
}
int mm = si->pongflags >> PONGFLAG_MASTERMODE;
if (si->pongflags & (1 << PONGFLAG_BANNED))
addserverdesc("temp-banned")
if (si->pongflags & (1 << PONGFLAG_BLACKLIST))
addserverdesc("blacklisted")
if (si->pongflags & (1 << PONGFLAG_PASSWORD))
addserverdesc("password-protected")
if (mm)
addserverdesc(mmfullname(mm))
if (si->pongflags & (1 << PONGFLAG_BYPASSBANS))
addserverdesc("ignores global bans")
if (si->pongflags & (1 << PONGFLAG_BYPASSPRIV))
addserverdesc("ignores auth")
concatstring(si->description, ")");
#undef addserverdesc
}
}
}
enum { SBS_PING = 0, SBS_NUMPL, SBS_MAXPL, SBS_MINREM, SBS_MAP, SBS_MODE, SBS_IP, SBS_DESC, NUMSERVSORT };
VARP(serversort, 0, 0, NUMSERVSORT-1);
VARP(serversortdir, 0, 0, 1);
VARP(showonlygoodservers, 0, 0, 1);
VAR(shownamesinbrowser, 0, 0, 1);
VARP(showminremain, 0, 1, 1);
VARP(serversortpreferofficial, 0, 1, 1);
void serversortprepare()
{
loopv(servers)
{
serverinfo &si = *servers[i];
// basic group weights: used(700) - empty(500) - unusable(200)
if(si.protocol != PROTOCOL_VERSION) si.weight += 200;
else if(!si.numplayers) si.weight += 500;
else
{
si.weight += 700;
if(serversortpreferofficial && securemapcheck(si.map, false)) si.weight += 100;
}
si.weight += si.msweight;
}
}
int sicompare(serverinfo **ap, serverinfo **bp)
{
serverinfo *a = *ap, *b = *bp;
int dir = serversortdir ? -1 : 1;
if(a->weight > b->weight) return -dir;
if(a->weight < b->weight) return dir;
enet_uint32 ai = ENET_NET_TO_HOST_32(a->address.host), bi = ENET_NET_TO_HOST_32(b->address.host);
int ips = ai < bi ? -dir : (ai > bi ? dir : 0); // most steady base sorting
switch(serversort)
{
case SBS_NUMPL: // player number
if(a->numplayers < b->numplayers) return dir;
if(a->numplayers > b->numplayers) return -dir;
break;
case SBS_MAXPL: // maxplayers
if(a->maxclients < b->maxclients) return dir;
if(a->maxclients > b->maxclients) return -dir;
break;
case SBS_MINREM: // minutes remaining
if(a->minremain < b->minremain) return dir;
if(a->minremain > b->minremain) return -dir;
break;
case SBS_DESC: // description
{
static string ad, bd;
filtertext(ad, a->sdesc);
filtertext(bd, b->sdesc);
if(!ad[0] && bd[0]) return dir;
if(ad[0] && !bd[0]) return -dir;
int mdir = dir * strcasecmp(ad, bd);
if(mdir) return mdir;
break;
}
case SBS_IP: // IP
if(ips) return ips;
break;
case SBS_MAP: // map
{
int mdir = dir * strcasecmp(a->map, b->map);
if(mdir) return mdir;
break;
}
case SBS_MODE: // mode
{
const char *am = modestr(a->mode, a->muts, modeacronyms > 0), *bm = modestr(b->mode, b->muts, modeacronyms > 0);
int mdir = dir * strcasecmp(am, bm);
if(mdir) return mdir;
break;
}
}
if(serversort == SBS_PING || (!a->numplayers && !b->numplayers)) // ping
{
if(a->ping > b->ping) return dir;
if(a->ping < b->ping) return -dir;
}
if(ips) return ips;
if(a->port > b->port) return dir;
else return -dir;
}
gmenu *servmenu = NULL, *searchmenu = NULL, *serverinfomenu = NULL;
vector<char *> namelists;
string cursearch, cursearchuc;
void searchnickname(const char *name)
{
if(!name || !name[0]) return;
copystring(cursearch, name);
copystring(cursearchuc, name);
strtoupper(cursearchuc);
showmenu("search");
}
COMMAND(searchnickname, "s");
VAR(showallservers, 0, 1, 1);
bool matchplayername(const char *name)
{
static string nameuc;
copystring(nameuc, name);
strtoupper(nameuc);
return strstr(nameuc, cursearchuc) != NULL;
}
VARP(serverbrowserhideip, 0, 2, 3);
VARP(serverbrowserhidefavtag, 0, 1, 2);
VAR(showweights, 0, 0, 1);
VARP(hidefavicons, 0, 0, 1);
vector<char *> favcats;
const char *fc_als[] = { "weight", "tag", "desc", "red", "green", "blue", "alpha", "keys", "ignore", "image" };
enum { FC_WEIGHT = 0, FC_TAG, FC_DESC, FC_RED, FC_GREEN, FC_BLUE, FC_ALPHA, FC_KEYS, FC_IGNORE, FC_IMAGE, FC_NUM };
VARF(showonlyfavourites, 0, 0, 100,
{
if(showonlyfavourites > favcats.length())
{
conoutf("showonlyfavourites: %d out of range (0..%d)", showonlyfavourites, favcats.length());
showonlyfavourites = 0;
}
});
const char *favcatargname(const char *refdes, int par)
{
static string text[3];
static int i = 0;
if(par < 0 || par >= FC_NUM) return NULL;
i = (i + 1) % 3;
formatstring(text[i])("sbfavourite_%s_%s", refdes, fc_als[par]);
return text[i];
}
void addfavcategory(const char *refdes)
{
string text, val;
char alx[FC_NUM];
if(!refdes) { intret(0); return; }
filtertext(text, refdes);
if(!text[0]) { intret(0); return; }
loopv(favcats) if(!strcmp(favcats[i], text)) { intret(i + 1); return; }
favcats.add(newstring(text));
bool oldpersist = per_idents;
per_idents = false; // only keep changed values
loopi(FC_NUM) alx[i] = getalias(favcatargname(text, i)) ? 1 : 0;
loopi(3)
{
formatstring(val)("%d", *text & (1 << i) ? 90 : 10);
if(!alx[i + FC_RED]) alias(favcatargname(text, i + FC_RED), val);
}
formatstring(val)("favourites %d", favcats.length());
const int defk[] = { FC_WEIGHT, FC_DESC, FC_TAG, FC_KEYS, FC_IGNORE, FC_ALPHA };
const char *defv[] = { "0", val, refdes, "", "", "20" };
loopi(sizeof(defk)/sizeof(defk[0])) { if(!alx[defk[i]]) alias(favcatargname(text, defk[i]), defv[i]); }
per_idents = oldpersist;
intret(favcats.length());
}
void listfavcats()
{
const char *str = conc(&favcats[0], favcats.length(), true);
result(str);
delete [] str;
}
bool favcatcheckkey(serverinfo &si, const char *key)
{ // IP:port, #gamemode ,%mapname, desc
string text, keyuc;
if(isdigit(*key)) // IP
{
formatstring(text)("%s:%d", si.name, si.port);
return !strncmp(text, key, strlen(key));
}
else if(si.address.host != ENET_HOST_ANY && si.ping != 9999) switch(*key)
{
case '#':
return si.map[0] && si.mode == atoi(key + 1);
case '%':
strtoupper(text, si.map);
strtoupper(keyuc, key + 1);
return si.map[0] && key[1] && strstr(text, keyuc);
case '>':
return si.ping > atoi(key + 1);
case '!':
return !favcatcheckkey(si, key + 1);
case '+':
return si.map[0] && favcatcheckkey(si, key + 1);
case '$':
if(key[1])
{
formatstring(text)("%s \"%s\" %d %d, %d %d %d \"%s\" %d %d", key + 1, si.map, si.mode, si.ping, si.minremain, si.numplayers, si.maxclients, si.name, si.port, si.pongflags);
filtertext(text, text, 1);
int cnt = 0;
for(const char *p = text; (p = strchr(p, '\"')); p++) cnt++;
return cnt == 4 && execute(text);
}
break;
default:
filtertext(text, si.sdesc);
return *key && strstr(text, key);
}
return false;
}
const char *favcatcheck(serverinfo &si, const char *ckeys, char *autokeys = NULL)
{
if(!ckeys) return NULL;
static char *nkeys = NULL;
const char *sep = " \t\n\r";
char *keys = newstring(ckeys), *k = strtok(keys, sep);
bool res = false;
DELETEA(nkeys);
nkeys = newstring(strlen(ckeys));
nkeys[0] = '\0';
while(k)
{
if(favcatcheckkey(si, k))
{
res = true;
if(autokeys && !(isdigit(*k) && strchr(k, ':'))) concatformatstring(autokeys, *autokeys ? " %s" : "%s", k);
}
else
{
if(*nkeys) strcat(nkeys, " ");
strcat(nkeys, k);
}
k = strtok(NULL, sep);
}
delete[] keys;
return res ? nkeys : NULL;
}
vector<const char *> favcattags;
bool assignserverfavourites()
{
int alxn[FC_NUM];
const char *alx[FC_NUM], *sep = " \t\n\r";
favcattags.setsize(0);
bool res = false;
loopv(servers) { servers[i]->favcat = -1; servers[i]->weight = 0; }
loopvj(favcats)
{
loopi(FC_NUM) { alx[i] = getalias(favcatargname(favcats[j], i)); alxn[i] = alx[i] ? atoi(alx[i]) : 0; }
favcattags.add(alx[FC_TAG]);
bool showonlythiscat = j == showonlyfavourites - 1;
char *keys = newstring(alx[FC_KEYS]), *k = strtok(keys, sep);
while(k)
{
loopv(servers)
{
serverinfo &si = *servers[i];
if(si.address.host == ENET_HOST_ANY || si.ping == 9999 || si.protocol != PROTOCOL_VERSION) continue;
if((!alxn[FC_IGNORE] || showonlythiscat) && favcatcheckkey(si, k))
{
si.weight += alxn[FC_WEIGHT];
res = true;
if(si.favcat == -1 || showonlythiscat)
{
si.favcat = j;
if(alxn[FC_ALPHA])
{
if (!si.bgcolor) si.bgcolor = new color(0, 0, 0);
new (si.bgcolor) color(((float)alxn[FC_RED]) / 100, ((float)alxn[FC_GREEN]) / 100, ((float)alxn[FC_BLUE]) / 100, ((float)alxn[FC_ALPHA]) / 100);
}
}
}
}
k = strtok(NULL, sep);
}
delete[] keys;
}
loopv(servers) if(servers[i]->favcat == -1)
{
DELETEP(servers[i]->bgcolor);
}
return res;
}
COMMAND(addfavcategory, "s");
COMMAND(listfavcats, "");
static serverinfo *lastselectedserver = NULL;
static bool pinglastselected = false;
VAR(masterserver_flags, 0, 0, 7);
void refreshservers(gmenu *menu, bool init)
{
static int servermenumillis;
static bool usedselect = false;
static string title;
bool issearch = menu == searchmenu;
bool isinfo = menu == serverinfomenu;
bool isscoreboard = menu == NULL;
serverinfo *curserver = getconnectedserverinfo(), *oldsel = NULL;
if(init)
{
loopi(PINGBUFSIZE) if(pingbuf[i] < totalmillis) pingbuf[i] = 0;
if(resolverthreads.empty()) resolverinit();
else resolverclear();
loopv(servers) resolverquery(servers[i]->name);
servermenumillis = totalmillis;
usedselect = false;
if(menu && curserver) oldsel = curserver;
}
checkresolver();
checkpings();
if(isinfo)
{
if(lastselectedserver)
{
bool found = false;
loopv(servers) if(lastselectedserver == servers[i]) { found = true; break; }
if(!found) lastselectedserver = NULL;
}
menutitle(menu, "extended server information (F5: refresh)");
menureset(menu);
static string infotext;
static char dummy = '\0';
if(lastselectedserver)
{
serverinfo &si = *lastselectedserver;
formatstring(si.full)("%s:%d %s", si.name, si.port, si.sdesc);
menumanual(menu, si.full);
menumanual(menu, &dummy);
if(si.infotexts.length() && !pinglastselected)
{
infotext[0] = '\0';
loopv(si.infotexts) menuimagemanual(menu, NULL, "bargraphs", si.infotexts[i]);
}
else
{
copystring(infotext, "-- waiting for server response --");
if(si.getinfo == EXTPING_NOP) si.getinfo = EXTPING_SERVERINFO;
if(init || pinglastselected || totalmillis - lastinfo >= servpingrate) pingservers(false, lastselectedserver);
pinglastselected = false;
}
}
else
copystring(infotext, " -- no server selected --");
if(*infotext) menumanual(menu, infotext);
return;
}
if((init && issearch) || totalmillis - lastinfo >= (servpingrate * (issearch ? 2 : 1))/(maxservpings ? max(1, (servers.length() + maxservpings - 1) / maxservpings) : 1))
pingservers(issearch, isscoreboard ? curserver : NULL);
if(!init && menu)// && servers.inrange(menu->menusel))
{
serverinfo *foundserver = NULL;
loopv(servers) if(servers[i]->menuline_from == menu->menusel && servers[i]->menuline_to > servers[i]->menuline_from) { foundserver = servers[i]; break; }
if(foundserver)
{
if((usedselect || menu->menusel > 0)) oldsel = foundserver;
lastselectedserver = foundserver;
}
}
if(isscoreboard) lastselectedserver = curserver;
bool showfavtag = (assignserverfavourites() || !serverbrowserhidefavtag) && serverbrowserhidefavtag != 2;
serversortprepare();
servers.sort(sicompare);
if(menu)
{
static const char *titles[NUMSERVSORT] =
{
"%s\fs\f0ping\fr\tplr\tserver%s%s", // 0: ping
"%sping\t\fs\f0plr\fr\tserver%s%s", // 1: player number
"%sping\tplr\tserver (\fs\f0max players\fr)%s%s", // 2: maxplayers
"%sping\tplr\fs\f0\fr\tserver (\fs\f0minutes remaining\fr)%s%s", // 3: minutes remaining
"%sping\tplr\tserver (\fs\f0map\fr)%s%s", // 4: map
"%sping\tplr\tserver (\fs\f0game mode\fr)%s%s", // 5: mode
"%sping\tplr\tserver (\fs\f0IP\fr)%s%s", // 6: IP
"%sping\tplr\tserver (\fs\f0description\fr)%s%s" // 7: description
};
bool showmr = showminremain || serversort == SBS_MINREM;
formatstring(title)(titles[serversort], showfavtag ? "fav\t" : "", issearch ? " search results for \f3" : " (F1: Help/Settings)", issearch ? cursearch : "");
// master-server flags
if(masterserver_flags)
{
if(masterserver_flags & 1)
concatstring(title, "\n\f0your IP is whitelisted");
else if(masterserver_flags & 2)
concatstring(title, "\n\f3your IP is globally banned! prepare AUTH!");
else if(masterserver_flags & 4)
concatstring(title, "\n\f2you are globally muted!");
}
menutitle(menu, title);
menureset(menu);
string text;
int curnl = 0;
bool sbconnectexists = identexists("sbconnect");
loopv(servers)
{
serverinfo &si = *servers[i];
si.menuline_to = si.menuline_from = menu->items.length();
if( !showallservers && si.lastpingmillis < servermenumillis ) continue; // no pong yet
int banned = ((si.pongflags >> PONGFLAG_BANNED) & 1) | ((si.pongflags >> (PONGFLAG_BLACKLIST - 1)) & 2);
bool showthisone = !(banned && showonlygoodservers) && !(showonlyfavourites > 0 && si.favcat != showonlyfavourites - 1);
bool serverfull = si.numplayers >= si.maxclients;
bool needspasswd = (si.pongflags & (1 << PONGFLAG_PASSWORD)) > 0;
int mmode = (si.pongflags >> PONGFLAG_MASTERMODE) & MM_MASK;
char basecolor = si.protocol!=PROTOCOL_VERSION ? '7' : banned ? '4' : (curserver == servers[i] ? '1' : '5');
char plnumcolor = serverfull ? '2' : (needspasswd ? '3' : (mmode != MM_OPEN ? '1' : basecolor));
const char *favimage = NULL;
defformatstring(serverportpart)((serverbrowserhideip >= 3 || (serverbrowserhideip == 2 && si.port != CUBE_DEFAULT_SERVER_PORT)) ? ":%d" : "", si.port);
if(si.address.host != ENET_HOST_ANY && si.ping != 9999)
{
if(si.protocol!=PROTOCOL_VERSION && showonlygoodservers)
{
// we still show descriptions of older/newer/modded servers
showthisone = false;
}
else
{
if(!hidefavicons && showfavtag && si.favcat > -1) favimage = getalias(favcatargname(favcats[si.favcat], FC_IMAGE));
filterrichtext(text, si.favcat > -1 && !favimage ? favcattags[si.favcat] : "");
if(showweights) concatformatstring(text, "(%d)", si.weight);
formatstring(si.full)(showfavtag ? (favimage ? "\t" : "\fs%s\fr\t") : "", text);
concatformatstring(si.full, "\fs\f%c%s\t\fs\f%c%d/%d\fr\t\a%c %s", basecolor, colorping(si.ping), plnumcolor, si.numplayers, si.maxclients, '0' + si.uplinkqual, si.pongflags & ((1 << PONGFLAG_BYPASSBANS) | (1 << PONGFLAG_BYPASSPRIV)) ? "! " : "");
if(si.map[0])
{
concatformatstring(si.full, "%s, %s", si.map, modestr(si.mode, si.muts, modeacronyms > 0));
if(showmr) concatformatstring(si.full, ", (%d)", si.minremain);
}
else concatformatstring(si.full, "empty");
concatformatstring(si.full, !serverbrowserhideip ? ": " : ": %s%s", si.name, serverportpart);
concatformatstring(si.full, "\fr %s", si.sdesc);
}
}
else
{
if(!showonlygoodservers) formatstring(si.full)("%s%s [%s]", si.name, serverportpart, si.address.host != ENET_HOST_ANY ? "waiting for server response" : "unknown host");
else showthisone = false;
}
if(issearch && showthisone)
{
bool found = false;
loopvj(si.playernames) if(matchplayername(si.playernames[j])) { found = true; break; };
if(!found) showthisone = false;
}
if(showthisone)
{
cutcolorstring(si.full, 76); // cut off too long server descriptions
cutcolorstring(si.description, 76);
if(sbconnectexists)
{
filtertext(text, si.sdesc);
for(char *p = text; (p = strchr(p, '\"')); *p++ = ' ');
text[30] = '\0';
formatstring(si.cmd)("sbconnect %s %d %d %d %d %d \"%s\"", si.name, si.port, serverfull ?1:0, needspasswd ?1:0, mmode, banned, text);
}
else formatstring(si.cmd)("connect %s %d", si.name, si.port);
menuimagemanual(menu, favimage, "serverquality", si.full, si.cmd, si.bgcolor, si.description);
if(!issearch && servers[i] == oldsel)
{
menu->menusel = menu->items.length() - 1;
usedselect = true;
if(shownamesinbrowser) si.getinfo = EXTPING_NAMELIST;
}
if((shownamesinbrowser && servers[i] == oldsel && si.playernames.length()) || issearch)
{
int cur = 0;
char *t = NULL;
loopvj(si.playernames)
{
if(cur == 0)
{
if(namelists.length() < ++curnl) namelists.add(newstringbuf());
t = namelists[curnl - 1];
copystring(t, showfavtag ? "\t\t" : "\t");
}
concatformatstring(t, " \t\fs%s%s\fr", !issearch || matchplayername(si.playernames[j]) ? "" : "\f4" ,si.playernames[j]);
cur++;
if(cur == 4)
{
menumanual(menu, t, NULL, NULL, NULL);
cur = 0;
}
}
if(cur) menumanual(menu, t, NULL, NULL, NULL);
}
}
si.menuline_to = menu->items.length();
}
static string notfoundmsg;
if(issearch)
{
if(curnl == 0)
{
formatstring(notfoundmsg)("\t\tpattern \fs\f3%s\fr not found.", cursearch);
menumanual(menu, notfoundmsg, NULL, NULL, NULL);
}
}
else if(!menu->items.length() && showonlyfavourites && favcats.inrange(showonlyfavourites - 1))
{
const char *desc = getalias(favcatargname(favcats[showonlyfavourites - 1], FC_DESC));
formatstring(notfoundmsg)("no servers in category \f2%s", desc ? desc : favcattags[showonlyfavourites - 1]);
menumanual(menu, notfoundmsg, NULL, NULL, NULL);
}
}
}
bool serverskey(gmenu *menu, int code, bool isdown, int unicode)
{
const int fk[] = { SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6, SDLK_7, SDLK_8, SDLK_9, SDLK_0 };
if(!isdown) return false;
ASSERT(menu);
loopi(sizeof(fk)/sizeof(fk[0])) if(code == fk[i] && favcats.inrange(i))
{
int sel = menu->menusel;
loopvj(servers) if(servers[j]->menuline_from <= sel && servers[j]->menuline_to > sel)
{
string ak; ak[0] = '\0';
const char *keyalias = favcatargname(favcats[i], FC_KEYS), *key = getalias(keyalias), *rest = favcatcheck(*servers[j], key, ak), *desc = getalias(favcatargname(favcats[i], FC_DESC));
if(!desc) desc = "";
if(*ak)
{ // server was automatically added to this favourite group, don't remove
conoutf(_("server \"%cs%s%cr\" is in category '%cs%s%cr' because of key '%s', please remove manually"), CC, servers[j]->sdesc, CC, CC, desc, CC, ak);
}
else if(rest)
{ // remove from favourite group
conoutf(_("removing server \"%cs%s%cr\" from favourites category '%cs%s%cr' (rest '%s')"), CC, servers[j]->sdesc, CC, CC, desc, CC, rest);
alias(keyalias, rest);
}
else
{ // add IP:port to group
defformatstring(text)("%s:%d", servers[j]->name, servers[j]->port);
if(key && *key)
{
char *newkey = newstring(key, strlen(text) + 1 + strlen(key));
strcat(newkey, " ");
strcat(newkey, text);
alias(keyalias, newkey);
delete[] newkey;
}
else alias(keyalias, text);
conoutf(_("adding server \"%cs%s%cr\" to favourites category '%cs%s%cr' (new '%s')"), CC, servers[j]->sdesc, CC, CC, desc, CC, getalias(keyalias));
}
return true;
}
}
switch(code)
{
case SDLK_HOME:
menu->menusel = 0;
return true;
case SDLK_LEFT:
serversort = (serversort+NUMSERVSORT-1) % NUMSERVSORT;
return true;
case SDLK_RIGHT:
serversort = (serversort+1) % NUMSERVSORT;
return true;
case SDLK_F5:
updatefrommaster(1);
return true;
case SDLK_F6:
serversortdir = serversortdir ? 0 : 1;
return true;
case SDLK_F9:
showmenu("serverinfo");
return true;
}
if(menu == searchmenu) return false;
switch(code)
{
case SDLK_F1:
showmenu("serverbrowser help");
return true;
case SDLK_F2:
shownamesinbrowser = shownamesinbrowser ? 0 : 1;
return true;
case SDLK_F3:
showmenu("search player");
return true;
case SDLK_F4:
showmenu("edit favourites");
return true;
case SDLK_F7:
showonlygoodservers = showonlygoodservers ? 0 : 1;
return true;
case SDLK_F8:
showminremain = showminremain ? 0 : 1;
return true;
}
return false;
}
bool serverinfokey(gmenu *menu, int code, bool isdown, int unicode)
{
if(!isdown) return false;
switch(code)
{
case SDLK_HOME:
if(menu) menu->menusel = 0;
return true;
case SDLK_F5:
if(lastselectedserver) lastselectedserver->getinfo = EXTPING_SERVERINFO;
pinglastselected = true;
return true;
case SDLK_F1:
showmenu("serverinfo help"); // feel free to actually write this menu ;)
return true;
case SDLK_F2: // yep: undocumented :)
if(lastselectedserver) lastselectedserver->getinfo = EXTPING_UPLINKSTATS;
pinglastselected = true;
break;
case SDLK_m:
if(lastselectedserver) lastselectedserver->getinfo = EXTPING_MAPROT;
pinglastselected = true;
break;
}
return false;
}
void clearservers()
{
resolverclear();
servers.deletecontents();
}
#define RETRIEVELIMIT 5000
extern char *global_name;
struct resolver_data
{
int timeout, starttime;
string text;
};
static int progress_callback(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow)
{
resolver_data *rd = (resolver_data *)clientp;
rd->timeout = SDL_GetTicks() - rd->starttime;
show_out_of_renderloop_progress(min(float(rd->timeout)/RETRIEVELIMIT, 1.0f), rd->text);
if(interceptkey(SDLK_ESCAPE))
{
loadingscreen();
return 1;
}
return 0;
}
static size_t write_callback(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
return fwrite(ptr, size, nmemb, stream);
}
void retrieveservers(vector<char> &data)
{
string request;
sprintf(request, "http://%s:%u%s/c?build_defs=%d&guid32=%lu", masterbase, masterport, masterpath, getbuildtype(), *&genguid(234534, 546456456U, 345345453, "3458739874jetrgjk"));
const char *tmpname = findfile(path("config/servers.cfg", true), "wb");
FILE *outfile = fopen(tmpname, "w+");
if(!outfile)
{
conoutf("\f3cannot write server list");
return;
}
resolver_data *rd = new resolver_data();
formatstring(rd->text)("retrieving servers from %s%s:%d... (esc to abort)", masterbase, masterpath, masterport);
show_out_of_renderloop_progress(0, rd->text);
rd->starttime = SDL_GetTicks();
rd->timeout = 0;
CURL *curl = curl_easy_init();
int result = 0, httpresult = 0;
curl_easy_setopt(curl, CURLOPT_URL, request);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); // Fixes crashbug for some buggy libcurl versions (Linux)
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, outfile);
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progress_callback);
curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rd);
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, RETRIEVELIMIT/1000);
result = curl_easy_perform(curl);
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpresult);
curl_easy_cleanup(curl);
curl = NULL;
if(outfile) fclose(outfile);
if(!result && httpresult == 200)
{
int size = 0;
char *content = loadfile(path("config/servers.cfg", true), &size);
data.shrink(0);
data.insert(0, content, size);
if(data.length()) data.add('\0');
}
DELETEP(rd);
}
VARP(masterupdatefrequency, 1, 60*60, 24*60*60);
void updatefrommaster(int force)
{
static int lastupdate = 0;
if(!force && lastupdate && totalmillis-lastupdate<masterupdatefrequency*1000) return;
vector<char> data;
retrieveservers(data);
if(data.empty())
{
conoutf("Master server is not replying. \f1Get more information at http://ms.acr.victorz.ca/bans");
}
else
{
// preserve currently connected server from deletion
serverinfo *curserver = getconnectedserverinfo();
string curname;
if(curserver) copystring(curname, curserver->name);
clearservers();
execute(data.getbuf());
if(curserver) addserver(curname, curserver->port, curserver->msweight);
lastupdate = totalmillis;
}
}
COMMANDF(addserver, "sii", (char *n, int *p, int *w) { addserver(n, *p, *w); });
COMMAND(clearservers, "");
COMMANDF(updatefrommaster, "i", (int *f) { updatefrommaster(*f); });
void writeservercfg()
{
stream *f = openfile(path("config/servers.cfg", true), "w");
if(!f) return;
f->printf("// servers connected to are added here automatically\n");
loopvrev(servers)
{
f->printf("\naddserver %s %d", servers[i]->name, servers[i]->port);
if(servers[i]->msweight) f->printf(" %d", servers[i]->msweight);
}
f->printf("\n");
delete f;
}
Advertisement
153
pages
Serverbrowser.cpp
Advertisement
