Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2026-10-02 19:03:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
d6dd5737419f83f7117c781ca198b3ecffed3719
DarkflameServer/dNet/WorldPackets.cpp
Aaron Kimbrell 79235702b3 feat(ugc): answer the client's UGC manifest requests without 3D services 
With UGCUSE3DSERVICES=7:0 (the client's default) the client asks its world for
a blueprint file's MD5 and size (REQUEST_UGC_MANIFEST_INFO, world 27) and then
downloads BrickModels/UserMade/<id % 1000>/<id>.<ext>.sd0. Layouts checked in
the 1.10.64 client: the request is a u64 blueprint id and a u8 resource type;
the answer (UGC_MANIFEST_RESPONSE, client 60) repeats them and adds a u8 valid,
the u32 size and the 16 byte MD5 of the inflated file, 37 bytes after the 0x53
exactly or the client drops it.

- dNet: WorldPackets::RequestUgcManifestInfo, ClientPackets::UgcManifestResponse
  (eUgcResourceType), with byte tests against the client's layouts.
- Database: ugc_file_checksums (per model or module combination and file) and
  ugc_modular_build.combination_id (migrations 89 / 72), GetUgcFileChecksum
  looks a blueprint up as a model, else as a build through its combination.
- UGC server: every download is also written as .sd0 (Sd0::Compress); workers
  hand the checksums back and the main thread stores them; old items get their
  sd0 icon and checksum, and builds their combination id, once at start-up, a
  few per tick; serves <dir>/BrickModels/UserMade/<bucket>/<id>.<ext>.sd0 under
  client_path, /<folder>/UserBrickModels and the root (.hkx 404).
- World: UgcManifest answers on the main thread with one indexed query per
  request; files not made yet are answered when they are (looked at again
  every 5 seconds), and a model in its quiet period is made right away. No
  worker threads, HTTP or file reads in the world.

Off by default (ugc_manifest=0): checked in game, the client then downloads
from http://127.0.0.1:80/lwoclient/UserBrickModels/ whatever its boot.cfg says
and logs the player out when it can't connect, so icons need the UGC server on
port 80 of each player's machine. docs/UgcServer.md has the details.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-28 22:31:14 -05:00

363 lines
12 KiB
C++
Raw Blame History

#include "WorldPackets.h"
#include "dCommonVars.h"
#include <algorithm>
namespace {
// Copies every unread bit of from into to.
bool ReadRest(RakNet::BitStream& from, RakNet::BitStream& to) {
to.Reset();
return from.Read(to, from.GetNumberOfUnreadBits());
}
void WriteAll(RakNet::BitStream& to, const RakNet::BitStream& from) {
auto& nonConst = const_cast<RakNet::BitStream&>(from); // GetData is not const in RakNet
to.WriteBits(nonConst.GetData(), nonConst.GetNumberOfBitsUsed(), false);
}
}
namespace WorldPackets {
void Validation::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(username);
bitStream.Write(sessionKey);
bitStream.Write(fdbChecksum);
}
bool Validation::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(username));
// sometimes client puts a null terminator at the end of the checksum and sometimes doesn't, weird
VALIDATE_READ(bitStream.Read(sessionKey));
VALIDATE_READ(bitStream.Read(fdbChecksum));
return true;
}
void CharacterCreateRequest::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(name);
bitStream.Write(firstNameIndex);
bitStream.Write(middleNameIndex);
bitStream.Write(lastNameIndex);
for (const auto byte : unknown) bitStream.Write(byte);
bitStream.Write(shirtColor);
bitStream.Write(shirtStyle);
bitStream.Write(pantsColor);
bitStream.Write(hairStyle);
bitStream.Write(hairColor);
bitStream.Write(leftHand);
bitStream.Write(rightHand);
bitStream.Write(eyebrows);
bitStream.Write(eyes);
bitStream.Write(mouth);
}
bool CharacterCreateRequest::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(name));
VALIDATE_READ(bitStream.Read(firstNameIndex));
VALIDATE_READ(bitStream.Read(middleNameIndex));
VALIDATE_READ(bitStream.Read(lastNameIndex));
for (auto& byte : unknown) VALIDATE_READ(bitStream.Read(byte));
VALIDATE_READ(bitStream.Read(shirtColor));
VALIDATE_READ(bitStream.Read(shirtStyle));
VALIDATE_READ(bitStream.Read(pantsColor));
VALIDATE_READ(bitStream.Read(hairStyle));
VALIDATE_READ(bitStream.Read(hairColor));
VALIDATE_READ(bitStream.Read(leftHand));
VALIDATE_READ(bitStream.Read(rightHand));
VALIDATE_READ(bitStream.Read(eyebrows));
VALIDATE_READ(bitStream.Read(eyes));
VALIDATE_READ(bitStream.Read(mouth));
return true;
}
void CharacterLoginRequest::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(playerID);
}
bool CharacterLoginRequest::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(playerID));
return true;
}
void GameMessage::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(objectID);
bitStream.Write(messageID);
WriteAll(bitStream, data);
}
bool GameMessage::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(objectID));
VALIDATE_READ(bitStream.Read(messageID));
VALIDATE_READ(ReadRest(bitStream, data));
return true;
}
void CharacterDeleteRequest::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(objectID);
}
bool CharacterDeleteRequest::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(objectID));
return true;
}
void CharacterRenameRequest::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(objectID);
bitStream.Write(name);
}
bool CharacterRenameRequest::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(objectID));
VALIDATE_READ(bitStream.Read(name));
return true;
}
void LevelLoadComplete::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(mapID);
bitStream.Write(instanceID);
bitStream.Write(cloneID);
}
bool LevelLoadComplete::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(mapID));
VALIDATE_READ(bitStream.Read(instanceID));
VALIDATE_READ(bitStream.Read(cloneID));
return true;
}
void PositionUpdate::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(update.position.x);
bitStream.Write(update.position.y);
bitStream.Write(update.position.z);
bitStream.Write(update.rotation.x);
bitStream.Write(update.rotation.y);
bitStream.Write(update.rotation.z);
bitStream.Write(update.rotation.w);
bitStream.Write(update.onGround);
bitStream.Write(update.onRail);
bitStream.Write(hasVelocity);
if (hasVelocity) {
bitStream.Write(update.velocity.x);
bitStream.Write(update.velocity.y);
bitStream.Write(update.velocity.z);
}
bitStream.Write(hasAngularVelocity);
if (hasAngularVelocity) {
bitStream.Write(update.angularVelocity.x);
bitStream.Write(update.angularVelocity.y);
bitStream.Write(update.angularVelocity.z);
}
bitStream.Write(hasLocalSpaceInfo);
if (hasLocalSpaceInfo) {
bitStream.Write(update.localSpaceInfo.objectId);
bitStream.Write(update.localSpaceInfo.position.x);
bitStream.Write(update.localSpaceInfo.position.y);
bitStream.Write(update.localSpaceInfo.position.z);
bitStream.Write(hasLinearVelocity);
if (hasLinearVelocity) {
bitStream.Write(update.localSpaceInfo.linearVelocity.x);
bitStream.Write(update.localSpaceInfo.linearVelocity.y);
bitStream.Write(update.localSpaceInfo.linearVelocity.z);
}
}
bitStream.Write(hasRemoteInputInfo);
if (hasRemoteInputInfo) {
bitStream.Write(update.remoteInputInfo.m_RemoteInputX);
bitStream.Write(update.remoteInputInfo.m_RemoteInputY);
bitStream.Write(update.remoteInputInfo.m_IsPowersliding);
bitStream.Write(update.remoteInputInfo.m_IsModified);
}
}
bool PositionUpdate::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(update.position.x));
VALIDATE_READ(bitStream.Read(update.position.y));
VALIDATE_READ(bitStream.Read(update.position.z));
VALIDATE_READ(bitStream.Read(update.rotation.x));
VALIDATE_READ(bitStream.Read(update.rotation.y));
VALIDATE_READ(bitStream.Read(update.rotation.z));
VALIDATE_READ(bitStream.Read(update.rotation.w));
VALIDATE_READ(bitStream.Read(update.onGround));
VALIDATE_READ(bitStream.Read(update.onRail));
VALIDATE_READ(bitStream.Read(hasVelocity));
if (hasVelocity) {
VALIDATE_READ(bitStream.Read(update.velocity.x));
VALIDATE_READ(bitStream.Read(update.velocity.y));
VALIDATE_READ(bitStream.Read(update.velocity.z));
}
VALIDATE_READ(bitStream.Read(hasAngularVelocity));
if (hasAngularVelocity) {
VALIDATE_READ(bitStream.Read(update.angularVelocity.x));
VALIDATE_READ(bitStream.Read(update.angularVelocity.y));
VALIDATE_READ(bitStream.Read(update.angularVelocity.z));
}
// The last two sections may be missing entirely (DLU has always accepted that)
hasLocalSpaceInfo = false;
hasLinearVelocity = false;
if (bitStream.Read(hasLocalSpaceInfo) && hasLocalSpaceInfo) {
VALIDATE_READ(bitStream.Read(update.localSpaceInfo.objectId));
VALIDATE_READ(bitStream.Read(update.localSpaceInfo.position.x));
VALIDATE_READ(bitStream.Read(update.localSpaceInfo.position.y));
VALIDATE_READ(bitStream.Read(update.localSpaceInfo.position.z));
if (bitStream.Read(hasLinearVelocity) && hasLinearVelocity) {
VALIDATE_READ(bitStream.Read(update.localSpaceInfo.linearVelocity.x));
VALIDATE_READ(bitStream.Read(update.localSpaceInfo.linearVelocity.y));
VALIDATE_READ(bitStream.Read(update.localSpaceInfo.linearVelocity.z));
}
}
hasRemoteInputInfo = false;
if (bitStream.Read(hasRemoteInputInfo) && hasRemoteInputInfo) {
VALIDATE_READ(bitStream.Read(update.remoteInputInfo.m_RemoteInputX));
VALIDATE_READ(bitStream.Read(update.remoteInputInfo.m_RemoteInputY));
VALIDATE_READ(bitStream.Read(update.remoteInputInfo.m_IsPowersliding));
VALIDATE_READ(bitStream.Read(update.remoteInputInfo.m_IsModified));
}
return true;
}
void MailPacket::Serialize(RakNet::BitStream& bitStream) const {
WriteAll(bitStream, data);
}
bool MailPacket::Deserialize(RakNet::BitStream& bitStream) {
return ReadRest(bitStream, data);
}
void RoutePacket::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(size);
bitStream.Write(routedService);
bitStream.Write(routedMessageID);
bitStream.Write(padding);
for (const auto byte : routedData) bitStream.Write(byte);
}
bool RoutePacket::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(size));
VALIDATE_READ(bitStream.Read(routedService));
VALIDATE_READ(bitStream.Read(routedMessageID));
VALIDATE_READ(bitStream.Read(padding));
routedData.resize(BITS_TO_BYTES(bitStream.GetNumberOfUnreadBits()));
if (!routedData.empty()) VALIDATE_READ(bitStream.ReadBits(routedData.data(), BYTES_TO_BITS(routedData.size()), true));
return true;
}
ChatPackets::RoutedFromClient RoutePacket::ToChat(const LWOOBJID senderID) const {
constexpr size_t ROUTED_DATA_SKIP = 4;
ChatPackets::RoutedFromClient routed(static_cast<uint8_t>(routedMessageID & 0xFF));
routed.senderID = senderID;
for (size_t i = ROUTED_DATA_SKIP; i - ROUTED_DATA_SKIP < size && i < routedData.size(); ++i) {
routed.data.push_back(routedData[i]);
}
return routed;
}
void StringCheck::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(chatLevel);
bitStream.Write(requestID);
auto fixedReceiver = receiver;
fixedReceiver.resize(42);
bitStream.Write(fixedReceiver);
bitStream.Write<uint16_t>(message.size());
bitStream.Write(message);
}
bool StringCheck::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(chatLevel));
VALIDATE_READ(bitStream.Read(requestID));
receiver.resize(42);
VALIDATE_READ(bitStream.ReadBits(reinterpret_cast<unsigned char*>(receiver.data()), BYTES_TO_BITS(receiver.size() * sizeof(char16_t)), true));
VALIDATE_READ(BitStreamUtils::ReadLengthPrefixed<uint16_t>(bitStream, message));
return true;
}
std::string StringCheck::GetNarrowReceiver() const {
std::string narrow;
for (const auto character : receiver) narrow.push_back(static_cast<uint8_t>(character));
if (!narrow.empty()) {
if (std::string(narrow.c_str(), 4) == "[GM]") { // Shift the string forward if we are speaking to a GM as the client appends "[GM]" if they are
narrow = std::string(narrow.c_str() + 4, narrow.size() - 4);
}
}
return narrow;
}
std::string StringCheck::GetNarrowMessage() const {
std::string narrow;
for (const auto character : message) narrow.push_back(static_cast<uint8_t>(character));
return narrow;
}
void GeneralChatMessage::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(chatChannel);
bitStream.Write(unknown);
bitStream.Write<int32_t>(message.size() + 1);
bitStream.Write(message);
bitStream.Write<char16_t>(u'\0');
}
bool GeneralChatMessage::Deserialize(RakNet::BitStream& bitStream) {
int32_t messageLength{};
VALIDATE_READ(bitStream.Read(chatChannel));
VALIDATE_READ(bitStream.Read(unknown));
VALIDATE_READ(bitStream.Read(messageLength));
if (messageLength < 0 || static_cast<uint32_t>(messageLength) > MAX_MESSAGE_LENGTH) return false;
message.clear();
for (int32_t i = 0; i < (messageLength - 1); ++i) {
char16_t character;
VALIDATE_READ(bitStream.Read(character));
message.push_back(character);
}
// The null terminator the count includes; DLU never needed it
if (messageLength > 0) bitStream.IgnoreBits(std::min<BitSize_t>(bitStream.GetNumberOfUnreadBits(), BYTES_TO_BITS(sizeof(char16_t))));
return true;
}
void HandleFunness::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(cheatInfo);
bitStream.Write(cheatType);
}
bool HandleFunness::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(cheatInfo));
VALIDATE_READ(bitStream.Read(cheatType));
return true;
}
void RequestUgcManifestInfo::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(blueprintId);
bitStream.Write(resourceType);
}
bool RequestUgcManifestInfo::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(blueprintId));
VALIDATE_READ(bitStream.Read(resourceType));
return true;
}
void UIHelpTop5::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(language);
}
bool UIHelpTop5::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(language));
return true;
}
}
Reference in New Issue View Git Blame Copy Permalink