ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Started to introduce new network string. It compiles, but certainly

Browse Source 
does not work yet.
This commit is contained in:
hiker 2016-02-23 16:29:57 +11:00
parent 05a1a8a785
commit 98ba11d9ba
27 changed files with 731 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main.cpp
View File

@ -173,6 +173,7 @@
#include "modes/demo_world.hpp"
#include "modes/profile_world.hpp"
#include "network/network_config.hpp"
#include "network/network_string.hpp"
#include "network/servers_manager.hpp"
#include "network/stk_host.hpp"
#include "online/profile_manager.hpp"
@ -1669,6 +1670,7 @@ static void cleanUserConfig()
void runUnitTests()
{
GraphicsRestrictions::unitTesting();
NewNetworkString::unitTesting();
// Test easter mode: in 2015 Easter is 5th of April - check with 0 days
// before and after
int saved_easter_mode = UserConfigParams::m_easter_ear_mode;
@ -1698,4 +1700,4 @@ void runUnitTests()
assert( isEasterMode(22, 3, 2016, 5));
assert(!isEasterMode(21, 3, 2016, 5));
UserConfigParams::m_easter_ear_mode = saved_easter_mode;
} // unitTesting
} // runUnitTests

20
src/network/event.cpp
View File

@ -46,20 +46,24 @@ Event::Event(ENetEvent* event)
}
if (m_type == EVENT_TYPE_MESSAGE)
{
m_data = NetworkString(std::string((char*)(event->packet->data),
event->packet->dataLength-1));
m_data = new NewNetworkString(event->packet->data,
event->packet->dataLength);
}
m_packet = NULL;
if (event->packet)
{
m_packet = event->packet;
// we got all we need, just remove the data.
enet_packet_destroy(m_packet);
enet_packet_destroy(event->packet);
}
m_packet = NULL;
m_peer = STKHost::get()->getPeer(event->peer);
if(m_data->getToken()!=m_peer->getClientServerToken() )
{
Log::error("Event", "Received event with invalid token!");
Log::error("Event", "HostID %d Token %d message token %d",
m_peer->getHostId(), m_peer->getClientServerToken(),
m_data->getToken());
}
} // Event(ENetEvent)
// ----------------------------------------------------------------------------
@ -70,7 +74,7 @@ Event::~Event()
// Do not delete m_peer, it's a pointer to the enet data structure
// which is persistent.
m_peer = NULL;
m_packet = NULL;
delete m_data;
} // ~Event
// ----------------------------------------------------------------------------
@ -79,6 +83,6 @@ Event::~Event()
*/
void Event::removeFront(int size)
{
m_data.removeFront(size);
m_data->removeFront(size);
} // removeFront

12
src/network/event.hpp
View File

@ -24,12 +24,12 @@
#ifndef EVENT_HPP
#define EVENT_HPP
#include "network/network_string.hpp"
#include "utils/leak_check.hpp"
#include "utils/types.hpp"
#include "enet/enet.h"
class NewNetworkString;
class STKPeer;
/*!
@ -57,11 +57,9 @@ class Event
{
private:
LEAK_CHECK()
/** Copy of the data passed by the event. */
NetworkString m_data;
/** A pointer on the ENetPacket to be deleted. */
ENetPacket* m_packet;
/** Copy of the data passed by the event. */
NewNetworkString *m_data;
/** Type of the event. */
EVENT_TYPE m_type;
@ -85,12 +83,12 @@ public:
/** \brief Get a const reference to the received data.
* This is empty for events like connection or disconnections.
*/
const NetworkString& data() const { return m_data; }
const NewNetworkString& data() const { return *m_data; }
// ------------------------------------------------------------------------
/** \brief Get a non-const reference to the received data.
* A copy of the message data. This is empty for events like
* connection or disconnections. */
NetworkString& data() { return m_data; }
NewNetworkString& data() { return *m_data; }
// ------------------------------------------------------------------------
}; // class Event

11
src/network/network.cpp
View File

