minetest
/
minetest
mirror of https://github.com/minetest/minetest.git
1
0
Fork 0
Code Issues Releases Wiki Activity

(se)SerializeString: Include max length in the name 

This commit clarifies the maximal length of the serialized strings.
It will avoid accidental use of serializeString() when a larger string can be expected.

Removes unused Wide String serialization functions
This commit is contained in:
SmallJoker 2020-09-20 13:12:55 +02:00 committed by Loïc Blot
parent ca5c2dbefa
commit 947466ab28
23 changed files with 168 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/client/content_cao.cpp
View File

@ -371,7 +371,7 @@ void GenericCAO::processInitData(const std::string &data)
} }
// PROTOCOL_VERSION >= 37 // PROTOCOL_VERSION >= 37
m_name = deSerializeString(is); m_name = deSerializeString16(is);
m_is_player = readU8(is); m_is_player = readU8(is);
m_id = readU16(is); m_id = readU16(is);
m_position = readV3F32(is); m_position = readV3F32(is);
@ -381,7 +381,7 @@ void GenericCAO::processInitData(const std::string &data)
const u8 num_messages = readU8(is); const u8 num_messages = readU8(is);
for (int i = 0; i < num_messages; i++) { for (int i = 0; i < num_messages; i++) {
std::string message = deSerializeLongString(is); std::string message = deSerializeString32(is);
processMessage(message); processMessage(message);
} }
@ -1657,7 +1657,7 @@ void GenericCAO::processMessage(const std::string &data)
rot_translator.update(m_rotation, false, update_interval); rot_translator.update(m_rotation, false, update_interval);
updateNodePos(); updateNodePos();
} else if (cmd == AO_CMD_SET_TEXTURE_MOD) { } else if (cmd == AO_CMD_SET_TEXTURE_MOD) {
std::string mod = deSerializeString(is); std::string mod = deSerializeString16(is);
// immediately reset a engine issued texture modifier if a mod sends a different one // immediately reset a engine issued texture modifier if a mod sends a different one
if (m_reset_textures_timer > 0) { if (m_reset_textures_timer > 0) {
@ -1735,7 +1735,7 @@ void GenericCAO::processMessage(const std::string &data)
m_animation_speed = readF32(is); m_animation_speed = readF32(is);
updateAnimationSpeed(); updateAnimationSpeed();
} else if (cmd == AO_CMD_SET_BONE_POSITION) { } else if (cmd == AO_CMD_SET_BONE_POSITION) {
std::string bone = deSerializeString(is); std::string bone = deSerializeString16(is);
v3f position = readV3F32(is); v3f position = readV3F32(is);
v3f rotation = readV3F32(is); v3f rotation = readV3F32(is);
m_bone_position[bone] = core::vector2d<v3f>(position, rotation); m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
@ -1743,7 +1743,7 @@ void GenericCAO::processMessage(const std::string &data)
// updateBonePosition(); now called every step // updateBonePosition(); now called every step
} else if (cmd == AO_CMD_ATTACH_TO) { } else if (cmd == AO_CMD_ATTACH_TO) {
u16 parent_id = readS16(is); u16 parent_id = readS16(is);
std::string bone = deSerializeString(is); std::string bone = deSerializeString16(is);
v3f position = readV3F32(is); v3f position = readV3F32(is);
v3f rotation = readV3F32(is); v3f rotation = readV3F32(is);
@ -1793,7 +1793,7 @@ void GenericCAO::processMessage(const std::string &data)
int armor_groups_size = readU16(is); int armor_groups_size = readU16(is);
for(int i=0; i<armor_groups_size; i++) for(int i=0; i<armor_groups_size; i++)
{ {
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
int rating = readS16(is); int rating = readS16(is);
m_armor_groups[name] = rating; m_armor_groups[name] = rating;
} }

18
src/content_nodemeta.cpp
View File

@ -43,26 +43,26 @@ static bool content_nodemeta_deserialize_legacy_body(
if(id == NODEMETA_GENERIC) // GenericNodeMetadata (0.4-dev) if(id == NODEMETA_GENERIC) // GenericNodeMetadata (0.4-dev)
{ {
meta->getInventory()->deSerialize(is); meta->getInventory()->deSerialize(is);
deSerializeLongString(is); // m_text deSerializeString32(is); // m_text
deSerializeString(is); // m_owner deSerializeString16(is); // m_owner
meta->setString("infotext",deSerializeString(is)); meta->setString("infotext",deSerializeString16(is));
meta->setString("formspec",deSerializeString(is)); meta->setString("formspec",deSerializeString16(is));
readU8(is); // m_allow_text_input readU8(is); // m_allow_text_input
readU8(is); // m_allow_removal readU8(is); // m_allow_removal
readU8(is); // m_enforce_owner readU8(is); // m_enforce_owner
int num_vars = readU32(is); int num_vars = readU32(is);
for(int i=0; i<num_vars; i++){ for(int i=0; i<num_vars; i++){
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
std::string var = deSerializeLongString(is); std::string var = deSerializeString32(is);
meta->setString(name, var); meta->setString(name, var);
} }
return false; return false;
} }
else if(id == NODEMETA_SIGN) // SignNodeMetadata else if(id == NODEMETA_SIGN) // SignNodeMetadata
{ {
meta->setString("text", deSerializeString(is)); meta->setString("text", deSerializeString16(is));
//meta->setString("infotext","\"${text}\""); //meta->setString("infotext","\"${text}\"");
meta->setString("infotext", meta->setString("infotext",
std::string("\"") + meta->getString("text") + "\""); std::string("\"") + meta->getString("text") + "\"");
@ -87,7 +87,7 @@ static bool content_nodemeta_deserialize_legacy_body(
} }
else if(id == NODEMETA_LOCKABLE_CHEST) // LockingChestNodeMetadata else if(id == NODEMETA_LOCKABLE_CHEST) // LockingChestNodeMetadata
{ {
meta->setString("owner", deSerializeString(is)); meta->setString("owner", deSerializeString16(is));
meta->getInventory()->deSerialize(is); meta->getInventory()->deSerialize(is);
// Rename inventory list "0" to "main" // Rename inventory list "0" to "main"
@ -138,7 +138,7 @@ static bool content_nodemeta_deserialize_legacy_meta(
s16 id = readS16(is); s16 id = readS16(is);
// Read data // Read data
std::string data = deSerializeString(is); std::string data = deSerializeString16(is);
std::istringstream tmp_is(data, std::ios::binary); std::istringstream tmp_is(data, std::ios::binary);
return content_nodemeta_deserialize_legacy_body(tmp_is, id, meta); return content_nodemeta_deserialize_legacy_body(tmp_is, id, meta);
} }

16
src/database/database-leveldb.cpp
View File

@ -145,8 +145,8 @@ void PlayerDatabaseLevelDB::savePlayer(RemotePlayer *player)
StringMap stringvars = sao->getMeta().getStrings(); StringMap stringvars = sao->getMeta().getStrings();
writeU32(os, stringvars.size()); writeU32(os, stringvars.size());
for (const auto &it : stringvars) { for (const auto &it : stringvars) {
os << serializeString(it.first); os << serializeString16(it.first);
os << serializeLongString(it.second); os << serializeString32(it.second);
} }
player->inventory.serialize(os); player->inventory.serialize(os);
@ -183,8 +183,8 @@ bool PlayerDatabaseLevelDB::loadPlayer(RemotePlayer *player, PlayerSAO *sao)
u32 attribute_count = readU32(is); u32 attribute_count = readU32(is);
for (u32 i = 0; i < attribute_count; i++) { for (u32 i = 0; i < attribute_count; i++) {
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
std::string value = deSerializeLongString(is); std::string value = deSerializeString32(is);
sao->getMeta().setString(name, value); sao->getMeta().setString(name, value);
} }
sao->getMeta().setModified(false); sao->getMeta().setModified(false);
@ -247,13 +247,13 @@ bool AuthDatabaseLevelDB::getAuth(const std::string &name, AuthEntry &res)
res.id = 1; res.id = 1;
res.name = name; res.name = name;
res.password = deSerializeString(is); res.password = deSerializeString16(is);
u16 privilege_count = readU16(is); u16 privilege_count = readU16(is);
res.privileges.clear(); res.privileges.clear();
res.privileges.reserve(privilege_count); res.privileges.reserve(privilege_count);
for (u16 i = 0; i < privilege_count; i++) { for (u16 i = 0; i < privilege_count; i++) {
res.privileges.push_back(deSerializeString(is)); res.privileges.push_back(deSerializeString16(is));
} }
res.last_login = readS64(is); res.last_login = readS64(is);
@ -264,14 +264,14 @@ bool AuthDatabaseLevelDB::saveAuth(const AuthEntry &authEntry)
{ {
std::ostringstream os; std::ostringstream os;
writeU8(os, 1); writeU8(os, 1);
os << serializeString(authEntry.password); os << serializeString16(authEntry.password);
size_t privilege_count = authEntry.privileges.size(); size_t privilege_count = authEntry.privileges.size();
FATAL_ERROR_IF(privilege_count > U16_MAX, FATAL_ERROR_IF(privilege_count > U16_MAX,
"Unsupported number of privileges"); "Unsupported number of privileges");
writeU16(os, privilege_count); writeU16(os, privilege_count);
for (const std::string &privilege : authEntry.privileges) { for (const std::string &privilege : authEntry.privileges) {
os << serializeString(privilege); os << serializeString16(privilege);
} }
writeS64(os, authEntry.last_login); writeS64(os, authEntry.last_login);

52
src/itemdef.cpp
View File

@ -128,10 +128,10 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
u8 version = 6; u8 version = 6;
writeU8(os, version); writeU8(os, version);
writeU8(os, type); writeU8(os, type);
os << serializeString(name); os << serializeString16(name);
os << serializeString(description); os << serializeString16(description);
os << serializeString(inventory_image); os << serializeString16(inventory_image);
os << serializeString(wield_image); os << serializeString16(wield_image);
writeV3F32(os, wield_scale); writeV3F32(os, wield_scale);
writeS16(os, stack_max); writeS16(os, stack_max);
writeU8(os, usable); writeU8(os, usable);
@ -143,25 +143,25 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
tool_capabilities->serialize(tmp_os, protocol_version); tool_capabilities->serialize(tmp_os, protocol_version);
tool_capabilities_s = tmp_os.str(); tool_capabilities_s = tmp_os.str();
} }
os << serializeString(tool_capabilities_s); os << serializeString16(tool_capabilities_s);
writeU16(os, groups.size()); writeU16(os, groups.size());
for (const auto &group : groups) { for (const auto &group : groups) {
os << serializeString(group.first); os << serializeString16(group.first);
writeS16(os, group.second); writeS16(os, group.second);
} }
os << serializeString(node_placement_prediction); os << serializeString16(node_placement_prediction);
// Version from ContentFeatures::serialize to keep in sync // Version from ContentFeatures::serialize to keep in sync
sound_place.serialize(os, CONTENTFEATURES_VERSION); sound_place.serialize(os, CONTENTFEATURES_VERSION);
sound_place_failed.serialize(os, CONTENTFEATURES_VERSION); sound_place_failed.serialize(os, CONTENTFEATURES_VERSION);
writeF32(os, range); writeF32(os, range);
os << serializeString(palette_image); os << serializeString16(palette_image);
writeARGB8(os, color); writeARGB8(os, color);
os << serializeString(inventory_overlay); os << serializeString16(inventory_overlay);
os << serializeString(wield_overlay); os << serializeString16(wield_overlay);
} }
void ItemDefinition::deSerialize(std::istream &is) void ItemDefinition::deSerialize(std::istream &is)
@ -175,16 +175,16 @@ void ItemDefinition::deSerialize(std::istream &is)
throw SerializationError("unsupported ItemDefinition version"); throw SerializationError("unsupported ItemDefinition version");
type = (enum ItemType)readU8(is); type = (enum ItemType)readU8(is);
name = deSerializeString(is); name = deSerializeString16(is);
description = deSerializeString(is); description = deSerializeString16(is);
inventory_image = deSerializeString(is); inventory_image = deSerializeString16(is);
wield_image = deSerializeString(is); wield_image = deSerializeString16(is);
wield_scale = readV3F32(is); wield_scale = readV3F32(is);
stack_max = readS16(is); stack_max = readS16(is);
usable = readU8(is); usable = readU8(is);
liquids_pointable = readU8(is); liquids_pointable = readU8(is);
std::string tool_capabilities_s = deSerializeString(is); std::string tool_capabilities_s = deSerializeString16(is);
if (!tool_capabilities_s.empty()) { if (!tool_capabilities_s.empty()) {
std::istringstream tmp_is(tool_capabilities_s, std::ios::binary); std::istringstream tmp_is(tool_capabilities_s, std::ios::binary);
tool_capabilities = new ToolCapabilities; tool_capabilities = new ToolCapabilities;
@ -194,22 +194,22 @@ void ItemDefinition::deSerialize(std::istream &is)
groups.clear(); groups.clear();
u32 groups_size = readU16(is); u32 groups_size = readU16(is);
for(u32 i=0; i<groups_size; i++){ for(u32 i=0; i<groups_size; i++){
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
int value = readS16(is); int value = readS16(is);
groups[name] = value; groups[name] = value;
} }
node_placement_prediction = deSerializeString(is); node_placement_prediction = deSerializeString16(is);
// Version from ContentFeatures::serialize to keep in sync // Version from ContentFeatures::serialize to keep in sync
sound_place.deSerialize(is, CONTENTFEATURES_VERSION); sound_place.deSerialize(is, CONTENTFEATURES_VERSION);
sound_place_failed.deSerialize(is, CONTENTFEATURES_VERSION); sound_place_failed.deSerialize(is, CONTENTFEATURES_VERSION);
range = readF32(is); range = readF32(is);
palette_image = deSerializeString(is); palette_image = deSerializeString16(is);
color = readARGB8(is); color = readARGB8(is);
inventory_overlay = deSerializeString(is); inventory_overlay = deSerializeString16(is);
wield_overlay = deSerializeString(is); wield_overlay = deSerializeString16(is);
// If you add anything here, insert it primarily inside the try-catch // If you add anything here, insert it primarily inside the try-catch
// block to not need to increase the version. // block to not need to increase the version.
@ -521,14 +521,14 @@ public:
// Serialize ItemDefinition and write wrapped in a string // Serialize ItemDefinition and write wrapped in a string
std::ostringstream tmp_os(std::ios::binary); std::ostringstream tmp_os(std::ios::binary);
def->serialize(tmp_os, protocol_version); def->serialize(tmp_os, protocol_version);
os << serializeString(tmp_os.str()); os << serializeString16(tmp_os.str());
} }
writeU16(os, m_aliases.size()); writeU16(os, m_aliases.size());
for (const auto &it : m_aliases) { for (const auto &it : m_aliases) {
os << serializeString(it.first); os << serializeString16(it.first);
os << serializeString(it.second); os << serializeString16(it.second);
} }
} }
void deSerialize(std::istream &is) void deSerialize(std::istream &is)
@ -543,7 +543,7 @@ public:
for(u16 i=0; i<count; i++) for(u16 i=0; i<count; i++)
{ {
// Deserialize a string and grab an ItemDefinition from it // Deserialize a string and grab an ItemDefinition from it
std::istringstream tmp_is(deSerializeString(is), std::ios::binary); std::istringstream tmp_is(deSerializeString16(is), std::ios::binary);
ItemDefinition def; ItemDefinition def;
def.deSerialize(tmp_is); def.deSerialize(tmp_is);
// Register // Register
@ -552,8 +552,8 @@ public:
u16 num_aliases = readU16(is); u16 num_aliases = readU16(is);
for(u16 i=0; i<num_aliases; i++) for(u16 i=0; i<num_aliases; i++)
{ {
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
std::string convert_to = deSerializeString(is); std::string convert_to = deSerializeString16(is);
registerAlias(name, convert_to); registerAlias(name, convert_to);
} }
} }

4
src/mapblock.cpp
View File

@ -668,13 +668,13 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
// Ignore errors // Ignore errors
try { try {
if (version <= 15) { if (version <= 15) {
std::string data = deSerializeString(is); std::string data = deSerializeString16(is);
std::istringstream iss(data, std::ios_base::binary); std::istringstream iss(data, std::ios_base::binary);
content_nodemeta_deserialize_legacy(iss, content_nodemeta_deserialize_legacy(iss,
&m_node_metadata, &m_node_timers, &m_node_metadata, &m_node_timers,
m_gamedef->idef()); m_gamedef->idef());
} else { } else {
//std::string data = deSerializeLongString(is); //std::string data = deSerializeString32(is);
std::ostringstream oss(std::ios_base::binary); std::ostringstream oss(std::ios_base::binary);
decompressZlib(is, oss); decompressZlib(is, oss);
std::istringstream iss(oss.str(), std::ios_base::binary); std::istringstream iss(oss.str(), std::ios_base::binary);

4
src/mapgen/mg_schematic.cpp
View File

@ -314,7 +314,7 @@ bool Schematic::deserializeFromMts(std::istream *is,
//// Read node names //// Read node names
u16 nidmapcount = readU16(ss); u16 nidmapcount = readU16(ss);
for (int i = 0; i != nidmapcount; i++) { for (int i = 0; i != nidmapcount; i++) {
std::string name = deSerializeString(ss); std::string name = deSerializeString16(ss);
// Instances of "ignore" from v1 are converted to air (and instances // Instances of "ignore" from v1 are converted to air (and instances
// are fixed to have MTSCHEM_PROB_NEVER later on). // are fixed to have MTSCHEM_PROB_NEVER later on).
@ -372,7 +372,7 @@ bool Schematic::serializeToMts(std::ostream *os,
writeU16(ss, names.size()); // name count writeU16(ss, names.size()); // name count
for (size_t i = 0; i != names.size(); i++) for (size_t i = 0; i != names.size(); i++)
ss << serializeString(names[i]); // node names ss << serializeString16(names[i]); // node names
// compressed bulk node data // compressed bulk node data
MapNode::serializeBulk(ss, SER_FMT_VER_HIGHEST_WRITE, MapNode::serializeBulk(ss, SER_FMT_VER_HIGHEST_WRITE,

4
src/nameidmapping.cpp
View File

@ -27,7 +27,7 @@ void NameIdMapping::serialize(std::ostream &os) const
writeU16(os, m_id_to_name.size()); writeU16(os, m_id_to_name.size());
for (const auto &i : m_id_to_name) { for (const auto &i : m_id_to_name) {
writeU16(os, i.first); writeU16(os, i.first);
os << serializeString(i.second); os << serializeString16(i.second);
} }
} }
@ -41,7 +41,7 @@ void NameIdMapping::deSerialize(std::istream &is)
m_name_to_id.clear(); m_name_to_id.clear();
for (u32 i = 0; i < count; i++) { for (u32 i = 0; i < count; i++) {
u16 id = readU16(is); u16 id = readU16(is);
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
m_id_to_name[id] = name; m_id_to_name[id] = name;
m_name_to_id[name] = id; m_name_to_id[name] = id;
} }

8
src/network/clientpackethandler.cpp
View File

@ -497,7 +497,7 @@ void Client::handleCommand_ActiveObjectMessages(NetworkPacket* pkt)
if (!is.good()) if (!is.good())
break; break;
std::string message = deSerializeString(is); std::string message = deSerializeString16(is);
// Pass on to the environment // Pass on to the environment
m_env.processActiveObjectMessage(id, message); m_env.processActiveObjectMessage(id, message);
@ -994,7 +994,7 @@ void Client::handleCommand_AddParticleSpawner(NetworkPacket* pkt)
p.minsize = readF32(is); p.minsize = readF32(is);
p.maxsize = readF32(is); p.maxsize = readF32(is);
p.collisiondetection = readU8(is); p.collisiondetection = readU8(is);
p.texture = deSerializeLongString(is); p.texture = deSerializeString32(is);
server_id = readU32(is); server_id = readU32(is);
@ -1207,11 +1207,11 @@ void Client::handleCommand_HudSetSky(NetworkPacket* pkt)
SkyboxParams skybox; SkyboxParams skybox;
skybox.bgcolor = video::SColor(readARGB8(is)); skybox.bgcolor = video::SColor(readARGB8(is));
skybox.type = std::string(deSerializeString(is)); skybox.type = std::string(deSerializeString16(is));
u16 count = readU16(is); u16 count = readU16(is);
for (size_t i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
skybox.textures.emplace_back(deSerializeString(is)); skybox.textures.emplace_back(deSerializeString16(is));
skybox.clouds = true; skybox.clouds = true;
try { try {

40
src/nodedef.cpp
View File

@ -207,7 +207,7 @@ void TileDef::serialize(std::ostream &os, u16 protocol_version) const
u8 version = 6; u8 version = 6;
writeU8(os, version); writeU8(os, version);
os << serializeString(name); os << serializeString16(name);
animation.serialize(os, version); animation.serialize(os, version);
bool has_scale = scale > 0; bool has_scale = scale > 0;
u16 flags = 0; u16 flags = 0;
@ -241,7 +241,7 @@ void TileDef::deSerialize(std::istream &is, u8 contentfeatures_version,
int version = readU8(is); int version = readU8(is);
if (version < 6) if (version < 6)
throw SerializationError("unsupported TileDef version"); throw SerializationError("unsupported TileDef version");
name = deSerializeString(is); name = deSerializeString16(is);
animation.deSerialize(is, version); animation.deSerialize(is, version);
u16 flags = readU16(is); u16 flags = readU16(is);
backface_culling = flags & TILE_FLAG_BACKFACE_CULLING; backface_culling = flags & TILE_FLAG_BACKFACE_CULLING;
@ -416,10 +416,10 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
writeU8(os, version); writeU8(os, version);
// general // general
os << serializeString(name); os << serializeString16(name);
writeU16(os, groups.size()); writeU16(os, groups.size());
for (const auto &group : groups) { for (const auto &group : groups) {
os << serializeString(group.first); os << serializeString16(group.first);
writeS16(os, group.second); writeS16(os, group.second);
} }
writeU8(os, param_type); writeU8(os, param_type);
@ -427,7 +427,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
// visual // visual
writeU8(os, drawtype); writeU8(os, drawtype);
os << serializeString(mesh); os << serializeString16(mesh);
writeF32(os, visual_scale); writeF32(os, visual_scale);
writeU8(os, 6); writeU8(os, 6);
for (const TileDef &td : tiledef) for (const TileDef &td : tiledef)
@ -442,7 +442,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
writeU8(os, color.getRed()); writeU8(os, color.getRed());
writeU8(os, color.getGreen()); writeU8(os, color.getGreen());
writeU8(os, color.getBlue()); writeU8(os, color.getBlue());
os << serializeString(palette_name); os << serializeString16(palette_name);
writeU8(os, waving); writeU8(os, waving);
writeU8(os, connect_sides); writeU8(os, connect_sides);
writeU16(os, connects_to_ids.size()); writeU16(os, connects_to_ids.size());
@ -470,8 +470,8 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
// liquid // liquid
writeU8(os, liquid_type); writeU8(os, liquid_type);
os << serializeString(liquid_alternative_flowing); os << serializeString16(liquid_alternative_flowing);
os << serializeString(liquid_alternative_source); os << serializeString16(liquid_alternative_source);
writeU8(os, liquid_viscosity); writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable); writeU8(os, liquid_renewable);
writeU8(os, liquid_range); writeU8(os, liquid_range);
@ -492,7 +492,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
writeU8(os, legacy_facedir_simple); writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted); writeU8(os, legacy_wallmounted);
os << serializeString(node_dig_prediction); os << serializeString16(node_dig_prediction);
writeU8(os, leveled_max); writeU8(os, leveled_max);
} }
@ -519,11 +519,11 @@ void ContentFeatures::deSerialize(std::istream &is)
throw SerializationError("unsupported ContentFeatures version"); throw SerializationError("unsupported ContentFeatures version");
// general // general
name = deSerializeString(is); name = deSerializeString16(is);
groups.clear(); groups.clear();
u32 groups_size = readU16(is); u32 groups_size = readU16(is);
for (u32 i = 0; i < groups_size; i++) { for (u32 i = 0; i < groups_size; i++) {
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
int value = readS16(is); int value = readS16(is);
groups[name] = value; groups[name] = value;
} }
@ -532,7 +532,7 @@ void ContentFeatures::deSerialize(std::istream &is)
// visual // visual
drawtype = (enum NodeDrawType) readU8(is); drawtype = (enum NodeDrawType) readU8(is);
mesh = deSerializeString(is); mesh = deSerializeString16(is);
visual_scale = readF32(is); visual_scale = readF32(is);
if (readU8(is) != 6) if (readU8(is) != 6)
throw SerializationError("unsupported tile count"); throw SerializationError("unsupported tile count");
@ -548,7 +548,7 @@ void ContentFeatures::deSerialize(std::istream &is)
color.setRed(readU8(is)); color.setRed(readU8(is));
color.setGreen(readU8(is)); color.setGreen(readU8(is));
color.setBlue(readU8(is)); color.setBlue(readU8(is));
palette_name = deSerializeString(is); palette_name = deSerializeString16(is);
waving = readU8(is); waving = readU8(is);
connect_sides = readU8(is); connect_sides = readU8(is);
u16 connects_to_size = readU16(is); u16 connects_to_size = readU16(is);
@ -578,8 +578,8 @@ void ContentFeatures::deSerialize(std::istream &is)
// liquid // liquid
liquid_type = (enum LiquidType) readU8(is); liquid_type = (enum LiquidType) readU8(is);
liquid_alternative_flowing = deSerializeString(is); liquid_alternative_flowing = deSerializeString16(is);
liquid_alternative_source = deSerializeString(is); liquid_alternative_source = deSerializeString16(is);
liquid_viscosity = readU8(is); liquid_viscosity = readU8(is);
liquid_renewable = readU8(is); liquid_renewable = readU8(is);
liquid_range = readU8(is); liquid_range = readU8(is);
@ -601,7 +601,7 @@ void ContentFeatures::deSerialize(std::istream &is)
legacy_wallmounted = readU8(is); legacy_wallmounted = readU8(is);
try { try {
node_dig_prediction = deSerializeString(is); node_dig_prediction = deSerializeString16(is);
u8 tmp_leveled_max = readU8(is); u8 tmp_leveled_max = readU8(is);
if (is.eof()) /* readU8 doesn't throw exceptions so we have to do this */ if (is.eof()) /* readU8 doesn't throw exceptions so we have to do this */
throw SerializationError(""); throw SerializationError("");
@ -1472,7 +1472,7 @@ void NodeDefManager::serialize(std::ostream &os, u16 protocol_version) const
// strict version incompatibilities // strict version incompatibilities
std::ostringstream wrapper_os(std::ios::binary); std::ostringstream wrapper_os(std::ios::binary);
f->serialize(wrapper_os, protocol_version); f->serialize(wrapper_os, protocol_version);
os2<<serializeString(wrapper_os.str()); os2<<serializeString16(wrapper_os.str());
// must not overflow // must not overflow
u16 next = count + 1; u16 next = count + 1;
@ -1480,7 +1480,7 @@ void NodeDefManager::serialize(std::ostream &os, u16 protocol_version) const
count++; count++;
} }
writeU16(os, count); writeU16(os, count);
os << serializeLongString(os2.str()); os << serializeString32(os2.str());
} }
@ -1491,13 +1491,13 @@ void NodeDefManager::deSerialize(std::istream &is)
if (version != 1) if (version != 1)
throw SerializationError("unsupported NodeDefinitionManager version"); throw SerializationError("unsupported NodeDefinitionManager version");
u16 count = readU16(is); u16 count = readU16(is);
std::istringstream is2(deSerializeLongString(is), std::ios::binary); std::istringstream is2(deSerializeString32(is), std::ios::binary);
ContentFeatures f; ContentFeatures f;
for (u16 n = 0; n < count; n++) { for (u16 n = 0; n < count; n++) {
u16 i = readU16(is2); u16 i = readU16(is2);
// Read it from the string wrapper // Read it from the string wrapper
std::string wrapper = deSerializeString(is2); std::string wrapper = deSerializeString16(is2);
std::istringstream wrapper_is(wrapper, std::ios::binary); std::istringstream wrapper_is(wrapper, std::ios::binary);
f.deSerialize(wrapper_is); f.deSerialize(wrapper_is);

8
src/nodemetadata.cpp
View File

@ -49,8 +49,8 @@ void NodeMetadata::serialize(std::ostream &os, u8 version, bool disk) const
if (!disk && priv) if (!disk && priv)
continue; continue;
os << serializeString(sv.first); os << serializeString16(sv.first);
os << serializeLongString(sv.second); os << serializeString32(sv.second);
if (version >= 2) if (version >= 2)
writeU8(os, (priv) ? 1 : 0); writeU8(os, (priv) ? 1 : 0);
} }
@ -63,8 +63,8 @@ void NodeMetadata::deSerialize(std::istream &is, u8 version)
clear(); clear();
int num_vars = readU32(is); int num_vars = readU32(is);
for(int i=0; i<num_vars; i++){ for(int i=0; i<num_vars; i++){
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
std::string var = deSerializeLongString(is); std::string var = deSerializeString32(is);
m_stringvars[name] = var; m_stringvars[name] = var;
if (version >= 2) { if (version >= 2) {
if (readU8(is) == 1) if (readU8(is) == 1)

28
src/object_properties.cpp
View File

@ -84,11 +84,11 @@ void ObjectProperties::serialize(std::ostream &os) const
writeV3F32(os, selectionbox.MinEdge); writeV3F32(os, selectionbox.MinEdge);
writeV3F32(os, selectionbox.MaxEdge); writeV3F32(os, selectionbox.MaxEdge);
writeU8(os, pointable); writeU8(os, pointable);
os << serializeString(visual); os << serializeString16(visual);
writeV3F32(os, visual_size); writeV3F32(os, visual_size);
writeU16(os, textures.size()); writeU16(os, textures.size());
for (const std::string &texture : textures) { for (const std::string &texture : textures) {
os << serializeString(texture); os << serializeString16(texture);
} }
writeV2S16(os, spritediv); writeV2S16(os, spritediv);
writeV2S16(os, initial_sprite_basepos); writeV2S16(os, initial_sprite_basepos);
@ -96,7 +96,7 @@ void ObjectProperties::serialize(std::ostream &os) const
writeU8(os, makes_footstep_sound); writeU8(os, makes_footstep_sound);
writeF32(os, automatic_rotate); writeF32(os, automatic_rotate);
// Added in protocol version 14 // Added in protocol version 14
os << serializeString(mesh); os << serializeString16(mesh);
writeU16(os, colors.size()); writeU16(os, colors.size());
for (video::SColor color : colors) { for (video::SColor color : colors) {
writeARGB8(os, color); writeARGB8(os, color);
@ -106,17 +106,17 @@ void ObjectProperties::serialize(std::ostream &os) const
writeU8(os, automatic_face_movement_dir); writeU8(os, automatic_face_movement_dir);
writeF32(os, automatic_face_movement_dir_offset); writeF32(os, automatic_face_movement_dir_offset);
writeU8(os, backface_culling); writeU8(os, backface_culling);
os << serializeString(nametag); os << serializeString16(nametag);
writeARGB8(os, nametag_color); writeARGB8(os, nametag_color);
writeF32(os, automatic_face_movement_max_rotation_per_sec); writeF32(os, automatic_face_movement_max_rotation_per_sec);
os << serializeString(infotext); os << serializeString16(infotext);
os << serializeString(wield_item); os << serializeString16(wield_item);
writeS8(os, glow); writeS8(os, glow);
writeU16(os, breath_max); writeU16(os, breath_max);
writeF32(os, eye_height); writeF32(os, eye_height);
writeF32(os, zoom_fov); writeF32(os, zoom_fov);
writeU8(os, use_texture_alpha); writeU8(os, use_texture_alpha);
os << serializeString(damage_texture_modifier); os << serializeString16(damage_texture_modifier);
writeU8(os, shaded); writeU8(os, shaded);
// Add stuff only at the bottom. // Add stuff only at the bottom.
@ -137,19 +137,19 @@ void ObjectProperties::deSerialize(std::istream &is)
selectionbox.MinEdge = readV3F32(is); selectionbox.MinEdge = readV3F32(is);
selectionbox.MaxEdge = readV3F32(is); selectionbox.MaxEdge = readV3F32(is);
pointable = readU8(is); pointable = readU8(is);
visual = deSerializeString(is); visual = deSerializeString16(is);
visual_size = readV3F32(is); visual_size = readV3F32(is);
textures.clear(); textures.clear();
u32 texture_count = readU16(is); u32 texture_count = readU16(is);
for (u32 i = 0; i < texture_count; i++){ for (u32 i = 0; i < texture_count; i++){
textures.push_back(deSerializeString(is)); textures.push_back(deSerializeString16(is));
} }
spritediv = readV2S16(is); spritediv = readV2S16(is);
initial_sprite_basepos = readV2S16(is); initial_sprite_basepos = readV2S16(is);
is_visible = readU8(is); is_visible = readU8(is);
makes_footstep_sound = readU8(is); makes_footstep_sound = readU8(is);
automatic_rotate = readF32(is); automatic_rotate = readF32(is);
mesh = deSerializeString(is); mesh = deSerializeString16(is);
colors.clear(); colors.clear();
u32 color_count = readU16(is); u32 color_count = readU16(is);
for (u32 i = 0; i < color_count; i++){ for (u32 i = 0; i < color_count; i++){
@ -160,18 +160,18 @@ void ObjectProperties::deSerialize(std::istream &is)
automatic_face_movement_dir = readU8(is); automatic_face_movement_dir = readU8(is);
automatic_face_movement_dir_offset = readF32(is); automatic_face_movement_dir_offset = readF32(is);
backface_culling = readU8(is); backface_culling = readU8(is);
nametag = deSerializeString(is); nametag = deSerializeString16(is);
nametag_color = readARGB8(is); nametag_color = readARGB8(is);
automatic_face_movement_max_rotation_per_sec = readF32(is); automatic_face_movement_max_rotation_per_sec = readF32(is);
infotext = deSerializeString(is); infotext = deSerializeString16(is);
wield_item = deSerializeString(is); wield_item = deSerializeString16(is);
glow = readS8(is); glow = readS8(is);
breath_max = readU16(is); breath_max = readU16(is);
eye_height = readF32(is); eye_height = readF32(is);
zoom_fov = readF32(is); zoom_fov = readF32(is);
use_texture_alpha = readU8(is); use_texture_alpha = readU8(is);
try { try {
damage_texture_modifier = deSerializeString(is); damage_texture_modifier = deSerializeString16(is);
u8 tmp = readU8(is); u8 tmp = readU8(is);
if (is.eof()) if (is.eof())
throw SerializationError(""); throw SerializationError("");

4
src/particles.cpp
View File

@ -28,7 +28,7 @@ void ParticleParameters::serialize(std::ostream &os, u16 protocol_ver) const
writeF32(os, expirationtime); writeF32(os, expirationtime);
writeF32(os, size); writeF32(os, size);
writeU8(os, collisiondetection); writeU8(os, collisiondetection);
os << serializeLongString(texture); os << serializeString32(texture);
writeU8(os, vertical); writeU8(os, vertical);
writeU8(os, collision_removal); writeU8(os, collision_removal);
animation.serialize(os, 6); /* NOT the protocol ver */ animation.serialize(os, 6); /* NOT the protocol ver */
@ -47,7 +47,7 @@ void ParticleParameters::deSerialize(std::istream &is, u16 protocol_ver)
expirationtime = readF32(is); expirationtime = readF32(is);
size = readF32(is); size = readF32(is);
collisiondetection = readU8(is); collisiondetection = readU8(is);
texture = deSerializeLongString(is); texture = deSerializeString32(is);
vertical = readU8(is); vertical = readU8(is);
collision_removal = readU8(is); collision_removal = readU8(is);
animation.deSerialize(is, 6); /* NOT the protocol ver */ animation.deSerialize(is, 6); /* NOT the protocol ver */

4
src/server.cpp
View File

@ -802,7 +802,7 @@ void Server::AsyncRunStep(bool initial_step)
// u16 id // u16 id
// std::string data // std::string data
buffer.append(idbuf, sizeof(idbuf)); buffer.append(idbuf, sizeof(idbuf));
buffer.append(serializeString(aom.datastring)); buffer.append(serializeString16(aom.datastring));
} }
} }
/* /*
@ -1993,7 +1993,7 @@ void Server::SendActiveObjectRemoveAdd(RemoteClient *client, PlayerSAO *playersa
writeU8((u8*)buf, type); writeU8((u8*)buf, type);
data.append(buf, 1); data.append(buf, 1);
data.append(serializeLongString( data.append(serializeString32(
obj->getClientInitializationData(client->net_proto_version))); obj->getClientInitializationData(client->net_proto_version)));
// Add to known objects // Add to known objects

28
src/server/luaentity_sao.cpp
View File

@ -42,8 +42,8 @@ LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos, const std::string &d
u8 version2 = 0; u8 version2 = 0;
u8 version = readU8(is); u8 version = readU8(is);
name = deSerializeString(is); name = deSerializeString16(is);
state = deSerializeLongString(is); state = deSerializeString32(is);
if (version < 1) if (version < 1)
break; break;
@ -225,7 +225,7 @@ std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
// PROTOCOL_VERSION >= 37 // PROTOCOL_VERSION >= 37
writeU8(os, 1); // version writeU8(os, 1); // version
os << serializeString(""); // name os << serializeString16(""); // name
writeU8(os, 0); // is_player writeU8(os, 0); // is_player
writeU16(os, getId()); //id writeU16(os, getId()); //id
writeV3F32(os, m_base_position); writeV3F32(os, m_base_position);
@ -233,26 +233,26 @@ std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
writeU16(os, m_hp); writeU16(os, m_hp);
std::ostringstream msg_os(std::ios::binary); std::ostringstream msg_os(std::ios::binary);
msg_os << serializeLongString(getPropertyPacket()); // message 1 msg_os << serializeString32(getPropertyPacket()); // message 1
msg_os << serializeLongString(generateUpdateArmorGroupsCommand()); // 2 msg_os << serializeString32(generateUpdateArmorGroupsCommand()); // 2
msg_os << serializeLongString(generateUpdateAnimationCommand()); // 3 msg_os << serializeString32(generateUpdateAnimationCommand()); // 3
for (const auto &bone_pos : m_bone_position) { for (const auto &bone_pos : m_bone_position) {
msg_os << serializeLongString(generateUpdateBonePositionCommand( msg_os << serializeString32(generateUpdateBonePositionCommand(
bone_pos.first, bone_pos.second.X, bone_pos.second.Y)); // m_bone_position.size bone_pos.first, bone_pos.second.X, bone_pos.second.Y)); // m_bone_position.size
} }
msg_os << serializeLongString(generateUpdateAttachmentCommand()); // 4 msg_os << serializeString32(generateUpdateAttachmentCommand()); // 4
int message_count = 4 + m_bone_position.size(); int message_count = 4 + m_bone_position.size();
for (const auto &id : getAttachmentChildIds()) { for (const auto &id : getAttachmentChildIds()) {
if (ServerActiveObject *obj = m_env->getActiveObject(id)) { if (ServerActiveObject *obj = m_env->getActiveObject(id)) {
message_count++; message_count++;
msg_os << serializeLongString(obj->generateUpdateInfantCommand( msg_os << serializeString32(obj->generateUpdateInfantCommand(
id, protocol_version)); id, protocol_version));
} }
} }
msg_os << serializeLongString(generateSetTextureModCommand()); msg_os << serializeString32(generateSetTextureModCommand());
message_count++; message_count++;
writeU8(os, message_count); writeU8(os, message_count);
@ -270,14 +270,14 @@ void LuaEntitySAO::getStaticData(std::string *result) const
// version must be 1 to keep backwards-compatibility. See version2 // version must be 1 to keep backwards-compatibility. See version2
writeU8(os, 1); writeU8(os, 1);
// name // name
os<<serializeString(m_init_name); os<<serializeString16(m_init_name);
// state // state
if(m_registered){ if(m_registered){
std::string state = m_env->getScriptIface()-> std::string state = m_env->getScriptIface()->
luaentity_GetStaticdata(m_id); luaentity_GetStaticdata(m_id);
os<<serializeLongString(state); os<<serializeString32(state);
} else { } else {
os<<serializeLongString(m_init_state); os<<serializeString32(m_init_state);
} }
writeU16(os, m_hp); writeU16(os, m_hp);
writeV3F1000(os, m_velocity); writeV3F1000(os, m_velocity);
@ -436,7 +436,7 @@ std::string LuaEntitySAO::generateSetTextureModCommand() const
// command // command
writeU8(os, AO_CMD_SET_TEXTURE_MOD); writeU8(os, AO_CMD_SET_TEXTURE_MOD);
// parameters // parameters
os << serializeString(m_current_texture_modifier); os << serializeString16(m_current_texture_modifier);
return os.str(); return os.str();
} }

16
src/server/player_sao.cpp
View File

@ -109,7 +109,7 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
// Protocol >= 15 // Protocol >= 15
writeU8(os, 1); // version writeU8(os, 1); // version
os << serializeString(m_player->getName()); // name os << serializeString16(m_player->getName()); // name
writeU8(os, 1); // is_player writeU8(os, 1); // is_player
writeS16(os, getId()); // id writeS16(os, getId()); // id
writeV3F32(os, m_base_position); writeV3F32(os, m_base_position);
@ -117,22 +117,22 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
writeU16(os, getHP()); writeU16(os, getHP());
std::ostringstream msg_os(std::ios::binary); std::ostringstream msg_os(std::ios::binary);
msg_os << serializeLongString(getPropertyPacket()); // message 1 msg_os << serializeString32(getPropertyPacket()); // message 1
msg_os << serializeLongString(generateUpdateArmorGroupsCommand()); // 2 msg_os << serializeString32(generateUpdateArmorGroupsCommand()); // 2
msg_os << serializeLongString(generateUpdateAnimationCommand()); // 3 msg_os << serializeString32(generateUpdateAnimationCommand()); // 3
for (const auto &bone_pos : m_bone_position) { for (const auto &bone_pos : m_bone_position) {
msg_os << serializeLongString(generateUpdateBonePositionCommand( msg_os << serializeString32(generateUpdateBonePositionCommand(
bone_pos.first, bone_pos.second.X, bone_pos.second.Y)); // m_bone_position.size bone_pos.first, bone_pos.second.X, bone_pos.second.Y)); // m_bone_position.size
} }
msg_os << serializeLongString(generateUpdateAttachmentCommand()); // 4 msg_os << serializeString32(generateUpdateAttachmentCommand()); // 4
msg_os << serializeLongString(generateUpdatePhysicsOverrideCommand()); // 5 msg_os << serializeString32(generateUpdatePhysicsOverrideCommand()); // 5
int message_count = 5 + m_bone_position.size(); int message_count = 5 + m_bone_position.size();
for (const auto &id : getAttachmentChildIds()) { for (const auto &id : getAttachmentChildIds()) {
if (ServerActiveObject *obj = m_env->getActiveObject(id)) { if (ServerActiveObject *obj = m_env->getActiveObject(id)) {
message_count++; message_count++;
msg_os << serializeLongString(obj->generateUpdateInfantCommand( msg_os << serializeString32(obj->generateUpdateInfantCommand(
id, protocol_version)); id, protocol_version));
} }
} }

2
src/server/serveractiveobject.cpp
View File

@ -61,7 +61,7 @@ std::string ServerActiveObject::generateUpdateInfantCommand(u16 infant_id, u16 p
// Clients since 4aa9a66 so no longer need this data // Clients since 4aa9a66 so no longer need this data
// Version 38 is the first bump after that commit. // Version 38 is the first bump after that commit.
// See also: ClientEnvironment::addActiveObject // See also: ClientEnvironment::addActiveObject
os << serializeLongString(getClientInitializationData(protocol_version)); os << serializeString32(getClientInitializationData(protocol_version));
} }
return os.str(); return os.str();
} }

6
src/server/unit_sao.cpp
View File

@ -242,7 +242,7 @@ std::string UnitSAO::generateUpdateAttachmentCommand() const
writeU8(os, AO_CMD_ATTACH_TO); writeU8(os, AO_CMD_ATTACH_TO);
// parameters // parameters
writeS16(os, m_attachment_parent_id); writeS16(os, m_attachment_parent_id);
os << serializeString(m_attachment_bone); os << serializeString16(m_attachment_bone);
writeV3F32(os, m_attachment_position); writeV3F32(os, m_attachment_position);
writeV3F32(os, m_attachment_rotation); writeV3F32(os, m_attachment_rotation);
return os.str(); return os.str();
@ -255,7 +255,7 @@ std::string UnitSAO::generateUpdateBonePositionCommand(
// command // command
writeU8(os, AO_CMD_SET_BONE_POSITION); writeU8(os, AO_CMD_SET_BONE_POSITION);
// parameters // parameters
os << serializeString(bone); os << serializeString16(bone);
writeV3F32(os, position); writeV3F32(os, position);
writeV3F32(os, rotation); writeV3F32(os, rotation);
return os.str(); return os.str();
@ -291,7 +291,7 @@ std::string UnitSAO::generateUpdateArmorGroupsCommand() const
writeU8(os, AO_CMD_UPDATE_ARMOR_GROUPS); writeU8(os, AO_CMD_UPDATE_ARMOR_GROUPS);
writeU16(os, m_armor_groups.size()); writeU16(os, m_armor_groups.size());
for (const auto &armor_group : m_armor_groups) { for (const auto &armor_group : m_armor_groups) {
os << serializeString(armor_group.first); os << serializeString16(armor_group.first);
writeS16(os, armor_group.second); writeS16(os, armor_group.second);
} }
return os.str(); return os.str();

4
src/sound.h
View File

@ -39,7 +39,7 @@ struct SimpleSoundSpec
// keep in sync with item definitions // keep in sync with item definitions
void serialize(std::ostream &os, u8 cf_version) const void serialize(std::ostream &os, u8 cf_version) const
{ {
os << serializeString(name); os << serializeString16(name);
writeF32(os, gain); writeF32(os, gain);
writeF32(os, pitch); writeF32(os, pitch);
writeF32(os, fade); writeF32(os, fade);
@ -49,7 +49,7 @@ struct SimpleSoundSpec
void deSerialize(std::istream &is, u8 cf_version) void deSerialize(std::istream &is, u8 cf_version)
{ {
name = deSerializeString(is); name = deSerializeString16(is);
gain = readF32(is); gain = readF32(is);
pitch = readF32(is); pitch = readF32(is);
fade = readF32(is); fade = readF32(is);

4
src/staticobject.cpp
View File

@ -35,7 +35,7 @@ void StaticObject::serialize(std::ostream &os)
// pos // pos
writeV3F1000(os, pos); writeV3F1000(os, pos);
// data // data
os<<serializeString(data); os<<serializeString16(data);
} }
void StaticObject::deSerialize(std::istream &is, u8 version) void StaticObject::deSerialize(std::istream &is, u8 version)
{ {
@ -44,7 +44,7 @@ void StaticObject::deSerialize(std::istream &is, u8 version)
// pos // pos
pos = readV3F1000(is); pos = readV3F1000(is);
// data // data
data = deSerializeString(is); data = deSerializeString16(is);
} }
void StaticObjectList::serialize(std::ostream &os) void StaticObjectList::serialize(std::ostream &os)

8
src/tool.cpp
View File

@ -66,7 +66,7 @@ void ToolCapabilities::serialize(std::ostream &os, u16 protocol_version) const
for (const auto &groupcap : groupcaps) { for (const auto &groupcap : groupcaps) {
const std::string *name = &groupcap.first; const std::string *name = &groupcap.first;
const ToolGroupCap *cap = &groupcap.second; const ToolGroupCap *cap = &groupcap.second;
os << serializeString(*name); os << serializeString16(*name);
writeS16(os, cap->uses); writeS16(os, cap->uses);
writeS16(os, cap->maxlevel); writeS16(os, cap->maxlevel);
writeU32(os, cap->times.size()); writeU32(os, cap->times.size());
@ -79,7 +79,7 @@ void ToolCapabilities::serialize(std::ostream &os, u16 protocol_version) const
writeU32(os, damageGroups.size()); writeU32(os, damageGroups.size());
for (const auto &damageGroup : damageGroups) { for (const auto &damageGroup : damageGroups) {
os << serializeString(damageGroup.first); os << serializeString16(damageGroup.first);
writeS16(os, damageGroup.second); writeS16(os, damageGroup.second);
} }
@ -98,7 +98,7 @@ void ToolCapabilities::deSerialize(std::istream &is)
groupcaps.clear(); groupcaps.clear();
u32 groupcaps_size = readU32(is); u32 groupcaps_size = readU32(is);
for (u32 i = 0; i < groupcaps_size; i++) { for (u32 i = 0; i < groupcaps_size; i++) {
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
ToolGroupCap cap; ToolGroupCap cap;
cap.uses = readS16(is); cap.uses = readS16(is);
cap.maxlevel = readS16(is); cap.maxlevel = readS16(is);
@ -113,7 +113,7 @@ void ToolCapabilities::deSerialize(std::istream &is)
u32 damage_groups_size = readU32(is); u32 damage_groups_size = readU32(is);
for (u32 i = 0; i < damage_groups_size; i++) { for (u32 i = 0; i < damage_groups_size; i++) {
std::string name = deSerializeString(is); std::string name = deSerializeString16(is);
s16 rating = readS16(is); s16 rating = readS16(is);
damageGroups[name] = rating; damageGroups[name] = rating;
} }

50
src/unittest/test_serialization.cpp
View File

@ -44,7 +44,7 @@ public:
std::wstring teststring2_w; std::wstring teststring2_w;
std::string teststring2_w_encoded; std::string teststring2_w_encoded;
static const u8 test_serialized_data[12 * 13 - 8]; static const u8 test_serialized_data[12 * 11 - 2];
}; };
static TestSerialization g_test_instance; static TestSerialization g_test_instance;
@ -91,21 +91,21 @@ void TestSerialization::buildTestStrings()
void TestSerialization::testSerializeString() void TestSerialization::testSerializeString()
{ {
// Test blank string // Test blank string
UASSERT(serializeString("") == mkstr("\0\0")); UASSERT(serializeString16("") == mkstr("\0\0"));
// Test basic string // Test basic string
UASSERT(serializeString("Hello world!") == mkstr("\0\14Hello world!")); UASSERT(serializeString16("Hello world!") == mkstr("\0\14Hello world!"));
// Test character range // Test character range
UASSERT(serializeString(teststring2) == mkstr("\1\0") + teststring2); UASSERT(serializeString16(teststring2) == mkstr("\1\0") + teststring2);
} }
void TestSerialization::testDeSerializeString() void TestSerialization::testDeSerializeString()
{ {
// Test deserialize // Test deserialize
{ {
std::istringstream is(serializeString(teststring2), std::ios::binary); std::istringstream is(serializeString16(teststring2), std::ios::binary);
UASSERT(deSerializeString(is) == teststring2); UASSERT(deSerializeString16(is) == teststring2);
UASSERT(!is.eof()); UASSERT(!is.eof());
is.get(); is.get();
UASSERT(is.eof()); UASSERT(is.eof());
@ -114,34 +114,34 @@ void TestSerialization::testDeSerializeString()
// Test deserialize an incomplete length specifier // Test deserialize an incomplete length specifier
{ {
std::istringstream is(mkstr("\x53"), std::ios::binary); std::istringstream is(mkstr("\x53"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeString(is)); EXCEPTION_CHECK(SerializationError, deSerializeString16(is));
} }
// Test deserialize a string with incomplete data // Test deserialize a string with incomplete data
{ {
std::istringstream is(mkstr("\x00\x55 abcdefg"), std::ios::binary); std::istringstream is(mkstr("\x00\x55 abcdefg"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeString(is)); EXCEPTION_CHECK(SerializationError, deSerializeString16(is));
} }
} }
void TestSerialization::testSerializeLongString() void TestSerialization::testSerializeLongString()
{ {
// Test blank string // Test blank string
UASSERT(serializeLongString("") == mkstr("\0\0\0\0")); UASSERT(serializeString32("") == mkstr("\0\0\0\0"));
// Test basic string // Test basic string
UASSERT(serializeLongString("Hello world!") == mkstr("\0\0\0\14Hello world!")); UASSERT(serializeString32("Hello world!") == mkstr("\0\0\0\14Hello world!"));
// Test character range // Test character range
UASSERT(serializeLongString(teststring2) == mkstr("\0\0\1\0") + teststring2); UASSERT(serializeString32(teststring2) == mkstr("\0\0\1\0") + teststring2);
} }
void TestSerialization::testDeSerializeLongString() void TestSerialization::testDeSerializeLongString()
{ {
// Test deserialize // Test deserialize
{ {
std::istringstream is(serializeLongString(teststring2), std::ios::binary); std::istringstream is(serializeString32(teststring2), std::ios::binary);
UASSERT(deSerializeLongString(is) == teststring2); UASSERT(deSerializeString32(is) == teststring2);
UASSERT(!is.eof()); UASSERT(!is.eof());
is.get(); is.get();
UASSERT(is.eof()); UASSERT(is.eof());
@ -150,19 +150,19 @@ void TestSerialization::testDeSerializeLongString()
// Test deserialize an incomplete length specifier // Test deserialize an incomplete length specifier
{ {
std::istringstream is(mkstr("\x53"), std::ios::binary); std::istringstream is(mkstr("\x53"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
} }
// Test deserialize a string with incomplete data // Test deserialize a string with incomplete data
{ {
std::istringstream is(mkstr("\x00\x00\x00\x05 abc"), std::ios::binary); std::istringstream is(mkstr("\x00\x00\x00\x05 abc"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
} }
// Test deserialize a string with a length too large // Test deserialize a string with a length too large
{ {
std::istringstream is(mkstr("\xFF\xFF\xFF\xFF blah"), std::ios::binary); std::istringstream is(mkstr("\xFF\xFF\xFF\xFF blah"), std::ios::binary);
EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
} }
} }
@ -235,19 +235,17 @@ void TestSerialization::testStreamRead()
UASSERT(readF1000(is) == F1000_MIN); UASSERT(readF1000(is) == F1000_MIN);
UASSERT(readF1000(is) == F1000_MAX); UASSERT(readF1000(is) == F1000_MAX);
UASSERT(deSerializeString(is) == "foobar!"); UASSERT(deSerializeString16(is) == "foobar!");
UASSERT(readV2S16(is) == v2s16(500, 500)); UASSERT(readV2S16(is) == v2s16(500, 500));
UASSERT(readV3S16(is) == v3s16(4207, 604, -30)); UASSERT(readV3S16(is) == v3s16(4207, 604, -30));
UASSERT(readV2S32(is) == v2s32(1920, 1080)); UASSERT(readV2S32(is) == v2s32(1920, 1080));
UASSERT(readV3S32(is) == v3s32(-400, 6400054, 290549855)); UASSERT(readV3S32(is) == v3s32(-400, 6400054, 290549855));
UASSERT(deSerializeWideString(is) == L"\x02~woof~\x5455");
UASSERT(readV3F1000(is) == v3f(500, 10024.2f, -192.54f)); UASSERT(readV3F1000(is) == v3f(500, 10024.2f, -192.54f));
UASSERT(readARGB8(is) == video::SColor(255, 128, 50, 128)); UASSERT(readARGB8(is) == video::SColor(255, 128, 50, 128));
UASSERT(deSerializeLongString(is) == "some longer string here"); UASSERT(deSerializeString32(is) == "some longer string here");
UASSERT(is.rdbuf()->in_avail() == 2); UASSERT(is.rdbuf()->in_avail() == 2);
UASSERT(readU16(is) == 0xF00D); UASSERT(readU16(is) == 0xF00D);
@ -275,7 +273,7 @@ void TestSerialization::testStreamWrite()
writeF1000(os, F1000_MIN); writeF1000(os, F1000_MIN);
writeF1000(os, F1000_MAX); writeF1000(os, F1000_MAX);
os << serializeString("foobar!"); os << serializeString16("foobar!");
data = os.str(); data = os.str();
UASSERT(data.size() < sizeof(test_serialized_data)); UASSERT(data.size() < sizeof(test_serialized_data));
@ -286,12 +284,10 @@ void TestSerialization::testStreamWrite()
writeV2S32(os, v2s32(1920, 1080)); writeV2S32(os, v2s32(1920, 1080));
writeV3S32(os, v3s32(-400, 6400054, 290549855)); writeV3S32(os, v3s32(-400, 6400054, 290549855));
os << serializeWideString(L"\x02~woof~\x5455");
writeV3F1000(os, v3f(500, 10024.2f, -192.54f)); writeV3F1000(os, v3f(500, 10024.2f, -192.54f));
writeARGB8(os, video::SColor(255, 128, 50, 128)); writeARGB8(os, video::SColor(255, 128, 50, 128));
os << serializeLongString("some longer string here"); os << serializeString32("some longer string here");
writeU16(os, 0xF00D); writeU16(os, 0xF00D);
@ -384,7 +380,7 @@ void TestSerialization::testFloatFormat()
UASSERT(test_single(i)); UASSERT(test_single(i));
} }
const u8 TestSerialization::test_serialized_data[12 * 13 - 8] = { const u8 TestSerialization::test_serialized_data[12 * 11 - 2] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
0xdd, 0xee, 0xff, 0x80, 0x75, 0x30, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff, 0xdd, 0xee, 0xff, 0x80, 0x75, 0x30, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0xd1, 0x1e, 0xee, 0x1e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0xd1, 0x1e, 0xee, 0x1e,
@ -392,9 +388,7 @@ const u8 TestSerialization::test_serialized_data[12 * 13 - 8] = {
0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, 0x21, 0x01, 0xf4, 0x01, 0xf4, 0x10, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, 0x21, 0x01, 0xf4, 0x01, 0xf4, 0x10,
0x6f, 0x02, 0x5c, 0xff, 0xe2, 0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0x04, 0x6f, 0x02, 0x5c, 0xff, 0xe2, 0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0x04,
0x38, 0xff, 0xff, 0xfe, 0x70, 0x00, 0x61, 0xa8, 0x36, 0x11, 0x51, 0x70, 0x38, 0xff, 0xff, 0xfe, 0x70, 0x00, 0x61, 0xa8, 0x36, 0x11, 0x51, 0x70,
0x5f, 0x00, 0x08, 0x00, 0x5f, 0x00, 0x07, 0xa1, 0x20, 0x00, 0x98, 0xf5, 0x08, 0xff,
0x02, 0x00, 0x7e, 0x00, 'w', 0x00, 'o', 0x00, 'o', 0x00, 'f', 0x00, // \x02~woof~\x5455
0x7e, 0x54, 0x55, 0x00, 0x07, 0xa1, 0x20, 0x00, 0x98, 0xf5, 0x08, 0xff,
0xfd, 0x0f, 0xe4, 0xff, 0x80, 0x32, 0x80, 0x00, 0x00, 0x00, 0x17, 0x73, 0xfd, 0x0f, 0xe4, 0xff, 0x80, 0x32, 0x80, 0x00, 0x00, 0x00, 0x17, 0x73,
0x6f, 0x6d, 0x65, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x73,
0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x65, 0x72, 0x65, 0xF0, 0x0D, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x65, 0x72, 0x65, 0xF0, 0x0D,

63
src/util/serialize.cpp
View File

@ -35,13 +35,13 @@ FloatType g_serialize_f32_type = FLOATTYPE_UNKNOWN;
//// String //// String
//// ////
std::string serializeString(const std::string &plain) std::string serializeString16(const std::string &plain)
{ {
std::string s; std::string s;
char buf[2]; char buf[2];
if (plain.size() > STRING_MAX_LEN) if (plain.size() > STRING_MAX_LEN)
throw SerializationError("String too long for serializeString"); throw SerializationError("String too long for serializeString16");
s.reserve(2 + plain.size()); s.reserve(2 + plain.size());
writeU16((u8 *)&buf[0], plain.size()); writeU16((u8 *)&buf[0], plain.size());
@ -51,14 +51,14 @@ std::string serializeString(const std::string &plain)
return s; return s;
} }
std::string deSerializeString(std::istream &is) std::string deSerializeString16(std::istream &is)
{ {
std::string s; std::string s;
char buf[2]; char buf[2];
is.read(buf, 2); is.read(buf, 2);
if (is.gcount() != 2) if (is.gcount() != 2)
throw SerializationError("deSerializeString: size not read"); throw SerializationError("deSerializeString16: size not read");
u16 s_size = readU16((u8 *)buf); u16 s_size = readU16((u8 *)buf);
if (s_size == 0) if (s_size == 0)
@ -67,66 +67,17 @@ std::string deSerializeString(std::istream &is)
s.resize(s_size); s.resize(s_size);
is.read(&s[0], s_size); is.read(&s[0], s_size);
if (is.gcount() != s_size) if (is.gcount() != s_size)
throw SerializationError("deSerializeString: couldn't read all chars"); throw SerializationError("deSerializeString16: couldn't read all chars");
return s; return s;
} }
////
//// Wide String
////
std::string serializeWideString(const std::wstring &plain)
{
std::string s;
char buf[2];
if (plain.size() > WIDE_STRING_MAX_LEN)
throw SerializationError("String too long for serializeWideString");
s.reserve(2 + 2 * plain.size());
writeU16((u8 *)buf, plain.size());
s.append(buf, 2);
for (wchar_t i : plain) {
writeU16((u8 *)buf, i);
s.append(buf, 2);
}
return s;
}
std::wstring deSerializeWideString(std::istream &is)
{
std::wstring s;
char buf[2];
is.read(buf, 2);
if (is.gcount() != 2)
throw SerializationError("deSerializeWideString: size not read");
u16 s_size = readU16((u8 *)buf);
if (s_size == 0)
return s;
s.reserve(s_size);
for (u32 i = 0; i < s_size; i++) {
is.read(&buf[0], 2);
if (is.gcount() != 2) {
throw SerializationError(
"deSerializeWideString: couldn't read all chars");
}
wchar_t c16 = readU16((u8 *)buf);
s.append(&c16, 1);
}
return s;
}
//// ////
//// Long String //// Long String
//// ////
std::string serializeLongString(const std::string &plain) std::string serializeString32(const std::string &plain)
{ {
std::string s; std::string s;
char buf[4]; char buf[4];
@ -141,7 +92,7 @@ std::string serializeLongString(const std::string &plain)
return s; return s;
} }
std::string deSerializeLongString(std::istream &is) std::string deSerializeString32(std::istream &is)
{ {
std::string s; std::string s;
char buf[4]; char buf[4];

8
src/util/serialize.h
View File

@ -440,16 +440,16 @@ MAKE_STREAM_WRITE_FXN(video::SColor, ARGB8, 4);
//// ////
// Creates a string with the length as the first two bytes // Creates a string with the length as the first two bytes
std::string serializeString(const std::string &plain); std::string serializeString16(const std::string &plain);
// Reads a string with the length as the first two bytes // Reads a string with the length as the first two bytes
std::string deSerializeString(std::istream &is); std::string deSerializeString16(std::istream &is);
// Creates a string with the length as the first four bytes // Creates a string with the length as the first four bytes
std::string serializeLongString(const std::string &plain); std::string serializeString32(const std::string &plain);
// Reads a string with the length as the first four bytes // Reads a string with the length as the first four bytes
std::string deSerializeLongString(std::istream &is); std::string deSerializeString32(std::istream &is);
// Creates a string encoded in JSON format (almost equivalent to a C string literal) // Creates a string encoded in JSON format (almost equivalent to a C string literal)
std::string serializeJsonString(const std::string &plain); std::string serializeJsonString(const std::string &plain);