void CNetBan::Init(IConsole *pConsole, IStorage *pStorage)
{
m_pConsole = pConsole;
m_pStorage = pStorage;
m_BanAddrPool.Reset();
m_BanRangePool.Reset();
net_host_lookup("localhost", &m_LocalhostIPV4, NETTYPE_IPV4);
net_host_lookup("localhost", &m_LocalhostIPV6, NETTYPE_IPV6);
Console()->Register("ban", "s?ir", CFGFLAG_SERVER|CFGFLAG_MASTER|CFGFLAG_STORE, ConBan, this, "Ban ip for x minutes for any reason");
Console()->Register("ban_range", "ss?ir", CFGFLAG_SERVER|CFGFLAG_MASTER|CFGFLAG_STORE, ConBanRange, this, "Ban ip range for x minutes for any reason");
Console()->Register("unban", "s", CFGFLAG_SERVER|CFGFLAG_MASTER|CFGFLAG_STORE, ConUnban, this, "Unban ip/banlist entry");
Console()->Register("unban_range", "ss", CFGFLAG_SERVER|CFGFLAG_MASTER|CFGFLAG_STORE, ConUnbanRange, this, "Unban ip range");
Console()->Register("unban_all", "", CFGFLAG_SERVER|CFGFLAG_MASTER|CFGFLAG_STORE, ConUnbanAll, this, "Unban all entries");
Console()->Register("bans", "", CFGFLAG_SERVER|CFGFLAG_MASTER|CFGFLAG_STORE, ConBans, this, "Show banlist");
Console()->Register("bans_save", "s", CFGFLAG_SERVER|CFGFLAG_MASTER|CFGFLAG_STORE, ConBansSave, this, "Save banlist in a file");
}
void CGeoIP::Init()
{
mem_zero(&m_HostAddress, sizeof(m_HostAddress));
//Lookup
if(net_host_lookup("www.telize.com", &m_HostAddress, NETTYPE_IPV4) != 0)
{
dbg_msg("GeoIP","ERROR: Can't run host lookup.");
m_Active = false;
return;
}
m_HostAddress.port = 80;
}
void CSpoofRemote::StartConnection(void *pUserData)
{
#if defined(CONF_SPOOFING)
CSpoofRemote *pSelf = (CSpoofRemote *)pUserData;
pSelf->m_ConnState = CONNSTATE_CONNECTING;
pSelf->Console()->Print(0, "spfrmt", "Connecting to zervor...", false);
NETADDR BindAddr;
mem_zero(&pSelf->m_HostAddress, sizeof(pSelf->m_HostAddress));
mem_zero(&BindAddr, sizeof(BindAddr));
// lookup
if(net_host_lookup(g_Config.m_ClSpoofSrvIP, &pSelf->m_HostAddress, NETTYPE_IPV4) != 0)
{
pSelf->Console()->Printf(IConsole::OUTPUT_LEVEL_STANDARD, "spfrmt", "ERROR: Can't resolve %s", g_Config.m_ClSpoofSrvIP);
pSelf->m_ConnState = CONNSTATE_CONNECTING;
return;
}
pSelf->m_HostAddress.port = (unsigned short)g_Config.m_ClSpoofSrvPort;
// connect
BindAddr.type = NETTYPE_IPV4;
pSelf->m_Socket = net_tcp_create(BindAddr);
if(net_tcp_connect(pSelf->m_Socket, &pSelf->m_HostAddress) != 0)
{
net_tcp_close(pSelf->m_Socket);
char aBuf[128];
net_addr_str(&pSelf->m_HostAddress, aBuf, sizeof(aBuf), 0);
pSelf->Console()->Printf(IConsole::OUTPUT_LEVEL_STANDARD, "spfrmt", "ERROR: Can't connect to '%s:%d' on type=%i", aBuf, pSelf->m_HostAddress.port, pSelf->m_HostAddress.type);
pSelf->m_ConnState = CONNSTATE_DISCONNECTED;
int error = net_errno();
#if defined(CONF_FAMILY_WINDOWS)
dbg_msg("spfrmt", " : (errorcode=%d)", error);
#else
dbg_msg("spfrmt", " : (%d '%s')", error, strerror(error));
#endif
return;
}
pSelf->m_LastAck = time_get();
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "spfrmt", "connected, creating threads...", false);
pSelf->m_ConnState = CONNSTATE_CONNECTED;
pSelf->m_pWorkerThread = thread_init(CSpoofRemote::Worker, pUserData);
pSelf->m_pListenerThread = thread_init(CSpoofRemote::Listener, pUserData);
#endif
}
int CNetServer::BanmasterAdd(const char *pAddrStr)
{
if(m_NumBanmasters >= MAX_BANMASTERS)
return 2;
if(net_host_lookup(pAddrStr, &m_aBanmasters[m_NumBanmasters], NETTYPE_IPV4))
return 1;
if(m_aBanmasters[m_NumBanmasters].port == 0)
m_aBanmasters[m_NumBanmasters].port = BANMASTER_PORT;
m_NumBanmasters++;
return 0;
}
void CEcon::Init(IConsole *pConsole, CNetBan *pNetBan)
{
m_pConsole = pConsole;
for(int i = 0; i < NET_MAX_CONSOLE_CLIENTS; i++)
m_aClients[i].m_State = CClient::STATE_EMPTY;
m_Ready = false;
m_UserClientID = -1;
if(g_Config.m_EcPort == 0 || g_Config.m_EcPassword[0] == 0)
return;
NETADDR BindAddr;
if(g_Config.m_EcBindaddr[0] && net_host_lookup(g_Config.m_EcBindaddr, &BindAddr, NETTYPE_ALL) == 0)
{
// got bindaddr
BindAddr.type = NETTYPE_ALL;
BindAddr.port = g_Config.m_EcPort;
}
else
{
mem_zero(&BindAddr, sizeof(BindAddr));
BindAddr.type = NETTYPE_ALL;
BindAddr.port = g_Config.m_EcPort;
}
if(m_NetConsole.Open(BindAddr, pNetBan, 0))
{
m_NetConsole.SetCallbacks(NewClientCallback, DelClientCallback, this);
m_Ready = true;
char aBuf[128];
str_format(aBuf, sizeof(aBuf), "bound to %s:%d", g_Config.m_EcBindaddr, g_Config.m_EcPort);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD,"econ", aBuf);
Console()->Chain("ec_output_level", ConchainEconOutputLevelUpdate, this);
m_PrintCBIndex = Console()->RegisterPrintCallback(g_Config.m_EcOutputLevel, SendLineCB, this);
Console()->Register("logout", "", CFGFLAG_ECON, ConLogout, this, "Logout of econ");
}
else
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD,"econ", "couldn't open socket. port might already be in use");
}
int main(int argc, const char **argv) // ignore_convention
{
int64 LastUpdate = time_get();
dbg_logger_stdout();
net_init();
IKernel *pKernel = IKernel::Create();
IStorage *pStorage = CreateStorage("Teeworlds", argc, argv); // ignore_convention
m_pConsole = CreateConsole(CFGFLAG_BANMASTER);
m_pConsole->RegisterPrintCallback(StandardOutput, 0);
m_pConsole->Register("ban", "s?r", CFGFLAG_BANMASTER, ConBan, 0, "Bans the specified ip", 0);
m_pConsole->Register("unban_all", "", CFGFLAG_BANMASTER, ConUnbanAll, 0, "Unbans all ips", 0);
m_pConsole->Register("bind", "s", CFGFLAG_BANMASTER, ConSetBindAddr, 0, "Binds to the specified address", 0);
{
bool RegisterFail = false;
RegisterFail = RegisterFail || !pKernel->RegisterInterface(m_pConsole);
RegisterFail = RegisterFail || !pKernel->RegisterInterface(pStorage);
if(RegisterFail)
return -1;
}
m_pConsole->ExecuteFile(BANMASTER_BANFILE);
NETADDR BindAddr;
if(m_aBindAddr[0] && net_host_lookup(m_aBindAddr, &BindAddr, NETTYPE_IPV4) == 0)
{
if(BindAddr.port == 0)
BindAddr.port = BANMASTER_PORT;
}
else
{
mem_zero(&BindAddr, sizeof(BindAddr));
BindAddr.port = BANMASTER_PORT;
}
m_Net.Open(BindAddr, 0);
// TODO: DDRace: heinrich5991: check socket for errors
dbg_msg("banmaster", "started");
while(1)
{
m_Net.Update();
// process m_aPackets
CNetChunk p;
while(m_Net.Recv(&p))
{
if(p.m_DataSize >= (int)sizeof(BANMASTER_IPCHECK) &&
!mem_comp(p.m_pData, BANMASTER_IPCHECK, sizeof(BANMASTER_IPCHECK)))
{
char *pAddr = (char*)p.m_pData + sizeof(BANMASTER_IPCHECK);
NETADDR CheckAddr;
if(net_addr_from_str(&CheckAddr, pAddr))
{
dbg_msg("banmaster", "dropped weird message ip=%d.%d.%d.%d checkaddr='%s'",
p.m_Address.ip[0], p.m_Address.ip[1], p.m_Address.ip[2], p.m_Address.ip[3], pAddr);
}
else
{
int Banned = SendResponse(&p.m_Address, &CheckAddr);
dbg_msg("banmaster", "responded to checkmsg ip=%d.%d.%d.%d checkaddr=%d.%d.%d.%d result=%s",
p.m_Address.ip[0], p.m_Address.ip[1], p.m_Address.ip[2], p.m_Address.ip[3],
CheckAddr.ip[0], CheckAddr.ip[1], CheckAddr.ip[2], CheckAddr.ip[3], (Banned) ? "ban" : "ok");
}
}
}
if(time_get() - LastUpdate > time_freq() * BAN_REREAD_TIME)
{
ClearBans();
LastUpdate = time_get();
m_pConsole->ExecuteFile(BANMASTER_BANFILE);
}
// be nice to the CPU
thread_sleep(1);
}
return 0;
}
static int HostLookupThread(void *pUser)
{
CHostLookup *pLookup = (CHostLookup *)pUser;
return net_host_lookup(pLookup->m_aHostname, &pLookup->m_Addr, pLookup->m_Nettype);
}
int hostlookup_thread(void *user)
{
HOSTLOOKUP *lookup = (HOSTLOOKUP *)user;
net_host_lookup(lookup->hostname, &lookup->addr, NETTYPE_IPV4);
return 0;
}
bool CHttpDownloader::GetToFile(const char *url, const char *dest, unsigned timeOut, unsigned downloadSpeed)
{
if (!dest || dest[0] == 0)
return false;
int64 downloadTime = time_get();
unsigned chunkBytes = 0;
NETSOCKET sock;
NETADDR nadd, bindAddr;
mem_zero(&nadd, sizeof(nadd));
mem_zero(&bindAddr, sizeof(bindAddr));
bindAddr.type = NETTYPE_IPV4;
NETURL NetUrl = CreateUrl(url);
if (net_host_lookup(NetUrl.m_aHost, &nadd, NETTYPE_IPV4) != 0)
{
dbg_msg("HttpDownloader", "Error can't found '%s'...", NetUrl.m_aHost);
return false;
}
nadd.port = 80;
sock = net_tcp_create(bindAddr);
if (net_tcp_connect(sock, &nadd) != 0)
{
dbg_msg("HttpDownloader", "Error can't connect with '%s'...", NetUrl.m_aHost);
net_tcp_close(sock);
return false;
}
net_socket_rcv_timeout(sock, timeOut);
char aBuff[512] = {0};
str_format(aBuff, sizeof(aBuff), "GET %s HTTP/1.0\r\nHost: %s\r\n\r\n", NetUrl.m_aSlug, NetUrl.m_aHost);
net_tcp_send(sock, aBuff, str_length(aBuff));
std::string NetData;
unsigned TotalRecv = 0;
unsigned TotalBytes = 0;
int CurrentRecv = 0;
unsigned nlCount = 0;
char aNetBuff[1024] = {0};
IOHANDLE dstFile = NULL;
do
{
// Limit Speed
if (downloadSpeed > 0)
{
int64 ctime = time_get();
if (ctime - downloadTime <= time_freq())
{
if (chunkBytes >= downloadSpeed)
{
int tdff = (time_freq() - (ctime - downloadTime)) / 1000;
thread_sleep(tdff);
continue;
}
}
else
{
chunkBytes = 0;
downloadTime = time_get();
}
}
//
CurrentRecv = net_tcp_recv(sock, aNetBuff, sizeof(aNetBuff));
chunkBytes += CurrentRecv;
for (int i=0; i<CurrentRecv ; i++)
{
if (nlCount < 2)
{
if (aNetBuff[i] == '\r' || aNetBuff[i] == '\n')
{
++nlCount;
if (NetData.size() > 0)
{
std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower);
if (NetData.find("404 not found") != std::string::npos)
{
dbg_msg("HttpDownloader", "ERROR 404: '%s' not found...", NetUrl.m_aFile);
net_tcp_close(sock);
return false;
}
else if (NetData.find("content-length:") != std::string::npos)
{
char aFileSize[64];
str_copy(aFileSize, NetData.substr(15).c_str(), sizeof(aFileSize));
str_trim(aFileSize);
TotalBytes = atoi(aFileSize);
}
NetData.clear();
}
if (aNetBuff[i] == '\r') ++i;
continue;
}
nlCount = 0;
NetData += aNetBuff[i];
}
else
{
if (nlCount == 2)
{
if (TotalBytes <= 0)
{
dbg_msg("HttpDownloader", "Error downloading '%s'...", NetUrl.m_aFile);
net_tcp_close(sock);
return false;
}
dstFile = io_open(dest, IOFLAG_WRITE);
if(!dstFile)
{
dbg_msg("HttpDownloader", "Error creating '%s'...", dest);
net_tcp_close(sock);
return false;
}
++nlCount;
}
io_write(dstFile, &aNetBuff[i], 1);
TotalRecv++;
if (TotalRecv == TotalBytes)
break;
}
}
} while (CurrentRecv > 0);
net_tcp_close(sock);
if (TotalRecv > 0)
{
io_close(dstFile);
return true;
}
return false;
}
unsigned CHttpDownloader::GetFileSize(const char *url, unsigned timeOut)
{
NETSOCKET sock;
NETADDR nadd, bindAddr;
mem_zero(&nadd, sizeof(nadd));
mem_zero(&bindAddr, sizeof(bindAddr));
bindAddr.type = NETTYPE_IPV4;
NETURL NetUrl = CreateUrl(url);
if (net_host_lookup(NetUrl.m_aHost, &nadd, NETTYPE_IPV4) != 0)
{
dbg_msg("HttpDownloader", "Error can't found '%s'...", NetUrl.m_aHost);
return false;
}
nadd.port = 80;
sock = net_tcp_create(bindAddr);
net_socket_rcv_timeout(sock, timeOut);
if (net_tcp_connect(sock, &nadd) != 0)
{
dbg_msg("HttpDownloader", "Error can't connect with '%s'...", NetUrl.m_aHost);
net_tcp_close(sock);
return false;
}
char aBuff[512] = {0};
str_format(aBuff, sizeof(aBuff), "GET %s HTTP/1.0\r\nHost: %s\r\n\r\n", NetUrl.m_aSlug, NetUrl.m_aHost);
net_tcp_send(sock, aBuff, str_length(aBuff));
std::string NetData;
int TotalBytes = 0;
int CurrentRecv = 0;
int nlCount = 0;
char aNetBuff[1024] = {0};
do
{
CurrentRecv = net_tcp_recv(sock, aNetBuff, sizeof(aNetBuff));
for (int i=0; i<CurrentRecv ; i++)
{
if (nlCount < 2)
{
if (aNetBuff[i] == '\r' || aNetBuff[i] == '\n')
{
++nlCount;
if (NetData.size() > 0)
{
std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower);
if (NetData.find("404 not found") != std::string::npos)
{
dbg_msg("HttpDownloader", "ERROR 404: '%s' not found...", NetUrl.m_aFile);
net_tcp_close(sock);
return false;
}
else if (NetData.find("content-length:") != std::string::npos)
{
char aFileSize[64];
str_copy(aFileSize, NetData.substr(15).c_str(), sizeof(aFileSize));
str_trim(aFileSize);
TotalBytes = atoi(aFileSize);
if (TotalBytes <= 0)
{
dbg_msg("HttpDownloader", "Error getting size of '%s'...", NetUrl.m_aFile);
net_tcp_close(sock);
return 0;
}
net_tcp_close(sock);
return TotalBytes;
}
NetData.clear();
}
if (aNetBuff[i] == '\r') ++i;
continue;
}
nlCount = 0;
NetData += aNetBuff[i];
}
else
{
dbg_msg("HttpDownloader", "Error getting size of '%s'...", NetUrl.m_aFile);
net_tcp_close(sock);
return 0;
}
}
} while (CurrentRecv > 0);
return 0;
}
// TODO: Ugly but works
bool CUpdater::GetFile(const char *url, const char *path)
{
NETSOCKET Socket = invalid_socket;
NETADDR HostAddress, BindAddr;
mem_zero(&HostAddress, sizeof(HostAddress));
mem_zero(&BindAddr, sizeof(BindAddr));
char aNetBuff[1024];
//Lookup
if(net_host_lookup(UPDATES_HOST, &HostAddress, NETTYPE_IPV4) != 0)
{
dbg_msg("autoupdate", "Error running host lookup");
return false;
}
HostAddress.port = 80;
//Connect
BindAddr.type = NETTYPE_IPV4;
Socket = net_tcp_create(BindAddr);
if(net_tcp_connect(Socket, &HostAddress) != 0)
{
net_tcp_close(Socket);
dbg_msg("autoupdate","Error connecting to host");
return false;
}
//Send request
str_format(aNetBuff, sizeof(aNetBuff), "GET "UPDATES_BASE_PATH"%s HTTP/1.0\r\nHost: "UPDATES_HOST"\r\n\r\n", url);
net_tcp_send(Socket, aNetBuff, str_length(aNetBuff));
//read data
IOHANDLE dstFile = 0;
std::string NetData;
int TotalRecv = 0, TotalBytes = 0, CurrentRecv = 0, enterCtrl = 0;
bool isHead = true, isStatusLine = true;
while ((CurrentRecv = net_tcp_recv(Socket, aNetBuff, sizeof(aNetBuff))) > 0)
{
for (int i=0; i<CurrentRecv ; i++)
{
if (isHead)
{
if (aNetBuff[i]=='\n')
{
if (++enterCtrl == 2) // Go To Body Part
{
dstFile = io_open(path, IOFLAG_WRITE);
if (!dstFile)
{
net_tcp_close(Socket);
dbg_msg("autoupdate","Error writing to disk");
return false;
}
str_copy(m_CurrentDownloadFileName, url, sizeof(m_CurrentDownloadFileName));
isHead = false;
NetData.clear();
continue;
}
std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower);
// Check Status
if (isStatusLine)
{
bool isCodeOk = NetData.find("200") != std::string::npos;
bool isStatusOk = NetData.find("ok") != std::string::npos;
if (!isCodeOk || !isStatusOk)
{
net_tcp_close(Socket);
dbg_msg("autoupdate","Server Host returns error code");
return false;
}
}
isStatusLine = false;
// Get File Size
std::size_t fpos = std::string::npos;
if ((fpos=NetData.find("content-length:")) != std::string::npos)
sscanf(NetData.substr(fpos+15).c_str(), "%d", &TotalBytes);
NetData.clear();
continue;
}
else if (aNetBuff[i]!='\r')
enterCtrl=0;
NetData+=aNetBuff[i];
}
else // Body Part
{
if (TotalBytes <= 0)
{
io_close(dstFile);
net_tcp_close(Socket);
dbg_msg("autoupdate","Error receiving file");
return false;
}
m_CurrentDownloadProgress = (float)TotalRecv/(float)TotalBytes;
io_write(dstFile, &aNetBuff[i], 1);
TotalRecv++;
if (TotalRecv == TotalBytes)
break;
}
}
}
//Finish
io_close(dstFile);
net_tcp_close(Socket);
return true;
}