@ -99,8 +99,7 @@ void Network::sendRawPacket(uint8_t* data, int length,
sendto(m_host->socket, (char*)data, length, 0,(sockaddr*)&to, to_len);
Log::verbose("Network", "Raw packet sent to %s",
dst.toString().c_str());
Network::logPacket(NetworkString(std::string((char*)(data), length)),
false);
Network::logPacket(NewNetworkString(data, length), false);
} // sendRawPacket
// ----------------------------------------------------------------------------
@ -146,7 +145,7 @@ int Network::receiveRawPacket(char *buffer, int buf_len,
if(len<0)
return -1;
Network::logPacket(NetworkString(std::string(buffer, len)), true);
Network::logPacket(NewNetworkString((uint8_t*)buffer, len), true);
sender->setIP(ntohl((uint32_t)(addr.sin_addr.s_addr)) );
sender->setPort( ntohs(addr.sin_port) );
if (addr.sin_family == AF_INET)
@ -161,9 +160,9 @@ int Network::receiveRawPacket(char *buffer, int buf_len,
/** \brief Broadcasts a packet to all peers.
* \param data : Data to send.
*/
void Network::broadcastPacket(const NetworkString& data, bool reliable)
void Network::broadcastPacket(const NewNetworkString& data, bool reliable)
{
ENetPacket* packet = enet_packet_create(data.getBytes(), data.size() + 1,
ENetPacket* packet = enet_packet_create(data.getData(), data.size() + 1,
reliable ? ENET_PACKET_FLAG_RELIABLE
: ENET_PACKET_FLAG_UNSEQUENCED);
enet_host_broadcast(m_host, 0, packet);
@ -189,7 +188,7 @@ void Network::openLog()
* \param incoming : True if the packet comes from a peer.
* False if it's sent to a peer.
*/
void Network::logPacket(const NetworkString &ns, bool incoming)
void Network::logPacket(const NewNetworkString &ns, bool incoming)
{
if (m_log_file.getData() == NULL) // read only access, no need to lock
return;

6
src/network/network.hpp
View File

@ -33,7 +33,7 @@
#include <stdio.h>
class NetworkString;
class NewNetworkString;
class TransportAddress;
/** \class EnetHost
@ -57,14 +57,14 @@ public:
virtual ~Network();
static void openLog();
static void logPacket(const NetworkString &ns, bool incoming);
static void logPacket(const NewNetworkString &ns, bool incoming);
static void closeLog();
ENetPeer *connectTo(const TransportAddress &address);
void sendRawPacket(uint8_t* data, int length,
const TransportAddress& dst);
int receiveRawPacket(char *buffer, int buf_len,
TransportAddress* sender, int max_tries = -1);
void broadcastPacket(const NetworkString& data,
void broadcastPacket(const NewNetworkString& data,
bool reliable = true);
// ------------------------------------------------------------------------
/** Returns a pointer to the ENet host object. */

2
src/network/network_console.cpp
View File

@ -173,7 +173,7 @@ void NetworkConsole::kickAllPlayers()
} // kickAllPlayers
// ----------------------------------------------------------------------------
void NetworkConsole::sendPacket(const NetworkString& data, bool reliable)
void NetworkConsole::sendPacket(const NewNetworkString& data, bool reliable)
{
m_localhost->broadcastPacket(data, reliable);
} // sendPacket

16
src/network/network_console.hpp
View File

@ -23,7 +23,7 @@
#include "pthread.h"
class NetworkString;
class NewNetworkString;
class STKHost;
class NetworkConsole
@ -43,14 +43,14 @@ public:
virtual ~NetworkConsole();
virtual void run();
void setMaxPlayers(uint8_t count) { m_max_players = count; }
uint8_t getMaxPlayers() { return m_max_players; }
void kickAllPlayers();
virtual void sendPacket(const NetworkString& data, bool reliable = true);
virtual void sendPacket(const NewNetworkString& data,
bool reliable = true);
// ------------------------------------------------------------------------
void setMaxPlayers(uint8_t count) { m_max_players = count; }
// ------------------------------------------------------------------------
uint8_t getMaxPlayers() { return m_max_players; }
// ------------------------------------------------------------------------
virtual bool isServer() { return true; }
}; // class NetworkConsole

95
src/network/network_string.cpp
View File

@ -27,7 +27,7 @@ NetworkString operator+(NetworkString const& a, NetworkString const& b)
// ----------------------------------------------------------------------------
/** Adds one byte for the length of the string, and then (up to 255 of)
* the characters of the given string. */
* the characters of the given string. */
NetworkString& NetworkString::encodeString(const std::string &value)
{
int len = value.size();
@ -77,3 +77,96 @@ int NetworkString::decodeStringW(int pos, irr::core::stringw *out) const
*out = StringUtils::utf8ToWide(s);
return len;
} // decodeString
// ============================================================================
void NewNetworkString::unitTesting()
{
NewNetworkString s(PROTOCOL_LOBBY_ROOM);
assert(s.getProtocolType() == PROTOCOL_LOBBY_ROOM);
assert(s.getProtocolType() != PROTOCOL_KART_UPDATE);
assert(!s.isSynchronous());
s.setSynchronous(true);
assert(s.isSynchronous());
s.setSynchronous(false);
assert(!s.isSynchronous());
uint32_t token = 0x12345678;
// Check token setting and reading
s.setToken(token);
assert(s.getToken()==token);
assert(s.getToken()!=0x87654321);
// Append some values from the message
s.addUInt16(12345);
s.addFloat(1.2345f);
// Ignore message type and token
s.removeFront(5);
assert(s.getUInt16(0) == 12345);
float f = s.getFloat(2);
assert(f==1.2345f);
// Check modifying a token in an already assembled message
uint32_t new_token = 0x87654321;
s.setToken(new_token);
assert(s.getToken()!=token);
assert(s.getToken()==new_token);
} // unitTesting
// ============================================================================
// ----------------------------------------------------------------------------
/** Adds one byte for the length of the string, and then (up to 255 of)
* the characters of the given string. */
NewNetworkString& NewNetworkString::encodeString(const std::string &value)
{
int len = value.size();
if(len<=255)
return this->addUInt8(len).addString(value);
else
return addUInt8(255).addString(value.substr(0, 255));
} // encodeString
// ----------------------------------------------------------------------------
/** Adds one byte for the length of the string, and then (up to 255 of)
* the characters of the given string. */
NewNetworkString& NewNetworkString::encodeString(const irr::core::stringw &value)
{
std::string v = StringUtils::wideToUtf8(value);
return encodeString(v);
} // encodeString
// ----------------------------------------------------------------------------
/** Returns a string at the given position. The first byte indicates the
* length, followed by the actual string (not 0 terminated).
* \param[in] pos Buffer position where the encoded string starts.
* \param[out] out The decoded string.
* \return number of bytes read = 1+length of string
*/
int NewNetworkString::decodeString(int pos, std::string *out) const
{
uint8_t len = get<uint8_t>(pos);
*out = getString(pos+1, len);
return len+1;
} // decodeString
// ----------------------------------------------------------------------------
/** Returns an irrlicht wide string from the utf8 encoded string at the
* given position.
* \param[in] pos Buffer position where the encoded string starts.
* \param[out] out The decoded string.
* \return number of bytes read. If there are no special characters in the
* string that will be 1+length of string, but multi-byte encoded
* characters can mean that the length of the returned string is
* less than the number of bytes read.
*/
int NewNetworkString::decodeStringW(int pos, irr::core::stringw *out) const
{
std::string s;
int len = decodeString(pos, &s);
*out = StringUtils::utf8ToWide(s);
return len;
} // decodeString

286
src/network/network_string.hpp
View File

@ -23,6 +23,7 @@
#ifndef NETWORK_STRING_HPP
#define NETWORK_STRING_HPP
#include "network/protocol.hpp"
#include "utils/types.hpp"
#include "utils/vec3.hpp"
@ -539,5 +540,290 @@ public:
}; // class NetworkString
NetworkString operator+(NetworkString const& a, NetworkString const& b);
// ============================================================================
/** A new implementation of NetworkString, which has a fixed format:
* Byte 0: The type of the message, which is actually a bit field:
* bit 7: if set, the message needs to be handled synchronously,
* otherwise it can be handled by the separate protocol
* manager thread.
* bits 6-0: The protocol ID, which identifies the receiving protocol
* for this message.
* Byte 1-4: A token to authenticate the sender.
*
* Otherwise this class offers template functions to add arbitrary variables,
* and retrieve them again. It kept the functionality of 'removing' bytes
* (e.g. the ProtocolManager would remove the first byte - protocol type -
* so that the protocols would not see this byte). But this is implemented
* now by using a base pointer (and not by moving the buffer content).
*/
class NewNetworkString
{
private:
/** The actual buffer. */
std::vector<uint8_t> m_buffer;
/** To avoid copying the buffer when bytes are deleted (which only
* happens at the front), use an offset index. All positions given
* by the user will be relative to this index. Note that the type
* should be left as signed, otherwise certain arithmetic (e.g.
* 1-m_current_offset in checkToken() will be done unsigned).
*/
int m_current_offset;
// ------------------------------------------------------------------------
/** Returns a part of the network string as a std::string. This is an
* internal function only, the user should call decodeString(W) instead.
* \param pos First position to be in the string.
* \param len Number of bytes to copy.
*/
std::string getString(int pos, int len) const
{
return std::string(m_buffer.begin() + (m_current_offset+pos ),
m_buffer.begin() + (m_current_offset+pos + len) );
} // getString
// ------------------------------------------------------------------------
/** Adds a std::string. Internal use only. */
NewNetworkString& addString(const std::string& value)
{
for (unsigned int i = 0; i < value.size(); i++)
m_buffer.push_back((uint8_t)(value[i]));
return *this;
} // addString
public:
static void unitTesting();
/** Constructor, sets the protocol type of this message. */
NewNetworkString(ProtocolType type, int capacity=16)
{
m_buffer.reserve(capacity);
m_buffer.push_back(type);
m_current_offset = 0;
} // NewNetworkString
// ------------------------------------------------------------------------
NewNetworkString(const uint8_t *data, int len)
{
m_buffer.resize(len);
memcpy(m_buffer.data(), data, len);
} // NewNetworkString
// ------------------------------------------------------------------------
/** Returns a byte pointer to the content of the network string. */
uint8_t* getData() { return &m_buffer[0]; };
// ------------------------------------------------------------------------
/** Returns a byte pointer to the content of the network string. */
const uint8_t* getData() const { return &m_buffer[0]; };
// ------------------------------------------------------------------------
/** Returns the protocol type of this message. */
ProtocolType getProtocolType() const
{
assert(!m_buffer.empty());
return (ProtocolType)m_buffer[0];
} // getProtocolType
// ------------------------------------------------------------------------
/** Sets if this message is to be sent synchronous or asynchronous. */
void setSynchronous(bool b)
{
if(b)
m_buffer[0] |= PROTOCOL_SYNCHRONOUS;
else
m_buffer[0] &= !PROTOCOL_SYNCHRONOUS;
} // setSynchronous
// ------------------------------------------------------------------------
/** Returns if this message is synchronous or not. */
bool isSynchronous() const
{
return (m_buffer[0] & PROTOCOL_SYNCHRONOUS) != 0;
} // isSynchronous
// ------------------------------------------------------------------------
/** Sets a token for a message. Note that the token in an already
* assembled message might be updated (e.g. if the same message is sent
* from the server to a set of clients). */
void setToken(uint32_t token)
{
// Make sure there is enough space for the token:
if(m_buffer.size()<5)
m_buffer.resize(5);
m_buffer[1] = (token >> 24) & 0xff;
m_buffer[2] = (token >> 16) & 0xff;
m_buffer[3] = (token >> 8) & 0xff;
m_buffer[4] = token & 0xff;
} // setToken
// ------------------------------------------------------------------------
/** Returns if the security token of this message is the same as the
* specified token. */
uint32_t getToken() const
{
// Since m_current_offset might be set, we need to make sure
// to really access bytes 1-4
return getUInt32(1-m_current_offset);
} // getToken
// ------------------------------------------------------------------------
/** Returns the current length of the network string. */
int size() const { return (int)m_buffer.size(); }
// ------------------------------------------------------------------------
/** Returns the content of the network string as a std::string. */
const std::string std_string() const
{
std::string str(m_buffer.begin(), m_buffer.end());
return str;
} // std_string
// ------------------------------------------------------------------------
// All functions related to adding data to a network string
// ========================================================
/** Add 8 bit unsigned int. */
NewNetworkString& addUInt8(const uint8_t value)
{
m_buffer.push_back(value);
return *this;
} // addUInt8
// ------------------------------------------------------------------------
/** Adds 16 bit unsigned int. */
NewNetworkString& addUInt16(const uint16_t value)
{
m_buffer.push_back((value >> 8) & 0xff);
m_buffer.push_back(value & 0xff);
return *this;
} // addUInt16
// ------------------------------------------------------------------------
/** Adds unsigned 32 bit integer. */
NewNetworkString& addUInt32(const uint32_t& value)
{
m_buffer.push_back((value >> 24) & 0xff);
m_buffer.push_back((value >> 16) & 0xff);
m_buffer.push_back((value >> 8) & 0xff);
m_buffer.push_back( value & 0xff);
return *this;
} // addUInt32
// ------------------------------------------------------------------------
/** Adds a 4 byte floating point value. */
NewNetworkString& addFloat(const float value)
{
uint32_t *p = (uint32_t*)&value;
return addUInt32(*p);
} // addFloat
// ------------------------------------------------------------------------
/** Adds the content of another network string. */
NewNetworkString& operator+=(NewNetworkString const& value)
{
m_buffer.insert(m_buffer.end(), value.m_buffer.begin(),
value.m_buffer.end() );
return *this;
} // operator+=
// ------------------------------------------------------------------------
/** Adds the xyz components of a Vec3 to the string. */
NewNetworkString& add(const Vec3 &xyz)
{
return addFloat(xyz.getX()).addFloat(xyz.getY()).addFloat(xyz.getZ());
} // add
// ------------------------------------------------------------------------
/** Adds the four components of a quaternion. */
NewNetworkString& add(const btQuaternion &quat)
{
return addFloat(quat.getX()).addFloat(quat.getY())
.addFloat(quat.getZ()).addFloat(quat.getW());
} // add
// Functions related to getting data from a network string
// =======================================================
/** Ignore the next num_bytes from the message.
*/
void removeFront(unsigned int num_bytes)
{
assert(m_current_offset + num_bytes <= m_buffer.size());
m_current_offset += num_bytes;
} // removeFront
// ------------------------------------------------------------------------
/** Gets the byte at the specified position (taking current offset into
* account). */
uint8_t operator[](const int pos) const
{
return m_buffer[m_current_offset + pos];
} // operator[]
private:
// ------------------------------------------------------------------------
/** Template to get n bytes from a buffer into a single data type. */
template<typename T, size_t n>
T get(int pos) const
{
int a = n;
T result = 0;
int offset = m_current_offset + pos + n -1;
while (a--)
{
result <<= 8; // offset one byte
// add the data to result
result += m_buffer[offset - a];
}
return result;
} // get(int pos)
// ------------------------------------------------------------------------
/** Another function for n == 1 to surpress warnings in clang. */
template<typename T>
T get(int pos) const
{
return m_buffer[pos];
} // get
public:
// ------------------------------------------------------------------------
/** Returns a unsigned 32 bit integer. */
inline uint32_t getUInt32(int pos = 0) const { return get<uint32_t, 4>(pos); }
// ------------------------------------------------------------------------
/** Returns an unsigned 16 bit integer. */
inline uint16_t getUInt16(int pos=0) const { return get<uint16_t, 2>(pos); }
// ------------------------------------------------------------------------
/** Returns an unsigned 8-bit integer. */
inline uint8_t getUInt8(int pos = 0) const
{
return m_buffer[m_current_offset + pos];
} // getUInt8
// ------------------------------------------------------------------------
/** Gets a 4 byte floating point value. */
float getFloat(int pos=0) const
{
uint32_t u = getUInt32(pos);
return *(float*)&u;
} // getFloat
// ------------------------------------------------------------------------
/** Gets a Vec3. */
Vec3 getVec3(int pos=0) const
{
return Vec3(getFloat(pos), getFloat(pos+4), getFloat(pos+8));
} // getVec3
// ------------------------------------------------------------------------
/** Gets a Vec3. */
btQuaternion getQuat(int pos=0) const
{
return btQuaternion(getFloat(pos), getFloat(pos+ 4),
getFloat(pos+8), getFloat(pos+12) );
} // getQuat
// ------------------------------------------------------------------------
NewNetworkString& encodeString(const std::string &value);
NewNetworkString& encodeString(const irr::core::stringw &value);
int decodeString(int n, std::string *out) const;
int decodeStringW(int n, irr::core::stringw *out) const;
// ------------------------------------------------------------------------
}; // class NetworkString
#endif // NETWORK_STRING_HPP

52
src/network/protocol.cpp
View File

@ -19,6 +19,7 @@
#include "network/protocol.hpp"
#include "network/event.hpp"
#include "network/network_string.hpp"
#include "network/protocol_manager.hpp"
#include "network/stk_host.hpp"
#include "network/stk_peer.hpp"
@ -46,10 +47,19 @@ Protocol::~Protocol()
{
} // ~Protocol
// ----------------------------------------------------------------------------
/** Returns a network string with the given type.
* \capacity Default preallocated size for the message.
*/
NewNetworkString* Protocol::getNetworkString(int capacity)
{
return new NewNetworkString(m_type, capacity);
} // getNetworkString
// ----------------------------------------------------------------------------
bool Protocol::checkDataSizeAndToken(Event* event, int minimum_size)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() < minimum_size || data[0] != 4)
{
Log::warn("Protocol", "Receiving a badly "
@ -58,7 +68,7 @@ bool Protocol::checkDataSizeAndToken(Event* event, int minimum_size)
return false;
}
STKPeer* peer = event->getPeer();
uint32_t token = data.gui32(1);
uint32_t token = data.getUInt32(1);
if (token != peer->getClientServerToken())
{
Log::warn("Protocol", "Peer sending bad token. Request "
@ -71,7 +81,7 @@ bool Protocol::checkDataSizeAndToken(Event* event, int minimum_size)
// ----------------------------------------------------------------------------
bool Protocol::isByteCorrect(Event* event, int byte_nb, int value)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data[byte_nb] != value)
{
Log::info("Protocol", "Bad byte at pos %d. %d "
@ -117,50 +127,28 @@ void Protocol::requestTerminate()
/** Sends a message to all peers, inserting the peer's token into the message.
* The message is composed of a 1-byte message (usually the message type)
* followed by the token of this client and then actual message).
* \param type The first byte of the combined message.
* \param message The actual message content.
*/
void Protocol::sendMessageToPeersChangingToken(uint8_t type,
const NetworkString &message)
void Protocol::sendMessageToPeersChangingToken(NewNetworkString *message)
{
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString combined(1+4+message.size());
combined.addUInt8(type).addUInt8(4)
.addUInt32(peers[i]->getClientServerToken());
combined+=message;
ProtocolManager::getInstance()->sendMessage(this, peers[i], combined);
message->setToken(peers[i]->getClientServerToken());
ProtocolManager::getInstance()->sendMessage(peers[i], *message);
}
} // sendMessageToPeersChangingToken
// ----------------------------------------------------------------------------
void Protocol::sendMessage(const NetworkString& message, bool reliable)
void Protocol::sendMessage(const NewNetworkString &message, bool reliable)
{
ProtocolManager::getInstance()->sendMessage(this, message, reliable,
/*synchronous*/false);
ProtocolManager::getInstance()->sendMessage(message, reliable);
} // sendMessage
// ----------------------------------------------------------------------------
void Protocol::sendSynchronousMessage(const NetworkString& message,
bool reliable)
{
ProtocolManager::getInstance()->sendMessage(this, message, reliable,
/*synchron*/true);
} // sendMessage
// ----------------------------------------------------------------------------
void Protocol::sendMessage(STKPeer* peer, const NetworkString& message,
void Protocol::sendMessage(STKPeer* peer, const NewNetworkString &message,
bool reliable)
{
ProtocolManager::getInstance()->sendMessage(this, peer, message, reliable,
/*synchronous*/false);
ProtocolManager::getInstance()->sendMessage(peer, message, reliable);
} // sendMessage
// ----------------------------------------------------------------------------
void Protocol::sendSynchronousMessage(STKPeer* peer,
const NetworkString& message,
bool reliable)
{
ProtocolManager::getInstance()->sendMessage(this, peer, message, reliable,
/*synchronous*/true);
} // sendSynchronousMessage

14
src/network/protocol.hpp
View File

@ -23,12 +23,12 @@
#ifndef PROTOCOL_HPP
#define PROTOCOL_HPP
#include "network/network_string.hpp"
#include "utils/leak_check.hpp"
#include "utils/no_copy.hpp"
#include "utils/types.hpp"
class Event;
class NewNetworkString;
class STKPeer;
@ -121,18 +121,14 @@ public:
virtual void asynchronousUpdate() = 0;
/// functions to check incoming data easily
NewNetworkString* getNetworkString(int capacity=16);
bool checkDataSizeAndToken(Event* event, int minimum_size);
bool isByteCorrect(Event* event, int byte_nb, int value);
void sendMessageToPeersChangingToken(uint8_t type,
const NetworkString &message);
void sendMessage(const NetworkString& message,
void sendMessageToPeersChangingToken(NewNetworkString *message);
void sendMessage(const NewNetworkString &message,
bool reliable = true);
void sendMessage(STKPeer* peer, const NetworkString& message,
void sendMessage(STKPeer* peer, const NewNetworkString &message,
bool reliable = true);
void sendSynchronousMessage(const NetworkString& message,
bool reliable=true);
void sendSynchronousMessage(STKPeer* peer, const NetworkString& message,
bool reliable = true);
void requestStart();
void requestPause();
void requestUnpause();

36
src/network/protocol_manager.cpp
View File

@ -177,43 +177,25 @@ void ProtocolManager::propagateEvent(Event* event)
} // propagateEvent
// ----------------------------------------------------------------------------
void ProtocolManager::sendMessage(Protocol* sender, const NetworkString& message,
bool reliable, bool send_synchronously)
void ProtocolManager::sendMessage(const NewNetworkString &message, bool reliable)
{
NetworkString new_message(1+message.size());
ProtocolType type = sender->getProtocolType();
// Set flag if the message must be handled synchronously on arrivat
if(send_synchronously)
type = ProtocolType(type | PROTOCOL_SYNCHRONOUS);
new_message.ai8(type); // add one byte to add protocol type
new_message += message;
STKHost::get()->sendMessage(new_message, reliable);
STKHost::get()->sendMessage(message, reliable);
} // sendMessage
// ----------------------------------------------------------------------------
void ProtocolManager::sendMessage(Protocol* sender, STKPeer* peer,
const NetworkString& message, bool reliable,
bool send_synchronously)
void ProtocolManager::sendMessage(STKPeer *peer,
const NewNetworkString &message,
bool reliable)
{
NetworkString new_message(1+message.size());
ProtocolType type = sender->getProtocolType();
// Set flag if the message must be handled synchronously on arrivat
if(send_synchronously)
type = ProtocolType(type | PROTOCOL_SYNCHRONOUS);
new_message.ai8(type); // add one byte to add protocol type
new_message += message;
peer->sendPacket(new_message, reliable);
peer->sendPacket(message, reliable);
} // sendMessage
// ----------------------------------------------------------------------------
void ProtocolManager::sendMessageExcept(Protocol* sender, STKPeer* peer,
const NetworkString& message,
void ProtocolManager::sendMessageExcept(STKPeer *peer,
const NewNetworkString &message,
bool reliable)
{
NetworkString new_message(1+message.size());
new_message.ai8(sender->getProtocolType()); // add one byte to add protocol type
new_message += message;
STKHost::get()->sendPacketExcept(peer, new_message, reliable);
STKHost::get()->sendPacketExcept(peer, message, reliable);
} // sendMessageExcept
// ----------------------------------------------------------------------------

17
src/network/protocol_manager.hpp
View File

@ -162,16 +162,13 @@ private:
public:
virtual void abort();
virtual void propagateEvent(Event* event);
virtual void sendMessage(Protocol* sender,
const NetworkString& message,
bool reliable = true,
bool send_synchronously = false);
virtual void sendMessage(Protocol* sender, STKPeer* peer,
const NetworkString& message,
bool reliable = true,
bool send_synchronously = false);
virtual void sendMessageExcept(Protocol* sender, STKPeer* peer,
const NetworkString& message,
virtual void sendMessage(const NewNetworkString &message,
bool reliable = true);
virtual void sendMessage(STKPeer* peer,
const NewNetworkString &message,
bool reliable = true);
virtual void sendMessageExcept(STKPeer* peer,
const NewNetworkString &message,
bool reliable = true);
virtual uint32_t requestStart(Protocol* protocol);
virtual void requestPause(Protocol* protocol);

124
src/network/protocols/client_lobby_room_protocol.cpp
View File

@ -60,44 +60,55 @@ void ClientLobbyRoomProtocol::setup()
void ClientLobbyRoomProtocol::requestKartSelection(const std::string &kart_name)
{
NetworkString request(6+1+kart_name.size());
NewNetworkString *request = getNetworkString(6+1+kart_name.size());
// size_token (4), token, size kart name, kart name
request.ai8(LE_KART_SELECTION).ai8(4).ai32(m_server->getClientServerToken())
.encodeString(kart_name);
sendMessage(request, true);
request->setToken(m_server->getClientServerToken());
request->addUInt8(LE_KART_SELECTION).encodeString(kart_name);
NewNetworkString *r = getNetworkString(7+kart_name.size());
r->setToken(m_server->getClientServerToken());
r->addUInt8(LE_KART_SELECTION).addUInt8(4).encodeString(kart_name);
sendMessage(*r, true);
delete r;
} // requestKartSelection
//-----------------------------------------------------------------------------
void ClientLobbyRoomProtocol::voteMajor(uint32_t major)
{
NetworkString request(8);
NewNetworkString *request = getNetworkString(8);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size major(1),major
request.ai8(LE_VOTE_MAJOR).ai8(4)
.ai32(m_server->getClientServerToken()).ai8(4).addUInt32(major);
sendMessage(request, true);
request->addUInt8(LE_VOTE_MAJOR).addUInt8(4)
.addUInt8(4).addUInt32(major);
sendMessage(*request, true);
delete request;
} // voteMajor
//-----------------------------------------------------------------------------
void ClientLobbyRoomProtocol::voteRaceCount(uint8_t count)
{
NetworkString request(8);
NewNetworkString *request = getNetworkString(8);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size race count(1), count
request.ai8(LE_VOTE_RACE_COUNT).ai8(4)
.ai32(m_server->getClientServerToken()).ai8(1).ai8(count);
sendMessage(request, true);
request->addUInt8(LE_VOTE_RACE_COUNT).addUInt8(4)
.addUInt8(1).addUInt8(count);
sendMessage(*request, true);
delete request;
} // voteRaceCount
//-----------------------------------------------------------------------------
void ClientLobbyRoomProtocol::voteMinor(uint32_t minor)
{
NetworkString request(8);
NewNetworkString *request = getNetworkString(8);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size minor(1),minor
request.ai8(LE_VOTE_MINOR).ai8(4).ai32(m_server->getClientServerToken())
.ai8(4).addUInt32(minor);
sendMessage(request, true);
request->addUInt8(LE_VOTE_MINOR).addUInt8(4)
.addUInt8(4).addUInt32(minor);
sendMessage(*request, true);
delete request;
} // voteMinor
//-----------------------------------------------------------------------------
@ -105,33 +116,38 @@ void ClientLobbyRoomProtocol::voteMinor(uint32_t minor)
void ClientLobbyRoomProtocol::voteTrack(const std::string &track,
uint8_t track_nb)
{
NetworkString request(8+1+track.size());
NewNetworkString *request = getNetworkString(8+1+track.size());
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size track, track, size #track, #track
request.ai8(LE_VOTE_TRACK).ai8(4).ai32(m_server->getClientServerToken())
.encodeString(track).ai8(1).ai8(track_nb);
sendMessage(request, true);
request->addUInt8(LE_VOTE_TRACK).addUInt8(4)
.encodeString(track).addUInt8(1).addUInt8(track_nb);
sendMessage(*request, true);
delete request;
} // voteTrack
//-----------------------------------------------------------------------------
void ClientLobbyRoomProtocol::voteReversed(bool reversed, uint8_t track_nb)
{
NetworkString request(9);
NewNetworkString *request = getNetworkString(9);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size reversed(1),reversed, size #track, #track
request.ai8(LE_VOTE_REVERSE).ai8(4).ai32(m_server->getClientServerToken())
.ai8(1).ai8(reversed).ai8(1).ai8(track_nb);
sendMessage(request, true);
request->addUInt8(LE_VOTE_REVERSE).addUInt8(4)
.addUInt8(1).addUInt8(reversed).addUInt8(1).addUInt8(track_nb);
sendMessage(*request, true);
delete request;
} // voteReversed
//-----------------------------------------------------------------------------
void ClientLobbyRoomProtocol::voteLaps(uint8_t laps, uint8_t track_nb)
{
NetworkString request(10);
NewNetworkString *request = getNetworkString(10);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size laps(1),laps, size #track, #track
request.ai8(LE_VOTE_LAPS).ai8(4).ai32(m_server->getClientServerToken())
.ai8(1).ai8(laps).ai8(1).ai8(track_nb);
sendMessage(request, true);
request->addUInt8(LE_VOTE_LAPS)
.addUInt8(1).addUInt8(laps).addUInt8(1).addUInt8(track_nb);
sendMessage(*request, true);
} // voteLaps
//-----------------------------------------------------------------------------
@ -151,7 +167,7 @@ bool ClientLobbyRoomProtocol::notifyEvent(Event* event)
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
assert(data.size()); // assert that data isn't empty
uint8_t message_type = data[0];
if (message_type != LE_KART_SELECTION_UPDATE &&
@ -178,7 +194,7 @@ bool ClientLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
assert(data.size()); // assert that data isn't empty
uint8_t message_type = data[0];
@ -244,11 +260,13 @@ void ClientLobbyRoomProtocol::update()
std::string name_u8 = StringUtils::wideToUtf8(name);
const std::string &password = NetworkConfig::get()->getPassword();
NetworkString ns(6+1+name_u8.size()+1+password.size());
NewNetworkString *ns = getNetworkString(6+1+name_u8.size()
+1+password.size());
// 4 (size of id), global id
ns.ai8(LE_CONNECTION_REQUESTED).encodeString(name)
ns->addUInt8(LE_CONNECTION_REQUESTED).encodeString(name)
.encodeString(NetworkConfig::get()->getPassword());
sendMessage(ns);
sendMessage(*ns);
delete ns;
m_state = REQUESTING_CONNECTION;
}
break;
@ -301,7 +319,7 @@ void ClientLobbyRoomProtocol::update()
*/
void ClientLobbyRoomProtocol::newPlayer(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@ -310,7 +328,7 @@ void ClientLobbyRoomProtocol::newPlayer(Event* event)
return;
}
uint8_t player_id = data.gui8(1);
uint8_t player_id = data.getUInt8(1);
core::stringw name;
data.decodeStringW(2, &name);
@ -349,7 +367,7 @@ void ClientLobbyRoomProtocol::newPlayer(Event* event)
*/
void ClientLobbyRoomProtocol::disconnectedPlayer(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() != 2 || data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@ -383,7 +401,7 @@ void ClientLobbyRoomProtocol::disconnectedPlayer(Event* event)
*/
void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
{
NetworkString &data = event->data();
const NewNetworkString &data = event->data();
// At least 12 bytes should remain now
if (data.size() < 9|| data[0] != 1 || data[2] != 4)
{
@ -418,7 +436,7 @@ void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
STKHost::get()->getGameSetup()->setLocalMaster(my_player_id);
m_setup->setNumLocalPlayers(1);
// connection token
uint32_t token = data.gui32(3);
uint32_t token = data.getUInt32(3);
peer->setClientServerToken(token);
// Add all players
@ -467,7 +485,7 @@ void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
*/
void ClientLobbyRoomProtocol::connectionRefused(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() != 2 || data[0] != 1) // 2 bytes remains now
{
Log::error("ClientLobbyRoomProtocol",
@ -508,7 +526,7 @@ void ClientLobbyRoomProtocol::connectionRefused(Event* event)
*/
void ClientLobbyRoomProtocol::kartSelectionRefused(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() != 2 || data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@ -547,7 +565,7 @@ void ClientLobbyRoomProtocol::kartSelectionRefused(Event* event)
*/
void ClientLobbyRoomProtocol::kartSelectionUpdate(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() < 3 || data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@ -582,14 +600,14 @@ void ClientLobbyRoomProtocol::kartSelectionUpdate(Event* event)
*/
void ClientLobbyRoomProtocol::startGame(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() < 5 || data[0] != 4)
{
Log::error("ClientLobbyRoomProtocol", "A message notifying a kart "
"selection update wasn't formated as expected.");
return;
}
uint32_t token = data.gui32(1);
uint32_t token = data.getUInt32(1);
if (token == STKHost::get()->getPeers()[0]->getClientServerToken())
{
m_state = PLAYING;
@ -616,14 +634,14 @@ void ClientLobbyRoomProtocol::startGame(Event* event)
*/
void ClientLobbyRoomProtocol::startSelection(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() < 5 || data[0] != 4)
{
Log::error("ClientLobbyRoomProtocol", "A message notifying a kart "
"selection update wasn't formated as expected.");
return;
}
uint32_t token = data.gui32(1);
uint32_t token = data.getUInt32(1);
if (token == STKHost::get()->getPeers()[0]->getClientServerToken())
{
m_state = KART_SELECTION;
@ -648,13 +666,13 @@ void ClientLobbyRoomProtocol::startSelection(Event* event)
*/
void ClientLobbyRoomProtocol::raceFinished(Event* event)
{
NetworkString &data = event->data();
NewNetworkString &data = event->data();
if (data.size() < 5)
{
Log::error("ClientLobbyRoomProtocol", "Not enough data provided.");
return;
}
if (event->getPeer()->getClientServerToken() != data.gui32(1))
if (event->getPeer()->getClientServerToken() != data.getUInt32(1))
{
Log::error("ClientLobbyRoomProtocol", "Bad token");
return;
@ -731,7 +749,7 @@ void ClientLobbyRoomProtocol::raceFinished(Event* event)
*/
void ClientLobbyRoomProtocol::playerMajorVote(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))
@ -754,7 +772,7 @@ void ClientLobbyRoomProtocol::playerMajorVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerRaceCountVote(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))
@ -777,7 +795,7 @@ void ClientLobbyRoomProtocol::playerRaceCountVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerMinorVote(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))
@ -801,7 +819,7 @@ void ClientLobbyRoomProtocol::playerMinorVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerTrackVote(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 10))
return;
if (!isByteCorrect(event, 5, 1))
@ -828,7 +846,7 @@ void ClientLobbyRoomProtocol::playerTrackVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerReversedVote(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 11))
return;
if (!isByteCorrect(event, 5, 1))
@ -854,7 +872,7 @@ void ClientLobbyRoomProtocol::playerReversedVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerLapsVote(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))

37
src/network/protocols/controller_events_protocol.cpp
View File

@ -50,7 +50,7 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() < 17)
{
Log::error("ControllerEventsProtocol",
@ -58,15 +58,15 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
data.size());
return true;
}
uint32_t token = data.gui32();
NetworkString pure_message = data;
uint32_t token = data.getUInt32();
NewNetworkString pure_message = data;
pure_message.removeFront(4);
if (token != event->getPeer()->getClientServerToken())
{
Log::error("ControllerEventsProtocol", "Bad token from peer.");
return true;
}
NetworkString ns = pure_message;
NewNetworkString ns = pure_message;
ns.removeFront(4);
uint8_t client_index = -1;
@ -80,9 +80,9 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
kart_id);
return true;
}
uint8_t serialized_1 = ns.gui8(1);
PlayerAction action = (PlayerAction)(ns.gui8(4));
int action_value = ns.gui32(5);
uint8_t serialized_1 = ns.getUInt8(1);
PlayerAction action = (PlayerAction)(ns.getUInt8(4));
int action_value = ns.getUInt32(5);
Controller *controller = World::getWorld()->getKart(kart_id)
->getController();
KartControl *controls = controller->getControls();
@ -113,11 +113,9 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
// was sent from originally
if(peer != event->getPeer())
{
NetworkString ns2(4+pure_message.size());
ns2.ai32(peer->getClientServerToken());
ns2 += pure_message;
ProtocolManager::getInstance()->sendMessage(this, peer,
ns2, false);
pure_message.setToken(peer->getClientServerToken());
ProtocolManager::getInstance()->sendMessage(peer, pure_message,
false);
} // if peer != event->getPeer()
} // for i in peers
} // if server
@ -159,14 +157,13 @@ void ControllerEventsProtocol::controllerAction(Controller* controller,
uint8_t serialized_2 = (uint8_t)(controls->m_accel*255.0);
uint8_t serialized_3 = (uint8_t)(controls->m_steer*127.0);
NetworkString ns(17);
uint32_t token = STKHost::get()->getPeers()[0]->getClientServerToken();
ns.ai32(token);
ns.af(World::getWorld()->getTime());
ns.addUInt8(controller->getKart()->getWorldKartId());
ns.ai8(serialized_1).ai8(serialized_2).ai8(serialized_3);
ns.ai8((uint8_t)(action)).ai32(value);
NewNetworkString *ns = getNetworkString(17);
ns->setToken(STKHost::get()->getPeers()[0]->getClientServerToken());
ns->addFloat(World::getWorld()->getTime());
ns->addUInt8(controller->getKart()->getWorldKartId());
ns->addUInt8(serialized_1).addUInt8(serialized_2).addUInt8(serialized_3);
ns->addUInt8((uint8_t)(action)).addUInt32(value);
Log::info("ControllerEventsProtocol", "Action %d value %d", action, value);
sendMessage(ns, false); // send message to server
sendMessage(*ns, false); // send message to server
} // controllerAction

45
src/network/protocols/game_events_protocol.cpp
View File

@ -38,18 +38,18 @@ bool GameEventsProtocol::notifyEvent(Event* event)
{
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
NetworkString &data = event->data();
NewNetworkString &data = event->data();
if (data.size() < 5) // for token and type
{
Log::warn("GameEventsProtocol", "Too short message.");
return true;
}
if ( event->getPeer()->getClientServerToken() != data.gui32())
if ( event->getPeer()->getClientServerToken() != data.getUInt32())
{
Log::warn("GameEventsProtocol", "Bad token.");
return true;
}
int8_t type = data.gui8(4);
int8_t type = data.getUInt8(4);
data.removeFront(5);
switch (type)
{
@ -85,8 +85,9 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString ns(11);
ns.ai32(peers[i]->getClientServerToken());
NewNetworkString *ns = getNetworkString(11);
ns->setToken(peers[i]->getClientServerToken());
ns->setSynchronous(true);
// Item picked : send item id, powerup type and kart race id
uint8_t powerup = 0;
if (item->getType() == Item::ITEM_BANANA)
@ -95,11 +96,11 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
powerup = (((int)(kart->getPowerup()->getType()) << 4) & 0xf0)
+ (kart->getPowerup()->getNum() & 0x0f);
ns.ai8(GE_ITEM_COLLECTED).ai32(item->getItemId()).ai8(powerup)
.ai8(kart->getWorldKartId());
ProtocolManager::getInstance()->sendMessage(this, peers[i], ns,
/*reliable*/true,
/*synchronous*/true);
ns->addUInt8(GE_ITEM_COLLECTED).addUInt32(item->getItemId())
.addUInt8(powerup).addUInt8(kart->getWorldKartId());
ProtocolManager::getInstance()->sendMessage(peers[i], *ns,
/*reliable*/true);
delete ns;
Log::info("GameEventsProtocol",
"Notified a peer that a kart collected item %d.",
(int)(kart->getPowerup()->getType()));
@ -109,15 +110,15 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
// ----------------------------------------------------------------------------
/** Called on the client when an itemCollected message is received.
*/
void GameEventsProtocol::collectedItem(const NetworkString &data)
void GameEventsProtocol::collectedItem(const NewNetworkString &data)
{
if (data.size() < 6)
{
Log::warn("GameEventsProtocol", "Too short message.");
}
uint32_t item_id = data.gui32();
uint8_t powerup_type = data.gui8(4);
uint8_t kart_id = data.gui8(5);
uint32_t item_id = data.getUInt32();
uint8_t powerup_type = data.getUInt8(4);
uint8_t kart_id = data.getUInt8(5);
// now set the kart powerup
AbstractKart* kart = World::getWorld()->getKart(kart_id);
ItemManager::get()->collectedItem(ItemManager::get()->getItem(item_id),
@ -134,18 +135,20 @@ void GameEventsProtocol::collectedItem(const NetworkString &data)
*/
void GameEventsProtocol::kartFinishedRace(AbstractKart *kart, float time)
{
NetworkString ns(20);
NewNetworkString *ns = getNetworkString(20);
ns->setSynchronous(true);
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
// FIXME - TODO THIS APPEARS COMPLETELY BROKEN!!!
for (unsigned int i = 0; i < peers.size(); i++)
{
ns.addUInt32(peers[i]->getClientServerToken())
ns->addUInt32(peers[i]->getClientServerToken())
.addUInt8(GE_KART_FINISHED_RACE)
.addUInt8(kart->getWorldKartId()).addFloat(time);
ProtocolManager::getInstance()->sendMessage(this, peers[i], ns,
/*reliable*/true,
/*synchronous*/true);
ProtocolManager::getInstance()->sendMessage(peers[i], *ns,
/*reliable*/true);
delete ns;
} // for i in peers
} // kartFinishedRace
@ -154,7 +157,7 @@ void GameEventsProtocol::kartFinishedRace(AbstractKart *kart, float time)
* event from the server. It updates the game with this information.
* \param ns The message from the server.
*/
void GameEventsProtocol::kartFinishedRace(const NetworkString &ns)
void GameEventsProtocol::kartFinishedRace(const NewNetworkString &ns)
{
uint8_t kart_id = ns.getUInt8(0);
float time = ns.getFloat(1);

4
src/network/protocols/game_events_protocol.hpp
View File

@ -22,9 +22,9 @@ public:
virtual void setup();
virtual void update();
void collectedItem(Item* item, AbstractKart* kart);
void collectedItem(const NetworkString &ns);
void collectedItem(const NewNetworkString &ns);
void kartFinishedRace(AbstractKart *kart, float time);
void kartFinishedRace(const NetworkString &ns);
void kartFinishedRace(const NewNetworkString &ns);
// ------------------------------------------------------------------------
virtual void asynchronousUpdate() {}
// ------------------------------------------------------------------------

1
src/network/protocols/get_public_address.cpp
View File

@ -21,6 +21,7 @@
#include "config/user_config.hpp"
#include "network/network.hpp"
#include "network/network_config.hpp"
#include "network/network_string.hpp"
#include "network/protocols/connect_to_server.hpp"
#include "utils/log.hpp"

32
src/network/protocols/kart_update_protocol.cpp
View File

@ -38,7 +38,7 @@ bool KartUpdateProtocol::notifyEvent(Event* event)
{
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
NetworkString &ns = event->data();
NewNetworkString &ns = event->data();
if (ns.size() < 33)
{
Log::info("KartUpdateProtocol", "Message too short.");
@ -48,9 +48,8 @@ bool KartUpdateProtocol::notifyEvent(Event* event)
while(ns.size() >= 29)
{
uint8_t kart_id = ns.getUInt8(0);
Vec3 xyz;
btQuaternion quat;
ns.get(&xyz, 1).get(&quat, 13);
Vec3 xyz = ns.getVec3(1);
btQuaternion quat = ns.getQuat(13);
m_next_positions [kart_id] = xyz;
m_next_quaternions[kart_id] = quat;
ns.removeFront(29);
@ -81,35 +80,40 @@ void KartUpdateProtocol::update()
if (NetworkConfig::get()->isServer())
{
World *world = World::getWorld();
NetworkString ns(4+world->getNumKarts()*29);
ns.af( world->getTime() );
NewNetworkString *ns = getNetworkString(4+world->getNumKarts()*29);
ns->setSynchronous(true);
ns->addFloat( world->getTime() );
for (unsigned int i = 0; i < world->getNumKarts(); i++)
{
AbstractKart* kart = world->getKart(i);
Vec3 xyz = kart->getXYZ();
ns.addUInt8( kart->getWorldKartId());
ns.add(xyz).add(kart->getRotation());
ns->addUInt8( kart->getWorldKartId());
ns->add(xyz).add(kart->getRotation());
Log::verbose("KartUpdateProtocol",
"Sending %d's positions %f %f %f",
kart->getWorldKartId(), xyz[0], xyz[1], xyz[2]);
}
sendSynchronousMessage(ns, false);
sendMessage(*ns, /*reliable*/false);
delete ns;
}
else
{
NetworkString ns(4+29*race_manager->getNumLocalPlayers());
ns.af(World::getWorld()->getTime());
NewNetworkString *ns =
getNetworkString(4+29*race_manager->getNumLocalPlayers());
ns->setSynchronous(true);
ns->addFloat(World::getWorld()->getTime());
for(unsigned int i=0; i<race_manager->getNumLocalPlayers(); i++)
{
AbstractKart *kart = World::getWorld()->getLocalPlayerKart(i);
const Vec3 &xyz = kart->getXYZ();
ns.addUInt8(kart->getWorldKartId());
ns.add(xyz).add(kart->getRotation());
ns->addUInt8(kart->getWorldKartId());
ns->add(xyz).add(kart->getRotation());
Log::verbose("KartUpdateProtocol",
"Sending %d's positions %f %f %f",
kart->getWorldKartId(), xyz[0], xyz[1], xyz[2]);
}
sendSynchronousMessage(ns, false);
sendMessage(*ns, /*reliable*/false);
delete ns;
} // if server
} // if (current_time > time + 0.1)

180
src/network/protocols/server_lobby_room_protocol.cpp
View File

@ -78,7 +78,7 @@ bool ServerLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
assert(data.size()); // message not empty
uint8_t message_type;
message_type = data[0];
@ -226,9 +226,11 @@ void ServerLobbyRoomProtocol::startGame()
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString ns(6);
ns.ai8(LE_START_RACE).ai8(4).ai32(peers[i]->getClientServerToken());
sendMessage(peers[i], ns, true); // reliably
NewNetworkString *ns = getNetworkString(6);
ns->setToken(peers[i]->getClientServerToken());
ns->addUInt8(LE_START_RACE).addUInt8(4);
sendMessage(peers[i], *ns, true); // reliably
delete ns;
}
Protocol *p = new StartGameProtocol(m_setup);
p->requestStart();
@ -251,10 +253,12 @@ void ServerLobbyRoomProtocol::startSelection(const Event *event)
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString ns(6);
NewNetworkString *ns = getNetworkString(6);
ns->setToken(peers[i]->getClientServerToken());
// start selection
ns.ai8(LE_START_SELECTION).ai8(4).ai32(peers[i]->getClientServerToken());
sendMessage(peers[i], ns, true); // reliably
ns->addUInt8(LE_START_SELECTION).addUInt8(4);
sendMessage(peers[i], *ns, true); // reliably
delete ns;
}
m_selection_enabled = true;
@ -338,19 +342,22 @@ void ServerLobbyRoomProtocol::checkRaceFinished()
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
NetworkString queue(karts_results.size()*2);
NewNetworkString *queue = getNetworkString(karts_results.size()*2);
for (unsigned int i = 0; i < karts_results.size(); i++)
{
queue.ai8(1).ai8(karts_results[i]); // kart pos = i+1
queue->addUInt8(1).addUInt8(karts_results[i]); // kart pos = i+1
Log::info("ServerLobbyRoomProtocol", "Kart %d finished #%d",
karts_results[i], i + 1);
}
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString ns(6);
ns.ai8(LE_RACE_FINISHED).ai8(4).ai32(peers[i]->getClientServerToken());
NetworkString total = ns + queue;
sendSynchronousMessage(peers[i], total, true);
NewNetworkString *total = getNetworkString();
total->setSynchronous(true);
total->setToken(peers[i]->getClientServerToken());
total->addUInt8(LE_RACE_FINISHED).addUInt8(4);
*total += *queue;
sendMessage(peers[i], *total, /*reliable*/true);
delete total;
}
Log::info("ServerLobbyRoomProtocol", "End of game message sent");
m_in_race = false;
@ -395,10 +402,11 @@ void ServerLobbyRoomProtocol::kartDisconnected(Event* event)
STKPeer* peer = event->getPeer();
if (peer->getPlayerProfile() != NULL) // others knew him
{
NetworkString msg(3);
msg.ai8(LE_PLAYER_DISCONNECTED).ai8(1)
.ai8(peer->getPlayerProfile()->getGlobalPlayerId());
sendMessage(msg);
NewNetworkString *msg = getNetworkString(3);
msg->addUInt8(LE_PLAYER_DISCONNECTED).addUInt8(1)
.addUInt8(peer->getPlayerProfile()->getGlobalPlayerId());
sendMessage(*msg);
delete msg;
Log::info("ServerLobbyRoomProtocol", "Player disconnected : id %d",
peer->getPlayerProfile()->getGlobalPlayerId());
m_setup->removePlayer(peer->getPlayerProfile());
@ -425,19 +433,20 @@ void ServerLobbyRoomProtocol::kartDisconnected(Event* event)
void ServerLobbyRoomProtocol::connectionRequested(Event* event)
{
STKPeer* peer = event->getPeer();
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
// can we add the player ?
if (m_setup->getPlayerCount() >= NetworkConfig::get()->getMaxPlayers() ||
m_state!=ACCEPTING_CLIENTS )
{
NetworkString message(3);
NewNetworkString *message = getNetworkString(3);
// Len, error code: 2 = busy, 0 = too many players
message.ai8(LE_CONNECTION_REFUSED).ai8(1)
.ai8(m_state!=ACCEPTING_CLIENTS ? 2 : 0);
message->addUInt8(LE_CONNECTION_REFUSED).addUInt8(1)
.addUInt8(m_state!=ACCEPTING_CLIENTS ? 2 : 0);
// send only to the peer that made the request
sendMessage(peer, message);
sendMessage(peer, *message);
delete message;
Log::verbose("ServerLobbyRoomProtocol", "Player refused");
return;
}
@ -465,11 +474,12 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
// Notify everybody that there is a new player
// -------------------------------------------
NetworkString message(8);
NewNetworkString *message = getNetworkString(8);
// size of id -- id -- size of local id -- local id;
message.ai8(LE_NEW_PLAYER_CONNECTED).ai8(1).ai8(new_player_id)
message->addUInt8(LE_NEW_PLAYER_CONNECTED).addUInt8(1).addUInt8(new_player_id)
.encodeString(name_u8).addUInt8(new_host_id);
ProtocolManager::getInstance()->sendMessageExcept(this, peer, message);
ProtocolManager::getInstance()->sendMessageExcept(peer, *message);
delete message;
// Now answer to the peer that just connected
// ------------------------------------------
@ -483,19 +493,21 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
const std::vector<NetworkPlayerProfile*> &players = m_setup->getPlayers();
// send a message to the one that asked to connect
// Size is overestimated, probably one player's data will not be sent
NetworkString message_ack(14 + players.size() * 7);
NewNetworkString *message_ack = getNetworkString(14 + players.size() * 7);
message_ack->setToken(token);
// connection success -- size of token -- token
message_ack.ai8(LE_CONNECTION_ACCEPTED).ai8(1).ai8(new_player_id).ai8(4)
.ai32(token).addUInt8(new_host_id).addUInt8(is_authorised);
message_ack->addUInt8(LE_CONNECTION_ACCEPTED).addUInt8(1).addUInt8(new_player_id).addUInt8(4)
.addUInt8(new_host_id).addUInt8(is_authorised);
// Add all players so that this user knows (this new player is only added
// to the list of players later, so the new player's info is not included)
for (unsigned int i = 0; i < players.size(); i++)
{
message_ack.ai8(1).ai8(players[i]->getGlobalPlayerId())
message_ack->addUInt8(1).addUInt8(players[i]->getGlobalPlayerId())
.encodeString(players[i]->getName())
.addUInt8(players[i]->getHostId());
}
sendMessage(peer, message_ack);
sendMessage(peer, *message_ack);
delete message_ack;
NetworkPlayerProfile* profile = new NetworkPlayerProfile(new_player_id, name);
profile->setHostId(new_host_id);
@ -516,10 +528,10 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
*
* Format of the data :
* Byte 0 1 5 6 N+6
* ---------------------------------------------------
* Size | 1 | 4 | 1 | N |
* Data | 4 | priv token | N (kart name size) | kart name |
* ---------------------------------------------------
* -----------------------------------------------
* Size | 4 | 1 | N |
* Data | priv token | N (kart name size) | kart name |
* -----------------------------------------------
*/
void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
{
@ -530,7 +542,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
return;
}
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 6))
return;
@ -540,38 +552,43 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
// check if selection is possible
if (!m_selection_enabled)
{
NetworkString answer(3);
NewNetworkString *answer = getNetworkString(3);
// selection still not started
answer.ai8(LE_KART_SELECTION_REFUSED).ai8(1).ai8(2);
sendMessage(peer, answer);
answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(2);
sendMessage(peer, *answer);
delete answer;
return;
}
// check if somebody picked that kart
if (!m_setup->isKartAvailable(kart_name))
{
NetworkString answer(3);
NewNetworkString *answer = getNetworkString(3);
// kart is already taken
answer.ai8(LE_KART_SELECTION_REFUSED).ai8(1).ai8(0);
sendMessage(peer, answer);
answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(0);
sendMessage(peer, *answer);
delete answer;
return;
}
// check if this kart is authorized
if (!m_setup->isKartAllowed(kart_name))
{
NetworkString answer(3);
NewNetworkString *answer = getNetworkString(3);
// kart is not authorized
answer.ai8(LE_KART_SELECTION_REFUSED).ai8(1).ai8(1);
sendMessage(peer, answer);
answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(1);
sendMessage(peer, *answer);
delete answer;
return;
}
// send a kart update to everyone
NetworkString answer(3+1+kart_name.size());
NewNetworkString *answer = getNetworkString(3+1+kart_name.size());
// This message must be handled synchronously on the client.
answer->setSynchronous(true);
// kart update (3), 1, race id
uint8_t player_id = peer->getPlayerProfile()->getGlobalPlayerId();
answer.ai8(LE_KART_SELECTION_UPDATE).ai8(1).ai8(player_id)
answer->addUInt8(LE_KART_SELECTION_UPDATE).addUInt8(1).addUInt8(player_id)
.encodeString(kart_name);
// This message must be handled synchronously on the client.
sendSynchronousMessage(answer);
sendMessage(*answer);
delete answer;
m_setup->setPlayerKart(player_id, kart_name);
} // kartSelectionRequested
@ -589,7 +606,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
*/
void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
{
NetworkString &data = event->data();
NewNetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 7))
return;
@ -600,10 +617,11 @@ void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
m_setup->getRaceConfig()->setPlayerMajorVote(player_id, major);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NetworkString other(5+data.size());
other.ai8(1).ai8(player_id); // add the player id
other += data; // add the data
sendMessageToPeersChangingToken(LE_VOTE_MAJOR, other);
NewNetworkString *other = getNetworkString(6+data.size());
other->addUInt8(LE_VOTE_MAJOR).addUInt8(1).addUInt8(player_id); // add the player id
*other += data; // add the data
sendMessageToPeersChangingToken(other);
delete other;
} // playerMajorVote
//-----------------------------------------------------------------------------
@ -620,7 +638,7 @@ void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
{
NetworkString &data = event->data();
NewNetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 7))
return;
@ -630,10 +648,12 @@ void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
m_setup->getRaceConfig()->setPlayerRaceCountVote(player_id, data[6]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NetworkString other(2+data.size());
other.ai8(1).ai8(player_id); // add the player id
other += data; // add the data
sendMessageToPeersChangingToken(LE_VOTE_RACE_COUNT, other);
NewNetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_RACE_COUNT).addUInt8(1)
.addUInt8(player_id); // add the player id
*other += data; // add the data
sendMessageToPeersChangingToken(other);
delete other;
} // playerRaceCountVote
//-----------------------------------------------------------------------------
@ -650,7 +670,7 @@ void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
{
NetworkString &data = event->data();
NewNetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 7))
return;
@ -661,10 +681,11 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
m_setup->getRaceConfig()->setPlayerMinorVote(player_id, minor);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NetworkString other(2+data.size());
other.ai8(1).ai8(player_id); // add the player id
other += data; // add the data
sendMessageToPeersChangingToken(LE_VOTE_MINOR, other);
NewNetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_MINOR).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);
delete other;
} // playerMinorVote
//-----------------------------------------------------------------------------
@ -681,7 +702,7 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
{
NetworkString &data = event->data();
NewNetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 8))
return;
@ -693,10 +714,11 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
m_setup->getRaceConfig()->setPlayerTrackVote(player_id, track_name, data[N+6]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NetworkString other(2+data.size());
other.ai8(1).ai8(player_id); // add the player id
other += data; // add the data
sendMessageToPeersChangingToken(LE_VOTE_TRACK, other);
NewNetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_TRACK).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);
delete other;
if(m_setup->getRaceConfig()->getNumTrackVotes()==m_setup->getPlayerCount())
startGame();
} // playerTrackVote
@ -715,7 +737,7 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
{
NetworkString &data = event->data();
NewNetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 9))
return;
@ -728,10 +750,11 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
data[6]!=0, data[8]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NetworkString other(2+data.size());
other.ai8(1).ai8(player_id); // add the player id
other += data; // add the data
sendMessageToPeersChangingToken(LE_VOTE_REVERSE, other);
NewNetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_REVERSE).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);
delete other;
} // playerReversedVote
//-----------------------------------------------------------------------------
@ -748,7 +771,7 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerLapsVote(Event* event)
{
NetworkString &data = event->data();
NewNetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 9))
return;
@ -760,10 +783,11 @@ void ServerLobbyRoomProtocol::playerLapsVote(Event* event)
m_setup->getRaceConfig()->setPlayerLapsVote(player_id, data[6], data[8]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NetworkString other(2+data.size());
other.ai8(1).ai8(player_id); // add the player id
other += data; // add the data
sendMessageToPeersChangingToken(LE_VOTE_LAPS, other);
NewNetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_LAPS).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);
delete other;
} // playerLapsVote
//-----------------------------------------------------------------------------

