Files
DarkflameServer/dDashboardServer/routes/CharacterXmlCheck.h
Aaron Kimbrell b2fba9d35b feat: save play time as live did: time before the session, stime in it
Live kept the total before the running session in <char time> and the
session's seconds in <char stime>; both changed at a login, together with
llog (time 262486 and stime 7344 became time 269830 at the next login).
The client reads both (LWOCharacterComponent::LoadFromSaveData 0x00ca4910)
and shows their sum (SendMessage 0x00d34330, GetTimePlayed). The server
wrote everything into time and no stime.

Now time + stime is read (a missing stime is 0, so a save from before
keeps its total) and time and stime are written as live had them. A
session starts when the character is picked on the character list:
charinfo.last_login is loaded with the character, a save whose llog is
another login has its stime moved into time, and llog is written as the
session's login. Without a known login the session goes on.

GetTotalTimePlayed is still every second played. The dashboard's save
check knows stime as a number.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-10 15:54:54 -06:00

381 lines
20 KiB
C++

#pragma once
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
#include "tinyxml2.h"
#include "ContrabandRules.h"
#include "GeneralUtils.h"
#include "dCommonVars.h"
#include "eCharacterVersion.h"
#include "eInventoryType.h"
/**
* Checks a character XML uploaded on the dashboard before it is stored. That upload is the one place hand-written
* XML reaches the game, and the game's load path (Character::DoQuickXMLDataParse and the LoadFromXml/LoadXml of the
* Character, Inventory, Mission, Destroyable, Buff, LevelProgression, ControllablePhysics and Character components)
* trusts the XML because the server writes it itself. So instead of the game skipping bad data at load (and saving
* the loss back), bad uploads are refused here.
*
* - errors: things the load path would throw on, read uninitialized, stop loading at (dropping everything after it,
* which is then saved back), or silently drop (an unknown mission or item, a duplicate item id or slot).
* The upload is refused.
* - warnings: valid but suspicious content (contraband, stacks above the item's stack size, coins, level or u-score
* out of reach, GM level above the account's). Staff see them and must confirm to store the XML.
*
* Pure (the game data it needs comes in through Lookups) so it can be unit tested.
*/
namespace CharacterXmlCheck {
constexpr int64_t MAX_COINS = 2000000000;
constexpr int64_t MAX_COUNT = 999999;
constexpr size_t MAX_REPORTED = 50;
// Game data from the CDClient; an unset lookup skips its check
struct Lookups {
std::function<bool(LOT)> isItem; // the LOT has an item component
std::function<int32_t(LOT)> stackSize; // the item's stack size, 0 if unknown
std::function<bool(int32_t)> missionExists; // the mission is in the Missions table
std::function<std::optional<int64_t>(uint32_t)> levelUScore; // u-score needed to reach a level
uint32_t maxLevel = 0; // highest level (0: unknown)
};
struct Context {
uint32_t ownerAccountId = 0; // the account of the character being replaced
int32_t accountGmLevel = 0; // that account's GM level
bool contrabandApplies = true; // Contraband::Applies for that account
Contraband::List contraband;
Lookups lookups;
};
struct Result {
std::vector<std::string> errors;
std::vector<std::string> warnings;
std::vector<Contraband::Finding> contraband;
bool Ok() const { return errors.empty(); }
};
namespace Detail {
enum class eKind { INT, UINT, INT64, UINT64, FLOAT, BOOL };
inline const char* KindName(eKind kind) {
switch (kind) {
case eKind::INT: return "a whole number";
case eKind::UINT: return "a non-negative whole number";
case eKind::INT64: return "a whole number";
case eKind::UINT64: return "a non-negative whole number";
case eKind::FLOAT: return "a number";
case eKind::BOOL: return "true/false or 1/0";
}
return "a number";
}
// Parses like the game's tinyxml2 Query*Attribute calls
inline bool Parses(const tinyxml2::XMLElement& e, const char* name, eKind kind) {
int i; unsigned u; int64_t i64; uint64_t u64; float f; bool b;
switch (kind) {
case eKind::INT: return e.QueryIntAttribute(name, &i) == tinyxml2::XML_SUCCESS;
case eKind::UINT: return e.QueryUnsignedAttribute(name, &u) == tinyxml2::XML_SUCCESS && e.Attribute(name)[0] != '-';
case eKind::INT64: return e.QueryInt64Attribute(name, &i64) == tinyxml2::XML_SUCCESS;
case eKind::UINT64: return e.QueryUnsigned64Attribute(name, &u64) == tinyxml2::XML_SUCCESS && e.Attribute(name)[0] != '-';
case eKind::FLOAT: return e.QueryFloatAttribute(name, &f) == tinyxml2::XML_SUCCESS;
case eKind::BOOL: return e.QueryBoolAttribute(name, &b) == tinyxml2::XML_SUCCESS;
}
return false;
}
struct Checker {
Result& result;
const Context& context;
void Error(const std::string& text) { if (result.errors.size() < MAX_REPORTED) result.errors.push_back(text); }
void Warn(const std::string& text) { if (result.warnings.size() < MAX_REPORTED) result.warnings.push_back(text); }
// Optional attributes: when present they must parse
void Numbers(const tinyxml2::XMLElement& e, const std::string& where, eKind kind, std::initializer_list<const char*> names) {
for (const auto* name : names) {
const char* value = e.Attribute(name);
if (value && !Parses(e, name, kind)) Error(where + ": " + name + "=\"" + value + "\" must be " + KindName(kind));
}
}
// Required attributes: the game reads them into uninitialized variables
bool Required(const tinyxml2::XMLElement& e, const std::string& where, eKind kind, std::initializer_list<const char*> names) {
bool ok = true;
for (const auto* name : names) {
if (!e.Attribute(name)) { Error(where + ": " + name + " is missing"); ok = false; }
}
Numbers(e, where, kind, names);
for (const auto* name : names) if (e.Attribute(name) && !Parses(e, name, kind)) ok = false;
return ok;
}
static int64_t Int64(const tinyxml2::XMLElement& e, const char* name) { return e.Int64Attribute(name, 0); }
static std::string Str(int64_t value) { return std::to_string(value); }
static bool KnownInventory(uint32_t type) { return type <= eInventoryType::ITEM_SETS; }
static bool KnownMissionState(int64_t state) {
switch (state) {
case -1: case 0: case 1: case 2: case 4: case 8: case 9: case 10: case 12: case 16: return true;
default: return false;
}
}
void Mf(const tinyxml2::XMLElement& mf) {
Numbers(mf, "<mf>", eKind::UINT, { "hc", "hs", "hd", "t", "l", "hdc", "cd", "lh", "rh", "es", "ess", "ms" });
}
void Char(const tinyxml2::XMLElement& c) {
const std::string where = "<char>";
Numbers(c, where, eKind::INT64, { "cc", "rpt", "ls", "lrid", "gid", "llog" });
Numbers(c, where, eKind::INT, { "gm", "ft" });
Numbers(c, where, eKind::UINT, { "lwid", "lnzid", "acct" });
Numbers(c, where, eKind::UINT64, { "lzid", "co", "co1", "co2", "co3", "time" });
Numbers(c, where, eKind::FLOAT, { "lzx", "lzy", "lzz", "lzrx", "lzry", "lzrz", "lzrw", "stime" });
if (c.Attribute("acct") && Parses(c, "acct", eKind::UINT) && c.UnsignedAttribute("acct") != context.ownerAccountId) {
Error(where + ": acct=\"" + c.Attribute("acct") + "\" is not the account of this character (" + std::to_string(context.ownerAccountId) + ")");
}
if (c.Attribute("gm") && Parses(c, "gm", eKind::INT)) {
const auto gm = c.IntAttribute("gm");
if (gm < 0 || gm > 9) Error(where + ": gm=\"" + std::to_string(gm) + "\" is not a GM level (0 to 9)");
else if (gm > context.accountGmLevel) Warn("GM level " + std::to_string(gm) + " in the XML is above the account's (" + std::to_string(context.accountGmLevel) + ")");
}
if (c.Attribute("cc") && Parses(c, "cc", eKind::INT64)) {
const auto coins = Int64(c, "cc");
if (coins < 0) Error(where + ": cc (coins) can't be negative");
else if (coins > MAX_COINS) Warn("Coins " + Str(coins) + " are above " + Str(MAX_COINS));
}
if (c.Attribute("ls") && Parses(c, "ls", eKind::INT64) && Int64(c, "ls") < 0) Error(where + ": ls (u-score) can't be negative");
if (const auto* ue = c.FirstChildElement("ue")) {
for (const auto* e = ue->FirstChildElement(); e; e = e->NextSiblingElement()) Required(*e, "<char><ue> emote", eKind::INT, { "id" });
}
if (const auto* vl = c.FirstChildElement("vl")) {
for (const auto* l = vl->FirstChildElement("l"); l; l = l->NextSiblingElement("l")) Numbers(*l, "<char><vl><l>", eKind::INT, { "id", "cid" });
}
if (const auto* zs = c.FirstChildElement("zs")) {
for (const auto* s = zs->FirstChildElement(); s; s = s->NextSiblingElement()) {
Required(*s, "<char><zs> zone statistics", eKind::UINT, { "map" });
Numbers(*s, "<char><zs> zone statistics", eKind::UINT64, { "ac", "cc", "es", "qbc" });
Numbers(*s, "<char><zs> zone statistics", eKind::INT64, { "bc" });
}
}
}
void Flags(const tinyxml2::XMLElement& flags) {
for (const auto* f = flags.FirstChildElement(); f; f = f->NextSiblingElement()) {
const char* id = f->Attribute("id");
const char* v = f->Attribute("v");
// Character::DoQuickXMLDataParse reads both with std::stoul/std::stoull, which throw
if (id && v) {
if (!GeneralUtils::TryParse<uint32_t>(id)) Error(std::string("<flag>: id=\"") + id + "\" must be a non-negative whole number");
if (!GeneralUtils::TryParse<uint64_t>(v)) Error(std::string("<flag>: v=\"") + v + "\" must be a non-negative whole number");
}
}
}
void Dest(const tinyxml2::XMLElement& dest) {
Numbers(dest, "<dest>", eKind::INT, { "hc", "ic", "ac" });
Numbers(dest, "<dest>", eKind::FLOAT, { "hm", "im", "am" });
if (const auto* buff = dest.FirstChildElement("buff")) {
for (const auto* b = buff->FirstChildElement("b"); b; b = b->NextSiblingElement("b")) {
Numbers(*b, "<dest><buff><b>", eKind::INT, { "id", "b", "refCount" });
Numbers(*b, "<dest><buff><b>", eKind::FLOAT, { "t", "tk", "tt", "s" });
Numbers(*b, "<dest><buff><b>", eKind::INT64, { "sr" });
Numbers(*b, "<dest><buff><b>", eKind::BOOL, { "cancelOnDamaged", "cancelOnDeath", "cancelOnLogout", "cancelOnRemoveBuff", "cancelOnUi", "cancelOnUnequip", "cancelOnZone", "applyOnTeammates" });
}
}
}
void Level(const tinyxml2::XMLElement& lvl, int64_t uscore) {
Numbers(lvl, "<lvl>", eKind::UINT, { "l", "cv" });
Numbers(lvl, "<lvl>", eKind::FLOAT, { "sb" });
if (lvl.Attribute("cv") && Parses(lvl, "cv", eKind::UINT) && lvl.UnsignedAttribute("cv") > GeneralUtils::ToUnderlying(eCharacterVersion::UP_TO_DATE)) {
Error("<lvl>: cv=\"" + std::string(lvl.Attribute("cv")) + "\" is newer than this server's character version (" + std::to_string(GeneralUtils::ToUnderlying(eCharacterVersion::UP_TO_DATE)) + ")");
}
if (!lvl.Attribute("l") || !Parses(lvl, "l", eKind::UINT)) return;
const auto level = lvl.UnsignedAttribute("l");
const auto& lookups = context.lookups;
if (lookups.maxLevel > 0 && level > lookups.maxLevel) {
Warn("Level " + std::to_string(level) + " is above the highest level (" + std::to_string(lookups.maxLevel) + ")");
return;
}
if (!lookups.levelUScore || uscore < 0) return;
const auto needed = lookups.levelUScore(level);
if (needed && uscore < *needed) Warn("Level " + std::to_string(level) + " needs " + Str(*needed) + " u-score but the character has " + Str(uscore));
const auto next = level < lookups.maxLevel ? lookups.levelUScore(level + 1) : std::nullopt;
if (next && uscore >= *next) Warn("U-score " + Str(uscore) + " is enough for level " + std::to_string(level + 1) + " but the character is level " + std::to_string(level));
}
void Inventory(const tinyxml2::XMLElement& inv) {
Numbers(inv, "<inv>", eKind::INT, { "csl" });
if (const auto* grps = inv.FirstChildElement("grps")) {
for (const auto* g = grps->FirstChildElement("grp"); g; g = g->NextSiblingElement("grp")) Numbers(*g, "<inv><grps><grp>", eKind::UINT, { "t" });
}
const auto* bag = inv.FirstChildElement("bag");
for (const auto* b = bag->FirstChildElement(); b; b = b->NextSiblingElement()) {
if (Required(*b, "<inv><bag><b>", eKind::UINT, { "t", "m" }) && !KnownInventory(b->UnsignedAttribute("t"))) {
Error("<inv><bag><b>: t=\"" + std::string(b->Attribute("t")) + "\" is not an inventory type");
}
}
std::set<LWOOBJID> ids;
std::map<uint32_t, std::set<uint32_t>> slots;
std::map<LOT, int32_t> stackSizes;
const auto& lookups = context.lookups;
for (const auto* in = inv.FirstChildElement("items")->FirstChildElement(); in; in = in->NextSiblingElement()) {
if (!Required(*in, "<inv><items><in>", eKind::UINT, { "t" })) continue;
const auto type = in->UnsignedAttribute("t");
if (!KnownInventory(type)) {
Error("<inv><items><in>: t=\"" + std::to_string(type) + "\" is not an inventory type");
continue;
}
const auto inventoryName = std::string(InventoryType::InventoryTypeToString(static_cast<eInventoryType>(type)));
// Items in the build inventories are moved (and given new slots) when the character loads
const bool reslotted = type == eInventoryType::MODELS_IN_BBB || type == eInventoryType::BRICKS_IN_BBB;
for (const auto* i = in->FirstChildElement(); i; i = i->NextSiblingElement()) {
const std::string where = "Item in " + inventoryName + (i->Attribute("l") ? std::string(" (LOT ") + i->Attribute("l") + ")" : std::string());
bool ok = Required(*i, where, eKind::INT64, { "id" });
ok = Required(*i, where, eKind::INT, { "l" }) && ok;
ok = Required(*i, where, eKind::UINT, { "s", "c" }) && ok;
ok = Required(*i, where, eKind::BOOL, { "eq", "b" }) && ok;
Numbers(*i, where, eKind::INT64, { "sk", "parent" });
if (!ok) continue;
const auto id = i->Int64Attribute("id");
const LOT lot = i->IntAttribute("l");
const auto slot = i->UnsignedAttribute("s");
const auto count = i->UnsignedAttribute("c");
if (id == LWOOBJID_EMPTY) Error(where + ": id can't be 0");
else if (!ids.insert(id).second) Error(where + ": id " + std::to_string(id) + " is used by another item (the game would drop one)");
if (!reslotted && !slots[type].insert(slot).second) Error(where + ": slot " + std::to_string(slot) + " is used by another item in " + inventoryName + " (the game would drop one)");
if (lookups.isItem && !lookups.isItem(lot)) {
Error(where + ": LOT " + std::to_string(lot) + " is not an item");
continue;
}
if (count == 0) Warn(where + ": count is 0");
else if (count > MAX_COUNT) Warn(where + ": count " + std::to_string(count) + " is above " + std::to_string(MAX_COUNT));
else if (lookups.stackSize) {
auto it = stackSizes.find(lot);
if (it == stackSizes.end()) it = stackSizes.emplace(lot, lookups.stackSize(lot)).first;
if (it->second > 0 && count > static_cast<uint32_t>(it->second)) Warn(where + ": count " + std::to_string(count) + " is above the stack size (" + std::to_string(it->second) + ")");
}
// Proxy items of item sets aren't what the player holds, like the world's check
if (i->Int64Attribute("parent", LWOOBJID_EMPTY) == LWOOBJID_EMPTY) held.push_back({ id, lot, count, static_cast<eInventoryType>(type) });
}
}
}
void Pets(const tinyxml2::XMLElement& pet) {
for (const auto* p = pet.FirstChildElement(); p; p = p->NextSiblingElement()) {
Numbers(*p, "<pet> pet", eKind::INT64, { "id" });
Numbers(*p, "<pet> pet", eKind::INT, { "l", "m", "t" });
}
}
void Missions(const tinyxml2::XMLElement& mis) {
const auto& lookups = context.lookups;
const auto mission = [&](const tinyxml2::XMLElement& m, const char* where, bool done) {
if (!Required(m, where, eKind::INT, { "id" })) return;
const auto id = m.IntAttribute("id");
const std::string name = std::string(where) + " " + std::to_string(id);
if (lookups.missionExists && !lookups.missionExists(id)) Error(name + ": no such mission (the game would lose it)");
Numbers(m, name, eKind::INT, { "state" });
Numbers(m, name, eKind::UINT, { "cct", "cts", "o" });
if (m.Attribute("state") && Parses(m, "state", eKind::INT)) {
const auto state = m.IntAttribute("state");
if (!KnownMissionState(state)) Error(name + ": state " + std::to_string(state) + " is not a mission state");
else if (done && state < 8) Warn(name + " is in the completed list but its state (" + std::to_string(state) + ") is not complete");
}
if (!done) for (const auto* t = m.FirstChildElement(); t; t = t->NextSiblingElement()) Numbers(*t, name + " task", eKind::UINT, { "v" });
};
if (const auto* done = mis.FirstChildElement("done")) for (const auto* m = done->FirstChildElement(); m; m = m->NextSiblingElement()) mission(*m, "Completed mission", true);
if (const auto* cur = mis.FirstChildElement("cur")) for (const auto* m = cur->FirstChildElement(); m; m = m->NextSiblingElement()) mission(*m, "Current mission", false);
}
void Respawns(const tinyxml2::XMLElement& res) {
for (const auto* r = res.FirstChildElement("r"); r; r = r->NextSiblingElement("r")) {
Numbers(*r, "<res><r>", eKind::INT, { "w" });
Numbers(*r, "<res><r>", eKind::FLOAT, { "x", "y", "z" });
}
}
std::vector<Contraband::HeldItem> held;
};
}
inline Result Check(const std::string& xml, const Context& context) {
Result result;
Detail::Checker check{ result, context };
tinyxml2::XMLDocument doc;
if (xml.empty() || doc.Parse(xml.c_str()) != tinyxml2::XML_SUCCESS) {
check.Error(xml.empty() ? "The XML is empty" : std::string("That is not valid XML: ") + (doc.ErrorStr() ? doc.ErrorStr() : "parse error"));
return result;
}
const auto* obj = doc.FirstChildElement("obj");
if (!obj) {
check.Error("The root element must be <obj>");
return result;
}
// Loading stops at the first of these that is missing; what would have been read after it is lost when the character is saved
const auto* character = obj->FirstChildElement("char");
const auto* mf = obj->FirstChildElement("mf");
const auto* inv = obj->FirstChildElement("inv");
const auto* items = inv ? inv->FirstChildElement("items") : nullptr;
if (!character) check.Error("<obj> must have a <char> element");
if (!mf) check.Error("<obj> must have an <mf> (appearance) element");
if (!inv) check.Error("<obj> must have an <inv> element");
if (inv && !inv->FirstChildElement("bag")) check.Error("<inv> must have a <bag> element");
if (inv && (!items || !items->FirstChildElement("in"))) check.Error("<inv> must have an <items> element with at least one <in>");
if (mf) check.Mf(*mf);
int64_t uscore = -1;
if (character) {
check.Char(*character);
if (character->Attribute("ls") && Detail::Parses(*character, "ls", Detail::eKind::INT64)) uscore = character->Int64Attribute("ls");
else uscore = 0;
}
if (const auto* flags = obj->FirstChildElement("flag")) check.Flags(*flags);
if (const auto* dest = obj->FirstChildElement("dest")) check.Dest(*dest);
if (const auto* lvl = obj->FirstChildElement("lvl")) check.Level(*lvl, uscore);
if (inv && inv->FirstChildElement("bag") && items) check.Inventory(*inv);
if (const auto* pet = obj->FirstChildElement("pet")) check.Pets(*pet);
if (const auto* mis = obj->FirstChildElement("mis")) check.Missions(*mis);
if (const auto* res = obj->FirstChildElement("res")) check.Respawns(*res);
if (context.contrabandApplies) {
result.contraband = Contraband::Find(check.held, context.contraband);
for (const auto& found : result.contraband) {
const bool remove = found.entry.action == IContraband::eContrabandAction::REMOVE;
check.Warn("Contraband: " + std::to_string(found.item.count) + " of item " + std::to_string(found.item.lot) + " (id " + std::to_string(found.item.id) + ") in " +
InventoryType::InventoryTypeToString(found.item.inventory) + (remove ? " [flag and remove]" : " [flag]") + (found.entry.reason.empty() ? "" : ": " + found.entry.reason));
}
}
return result;
}
// The XML without the items with these ids (and without set proxy items whose parent is one of them), printed compactly
inline std::string RemoveItems(const std::string& xml, const std::set<LWOOBJID>& ids) {
tinyxml2::XMLDocument doc;
if (doc.Parse(xml.c_str()) != tinyxml2::XML_SUCCESS) return xml;
auto* inv = doc.FirstChildElement("obj") ? doc.FirstChildElement("obj")->FirstChildElement("inv") : nullptr;
auto* items = inv ? inv->FirstChildElement("items") : nullptr;
for (auto* in = items ? items->FirstChildElement() : nullptr; in; in = in->NextSiblingElement()) {
for (auto* i = in->FirstChildElement(); i;) {
auto* next = i->NextSiblingElement();
if (ids.contains(i->Int64Attribute("id")) || ids.contains(i->Int64Attribute("parent", LWOOBJID_EMPTY))) in->DeleteChild(i);
i = next;
}
}
tinyxml2::XMLPrinter printer(nullptr, true);
doc.Print(&printer);
return printer.CStr();
}
}