void serverms(int mode, int numplayers, int minremain, char *smapname, int seconds, bool isfull) {
checkmasterreply();
updatemasterserver(seconds);
// reply all server info requests
ENetBuffer buf;
ENetAddress addr;
u8 pong[MAXTRANS], *p;
int len;
enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
buf.data = pong;
while (enet_socket_wait(pongsock, &events, 0) >= 0 && events) {
buf.dataLength = sizeof(pong);
len = enet_socket_receive(pongsock, &addr, &buf, 1);
if (len < 0) return;
p = &pong[len];
putint(p, PROTOCOL_VERSION);
putint(p, mode);
putint(p, numplayers);
putint(p, minremain);
string mname;
strcpy_s(mname, isfull ? "[FULL] " : "");
strcat_s(mname, smapname);
sendstring(mname, p);
sendstring(serverdesc, p);
buf.dataLength = p - pong;
enet_socket_send(pongsock, &addr, &buf, 1);
}
}
void BroadcastHost::update()
{
int length;
ENetAddress addr;
ENetBuffer bcbuffer;
bcbuffer.data = new char[1024];
bcbuffer.dataLength = 1024;
// Look for broadcast messages
while ((length = enet_socket_receive(bcastsocket, &addr, &bcbuffer, 1))
!= 0)
{
if (length < 0)
{
std::cout << "Socket error: " << errno << std::endl;
break;
}
else
{
// Send answer
ENetBuffer replybuffer;
if (reply)
{
replybuffer.data = reply->getData();
replybuffer.dataLength = reply->getSize();
}
else
{
replybuffer.data = (void*)"PONG";
replybuffer.dataLength = 5;
}
enet_socket_send(bcastsocket, &addr, &replybuffer, 1);
}
}
delete[] (char*)bcbuffer.data;
}
void httpgetrecieve(ENetBuffer &buf) {
if (mssock==ENET_SOCKET_NULL)
return;
enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
if (enet_socket_wait(mssock, &events, 0) >= 0 && events) {
int len = enet_socket_receive(mssock, NULL, &buf, 1);
if (len<=0) {
enet_socket_destroy(mssock);
mssock = ENET_SOCKET_NULL;
return;
}
buf.data = ((char *)buf.data)+len;
((char*)buf.data)[0] = 0;
buf.dataLength -= len;
}
}
static int
enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
{
for (;;)
{
int receivedLength;
ENetBuffer buffer;
buffer.data = host -> receivedData;
buffer.dataLength = sizeof (host -> receivedData);
receivedLength = enet_socket_receive (host -> socket,
& host -> receivedAddress,
& buffer,
1);
if (receivedLength < 0)
return -1;
if (receivedLength == 0)
return 0;
host -> receivedDataLength = receivedLength;
switch (enet_protocol_handle_incoming_commands (host, event))
{
case 1:
return 1;
case -1:
return -1;
default:
break;
}
}
return -1;
}
void LANGameFinderAndAnnouncer::receivePackets() {
NetworkPacket_AnnounceGame announcePacket;
ENetAddress senderAddress;
ENetBuffer enetBuffer;
enetBuffer.data = &announcePacket;
enetBuffer.dataLength = sizeof(announcePacket);
int receivedBytes = enet_socket_receive(announceSocket, &senderAddress, &enetBuffer, 1);
if(receivedBytes==0) {
// blocked
} else if(receivedBytes < 0) {
throw std::runtime_error("LANGameFinderAndAnnouncer: Receiving data failed!");
} else {
if((receivedBytes == sizeof(NetworkPacket_AnnounceGame))
&& (SDL_SwapLE32(announcePacket.magicNumber) == LANGAME_ANNOUNCER_MAGICNUMBER)
&& (announcePacket.type == NETWORKPACKET_ANNOUNCEGAME)
&& (strncmp(announcePacket.serverVersion, VERSIONSTRING, LANGAME_ANNOUNCER_MAXGAMEVERSIONSIZE) == 0)) {
std::string serverName = std::string(announcePacket.serverName, LANGAME_ANNOUNCER_MAXGAMENAMESIZE);
serverName.resize(strlen(serverName.c_str())); // strip off '\0' at the end of the std::string
int serverPort = SDL_SwapLE16(announcePacket.serverPort);
std::string mapName = std::string(announcePacket.mapName, LANGAME_ANNOUNCER_MAXMAPNAMESIZE);
mapName.resize(strlen(mapName.c_str())); // strip off '\0' at the end of the std::string
int numPlayers = announcePacket.numPlayers;
int maxPlayers = announcePacket.maxPlayers;
GameServerInfo gameServerInfo;
gameServerInfo.serverAddress.host = senderAddress.host;
gameServerInfo.serverAddress.port = serverPort;
gameServerInfo.serverName = serverName;
gameServerInfo.mapName = mapName;
gameServerInfo.numPlayers = numPlayers;
gameServerInfo.maxPlayers = maxPlayers;
gameServerInfo.bPasswordProtected = false;
gameServerInfo.lastUpdate = SDL_GetTicks();
bool bUpdate = false;
std::list<GameServerInfo>::iterator iter;
for(iter = gameServerInfoList.begin(); iter != gameServerInfoList.end(); ++iter) {
if((iter->serverAddress.host == gameServerInfo.serverAddress.host)
&& (iter->serverAddress.port == gameServerInfo.serverAddress.port)) {
*iter = gameServerInfo;
bUpdate = true;
break;
}
}
if(bUpdate) {
if(pOnUpdateServer) {
pOnUpdateServer(gameServerInfo);
}
} else {
gameServerInfoList.push_back(gameServerInfo);
if(pOnNewServer) {
pOnNewServer(gameServerInfo);
}
}
} else if((receivedBytes == sizeof(NetworkPacket_RemoveGameAnnouncement))
&& (SDL_SwapLE32(announcePacket.magicNumber) == LANGAME_ANNOUNCER_MAGICNUMBER)
&& (announcePacket.type == NETWORKPACKET_REMOVEGAMEANNOUNCEMENT)) {
int serverPort = SDL_SwapLE16(announcePacket.serverPort);
std::list<GameServerInfo>::iterator iter = gameServerInfoList.begin();
while(iter != gameServerInfoList.end()) {
if((iter->serverAddress.host == senderAddress.host)
&& (iter->serverAddress.port == serverPort)) {
GameServerInfo tmpGameServerInfo = *iter;
iter = gameServerInfoList.erase(iter);
if(pOnRemoveServer) {
pOnRemoveServer(tmpGameServerInfo);
}
} else {
++iter;
}
}
} else if((serverPort > 0)
&& (receivedBytes == sizeof(NetworkPacket_RequestGame))
&& (SDL_SwapLE32(announcePacket.magicNumber) == LANGAME_ANNOUNCER_MAGICNUMBER)
&& (announcePacket.type == NETWORKPACKET_REQUESTANNOUNCE)) {
announceGame();
}
}
}