14
src/network/protocols/start_game_protocol.cpp
View File

@ -123,14 +123,14 @@ void StartGameProtocol::setup()
// ----------------------------------------------------------------------------
bool StartGameProtocol::notifyEventAsynchronous(Event* event)
{
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() < 5)
{
Log::error("StartGameProtocol", "Too short message.");
return true;
}
uint32_t token = data.gui32();
uint8_t ready = data.gui8(4);
uint32_t token = data.getUInt32();
uint8_t ready = data.getUInt8(4);
STKPeer* peer = event->getPeer();
if (peer->getClientServerToken() != token)
{
@ -219,10 +219,12 @@ void StartGameProtocol::ready()
if (NetworkConfig::get()->isClient())
{
assert(STKHost::get()->getPeerCount() == 1);
NetworkString ns(5);
ns.ai32(STKHost::get()->getPeers()[0]->getClientServerToken()).ai8(1);
NewNetworkString *ns = getNetworkString(5);
ns->setToken(STKHost::get()->getPeers()[0]->getClientServerToken());
ns->addUInt8(1);
Log::info("StartGameProtocol", "Player ready, notifying server.");
sendMessage(ns, true);
sendMessage(*ns, /*reliable*/true);
delete ns;
m_state = READY;
m_ready = true;
return;

29
src/network/protocols/synchronization_protocol.cpp
View File

@ -43,15 +43,15 @@ bool SynchronizationProtocol::notifyEventAsynchronous(Event* event)
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
const NetworkString &data = event->data();
const NewNetworkString &data = event->data();
if (data.size() < 9)
{
Log::warn("SynchronizationProtocol", "Received a too short message.");
return true;
}
uint32_t token = data.gui32(0);
uint32_t request = data.gui8(4);
uint32_t sequence = data.gui32(5);
uint32_t token = data.getUInt32(0);
uint32_t request = data.getUInt8(4);
uint32_t sequence = data.getUInt32(5);
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
assert(peers.size() > 0);
@ -79,17 +79,19 @@ bool SynchronizationProtocol::notifyEventAsynchronous(Event* event)
{
// Only a client should receive a request for a ping response
assert(NetworkConfig::get()->isClient());
NetworkString response(10);
NewNetworkString *response = getNetworkString(10);
response->setToken(token);
// The '0' indicates a response to a ping request
response.ai32(token).ai8(0).ai32(sequence);
sendMessage(event->getPeer(), response, false);
response->addUInt8(0).addUInt32(sequence);
sendMessage(event->getPeer(), *response, false);
delete response;
Log::verbose("SynchronizationProtocol", "Answering sequence %u at %lf",
sequence, StkTime::getRealTime());
// countdown time in the message
if (data.size() == 13)
{
uint32_t time_to_start = data.gui32(9);
uint32_t time_to_start = data.getUInt32(9);
Log::debug("SynchronizationProtocol",
"Request to start game in %d.", time_to_start);
if (!m_countdown_activated)
@ -169,15 +171,15 @@ void SynchronizationProtocol::asynchronousUpdate()
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString ping_request(13);
ping_request.addUInt32(peers[i]->getClientServerToken())
.addUInt8(1).addUInt32(m_pings[i].size());
NewNetworkString *ping_request = getNetworkString(13);
ping_request->setToken(peers[i]->getClientServerToken());
ping_request->addUInt8(1).addUInt32(m_pings[i].size());
// Server adds the countdown if it has started. This will indicate
// to the client to start the countdown as well (first time the
// message is received), or to update the countdown time.
if (m_countdown_activated )
{
ping_request.addUInt32((int)(m_countdown*1000.0));
ping_request->addUInt32((int)(m_countdown*1000.0));
Log::debug("SynchronizationProtocol",
"CNTActivated: Countdown value : %f", m_countdown);
}
@ -185,7 +187,8 @@ void SynchronizationProtocol::asynchronousUpdate()
"Added sequence number %u for peer %d at %lf",
m_pings[i].size(), i, StkTime::getRealTime());
m_pings[i] [ m_pings_count ] = current_time;
sendMessage(peers[i], ping_request, false);
sendMessage(peers[i], *ping_request, false);
delete ping_request;
} // for i M peers
m_last_time = current_time;
m_pings_count++;

8
src/network/stk_host.cpp
View File

@ -440,7 +440,7 @@ bool STKHost::connect(const TransportAddress& address)
* \param data Message to sent.
* \param reliable If the message is to be sent reliable.
*/
void STKHost::sendMessage(const NetworkString& data, bool reliable)
void STKHost::sendMessage(const NewNetworkString& data, bool reliable)
{
if (NetworkConfig::get()->isServer())
broadcastPacket(data, reliable);
@ -604,13 +604,13 @@ void STKHost::handleLANRequests()
// current players, and the client's ip address and port
// number (which solves the problem which network interface
// might be the right one if there is more than one).
NetworkString s;
NewNetworkString s(PROTOCOL_NONE);
s.encodeString(name);
s.addUInt8(NetworkConfig::get()->getMaxPlayers());
s.addUInt8(0); // FIXME: current number of connected players
s.addUInt32(sender.getIP());
s.addUInt16(sender.getPort());
m_lan_network->sendRawPacket(s.getBytes(), s.size(), sender);
m_lan_network->sendRawPacket(s.getData(), s.size(), sender);
} // if message is server-requested
else if (std::string(buffer, len) == "connection-request")
{
@ -740,7 +740,7 @@ uint16_t STKHost::getPort() const
* \param data Data to sent.
* \param reliable If the data should be sent reliable or now.
*/
void STKHost::sendPacketExcept(STKPeer* peer, const NetworkString& data,
void STKHost::sendPacketExcept(STKPeer* peer, const NewNetworkString &data,
bool reliable)
{
for (unsigned int i = 0; i < m_peers.size(); i++)

6
src/network/stk_host.hpp
View File

@ -145,9 +145,9 @@ public:
void requestShutdown();
void shutdown();
void sendMessage(const NetworkString& data, bool reliable = true);
void sendMessage(const NewNetworkString& data, bool reliable = true);
void sendPacketExcept(STKPeer* peer,
const NetworkString& data,
const NewNetworkString& data,
bool reliable = true);
void setupClient(int peer_count, int channel_limit,
uint32_t max_incoming_bandwidth,
@ -181,7 +181,7 @@ public:
} // receiveRawPacket
// --------------------------------------------------------------------
void broadcastPacket(const NetworkString& data,
void broadcastPacket(const NewNetworkString& data,
bool reliable = true)
{
m_network->broadcastPacket(data, reliable);

4
src/network/stk_peer.cpp
View File

@ -62,13 +62,13 @@ void STKPeer::disconnect()
* \param data The data to send.
* \param reliable If the data is sent reliable or not.
*/
void STKPeer::sendPacket(NetworkString const& data, bool reliable)
void STKPeer::sendPacket(NewNetworkString const& data, bool reliable)
{
TransportAddress a(m_enet_peer->address);
Log::verbose("STKPeer", "sending packet of size %d to %s",
data.size(), a.toString().c_str());
ENetPacket* packet = enet_packet_create(data.getBytes(), data.size() + 1,
ENetPacket* packet = enet_packet_create(data.getData(), data.size() + 1,
(reliable ? ENET_PACKET_FLAG_RELIABLE
: ENET_PACKET_FLAG_UNSEQUENCED));
enet_peer_send(m_enet_peer, 0, packet);

5
src/network/stk_peer.hpp
View File

@ -29,7 +29,7 @@
#include <enet/enet.h>
class NetworkPlayerProfile;
class NetworkString;
class NewNetworkString;
class TransportAddress;
/*! \class STKPeer
@ -59,7 +59,8 @@ public:
STKPeer(ENetPeer *enet_peer);
virtual ~STKPeer();
virtual void sendPacket(const NetworkString& data, bool reliable = true);
virtual void sendPacket(const NewNetworkString &data,
bool reliable = true);
void disconnect();
bool isConnected() const;
bool exists() const;

5
src/states_screens/networking_lobby.cpp
View File

@ -141,9 +141,8 @@ void NetworkingLobby::eventCallback(Widget* widget, const std::string& name,
if(name==m_start_button->m_properties[PROP_ID])
{
// Send a message to the server to start
NetworkString start;
start.addUInt8(PROTOCOL_LOBBY_ROOM)
.addUInt8(LobbyRoomProtocol::LE_REQUEST_BEGIN);
NewNetworkString start(PROTOCOL_LOBBY_ROOM);
start.addUInt8(LobbyRoomProtocol::LE_REQUEST_BEGIN);
STKHost::get()->sendMessage(start, true);
}