Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Switched to generic endian swap #2380

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
+110 −375
Open

Switched to generic endian swap #2380

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
2 changes: 1 addition & 1 deletion examples/voip/Server.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -119,7 +119,7 @@ class NetworkAudioStream : public sf::SoundStream
break;

// Extract the message ID
std::uint8_t id;
std::uint8_t id = 0;
packet >> id;

if (id == serverAudioData)
Expand Down
160 changes: 68 additions & 92 deletions include/SFML/Network/Packet.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,17 +29,59 @@
////////////////////////////////////////////////////////////
#include <SFML/Network/Export.hpp>

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstring>
#include <string>
#include <vector>


namespace sf
{
class String;
class TcpSocket;
class UdpSocket;

namespace
{
////////////////////////////////////////////////////////////
/// \brief Endian test
///
////////////////////////////////////////////////////////////
inline bool isBigEndian()
{
int one = 1;
return (*reinterpret_cast<char*>(&one)) != 1;
};


////////////////////////////////////////////////////////////
/// \brief Generic endianness conversion; if host is big-endian,
/// incoming network byte order can be handled without swap, and
/// host byte order is already network byte order
///
////////////////////////////////////////////////////////////
template <typename T>
T swapEndian(T value)
{
if (isBigEndian())
{
return value;
}

std::array<std::uint8_t, sizeof(T)> rawBytes;

auto* valueBytes = reinterpret_cast<std::uint8_t*>(&value);
std::memcpy(rawBytes.data(), valueBytes, sizeof(T));

std::array<std::uint8_t, sizeof(T)> swapped;
std::reverse_copy(rawBytes.begin(), rawBytes.end(), swapped.begin());
std::memcpy(valueBytes, swapped.data(), sizeof(T));

return *reinterpret_cast<T*>(valueBytes);
}
} // namespace

////////////////////////////////////////////////////////////
/// \brief Utility class to build blocks of data to transfer
/// over the network
Expand Down Expand Up @@ -211,52 +253,21 @@ class SFML_NETWORK_API Packet
////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::int8_t& data);
template <typename T>
Packet& operator>>(T& data)
{
if (checkSize(sizeof(data)))
{
std::memcpy(&data, &m_data[m_readPos], sizeof(data));
if constexpr (sizeof(T) > 1)
{
data = swapEndian(data);
}
m_readPos += sizeof(data);
}

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::uint8_t& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::int16_t& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::uint16_t& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::int32_t& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::uint32_t& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::int64_t& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(std::uint64_t& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(float& data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(double& data);
return *this;
}

////////////////////////////////////////////////////////////
/// \overload
Expand Down Expand Up @@ -292,52 +303,17 @@ class SFML_NETWORK_API Packet
////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::int8_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::uint8_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::int16_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::uint16_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::int32_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::uint32_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::int64_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(std::uint64_t data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(float data);

////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(double data);
template <typename T>
Packet& operator<<(T& data)
{
auto toWrite = data;
if constexpr (sizeof(T) > 1)
{
toWrite = swapEndian(data);
}
append(&toWrite, sizeof(toWrite));
return *this;
}

////////////////////////////////////////////////////////////
/// \overload
Expand Down