Ticket #245: xml_validation.patch

source/graphics/MapReader.cpp

@@ -358 +358 @@
     VfsPath filename_xml = pathname.ChangeExtension(L".xml");
 
     CXeromyces xmb_file;
-    if (xmb_file.Load(g_VFS, filename_xml) != PSRETURN_OK)
+    if (xmb_file.Load(g_VFS, filename_xml, "scenario") != PSRETURN_OK)
         return PSRETURN_File_ReadFailed;
 
     // Define all the relevant elements used in the XML file
@@ -463 +463 @@
     // must only assign once, so do it here
     node_idx = entity_idx = 0;
 
-    if (xmb_file.Load(g_VFS, xml_filename) != PSRETURN_OK)
+    if (xmb_file.Load(g_VFS, xml_filename, "scenario") != PSRETURN_OK)
         throw PSERROR_File_ReadFailed();
 
     // define the elements and attributes that are frequently used in the XML file,

source/graphics/MaterialManager.cpp

@@ -22 +22 @@
 #include "lib/ogl.h"
 #include "maths/MathUtil.h"
 #include "maths/Vector4D.h"
+#include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/PreprocessorWrapper.h"
@@ -35 +36 @@
     qualityLevel = 5.0;
     CFG_GET_VAL("materialmgr.quality", Float, qualityLevel);
     qualityLevel = clamp(qualityLevel, 0.0f, 10.0f);
+
+    if (!CXeromyces::AddValidator(g_VFS, "material", "art/materials/material.rng"))
+        LOGERROR(L"CMaterialManager: failed to load grammar file 'art/materials/material.rng'");
 }
 
 CMaterial CMaterialManager::LoadMaterial(const VfsPath& pathname)
@@ -47 +51 @@
         return iter->second;
 
     CXeromyces xeroFile;
-    if (xeroFile.Load(g_VFS, pathname) != PSRETURN_OK)
+    if (xeroFile.Load(g_VFS, pathname, "material") != PSRETURN_OK)
         return CMaterial();
 
     #define EL(x) int el_##x = xeroFile.GetElementID(#x)

source/graphics/ObjectBase.cpp

@@ -44 +44 @@
     m_UsedFiles.insert(pathname);
 
     CXeromyces XeroFile;
-    if (XeroFile.Load(g_VFS, pathname) != PSRETURN_OK)
+    if (XeroFile.Load(g_VFS, pathname, "actor") != PSRETURN_OK)
         return false;
 
     // Define all the elements used in the XML file

source/graphics/ObjectManager.cpp

@@ -25 +25 @@
 #include "ps/Game.h"
 #include "ps/Profile.h"
 #include "ps/Filesystem.h"
+#include "ps/XML/Xeromyces.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpTerrain.h"
 #include "simulation2/components/ICmpVisual.h"
@@ -62 +63 @@
 : m_MeshManager(meshManager), m_SkeletonAnimManager(skeletonAnimManager), m_Simulation(simulation)
 {
     RegisterFileReloadFunc(ReloadChangedFileCB, this);
+
+    if (!CXeromyces::AddValidator(g_VFS, "actor", "art/actors/actor.rng"))
+        LOGERROR(L"CObjectManager: failed to load actor grammar file 'art/actors/actor.rng'");
 }
 
 CObjectManager::~CObjectManager()

source/graphics/ParticleEmitterType.cpp

@@ -361 +361 @@
     m_Texture = g_Renderer.GetTextureManager().GetErrorTexture();
 
     CXeromyces XeroFile;
-    PSRETURN ret = XeroFile.Load(g_VFS, path);
+    PSRETURN ret = XeroFile.Load(g_VFS, path, "particle");
     if (ret != PSRETURN_OK)
         return false;
 
-    // TODO: should do some RNG schema validation
-
     // Define all the elements and attributes used in the XML file
 #define EL(x) int el_##x = XeroFile.GetElementID(#x)
 #define AT(x) int at_##x = XeroFile.GetAttributeID(#x)

source/graphics/ShaderManager.cpp

@@ -28 +28 @@
 #include "ps/Filesystem.h"
 #include "ps/PreprocessorWrapper.h"
 #include "ps/Profile.h"
+#if USE_SHADER_XML_VALIDATION
+# include "ps/XML/RelaxNG.h"
+#endif
 #include "ps/XML/Xeromyces.h"
 #include "ps/XML/XMLWriter.h"
 #include "renderer/Renderer.h"
@@ -47 +50 @@
 #if USE_SHADER_XML_VALIDATION
     {
         TIMER_ACCRUE(tc_ShaderValidation);
-        CVFSFile grammar;
-        if (grammar.Load(g_VFS, L"shaders/program.rng") != PSRETURN_OK)
-            LOGERROR(L"Failed to read grammar shaders/program.rng");
-        else
-        {
-            if (!m_Validator.LoadGrammar(grammar.GetAsString()))
-                LOGERROR(L"Failed to load grammar shaders/program.rng");
-        }
+        
+        if (!CXeromyces::AddValidator(g_VFS, "shader", "shaders/program.rng"))
+            LOGERROR(L"CShaderManager: failed to load grammar shaders/program.rng");
     }
 #endif
 
@@ -141 +139 @@
         XML_Start();
         XML_SetPrettyPrint(false);
         XML_WriteXMB(XeroFile);
-        bool ok = m_Validator.ValidateEncoded(wstring_from_utf8(name), XML_GetOutput());
+        bool ok = CXeromyces::GetValidator("shader").ValidateEncoded(wstring_from_utf8(name), XML_GetOutput());
         if (!ok)
             return false;
     }

source/graphics/ShaderManager.h

@@ -27 +27 @@
 #include "graphics/ShaderProgram.h"
 #include "graphics/ShaderTechnique.h"
 
-#if USE_SHADER_XML_VALIDATION
-# include "ps/XML/RelaxNG.h"
-#endif
-
 #include <set>
 
 /**
@@ -121 +117 @@
     typedef boost::unordered_map<VfsPath, std::set<boost::weak_ptr<CShaderProgram> > > HotloadFilesMap;
     HotloadFilesMap m_HotloadFiles;
 
-#if USE_SHADER_XML_VALIDATION
-    RelaxNGValidator m_Validator;
-#endif
-
     bool NewProgram(const char* name, const CShaderDefines& defines, CShaderProgramPtr& program);
     bool NewEffect(const char* name, const CShaderDefines& defines, CShaderTechniquePtr& tech);
 

source/graphics/TerrainProperties.cpp

@@ -48 +48 @@
 CTerrainPropertiesPtr CTerrainProperties::FromXML(const CTerrainPropertiesPtr& parent, const VfsPath& pathname)
 {
     CXeromyces XeroFile;
-    if (XeroFile.Load(g_VFS, pathname) != PSRETURN_OK)
+    if (XeroFile.Load(g_VFS, pathname, "terrain") != PSRETURN_OK)
         return CTerrainPropertiesPtr();
 
     XMBElement root = XeroFile.GetRoot();

source/graphics/TerrainTextureEntry.cpp

@@ -45 +45 @@
     ENSURE(properties);
     
     CXeromyces XeroFile;
-    if (XeroFile.Load(g_VFS, path) != PSRETURN_OK)
+    if (XeroFile.Load(g_VFS, path, "terrain_texture") != PSRETURN_OK)
     {
         LOGERROR(L"Terrain xml not found (%hs)", path.string().c_str());
         return;

source/graphics/TerrainTextureManager.cpp

@@ -30 +30 @@
 
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
+#include "ps/XML/Xeromyces.h"
 
 // Disable "'boost::algorithm::detail::is_classifiedF' : assignment operator could not be generated"
 // and "find_format_store.hpp(74) : warning C4100: 'Input' : unreferenced formal parameter"
@@ -43 +44 @@
 
 CTerrainTextureManager::CTerrainTextureManager():
     m_LastGroupIndex(0)
-{}
+{
+    if (!CXeromyces::AddValidator(g_VFS, "terrain", "art/terrains/terrain.rng"))
+        LOGERROR(L"CTerrainTextureManager: failed to load grammar file 'art/terrains/terrain.rng'");
+    if (!CXeromyces::AddValidator(g_VFS, "terrain_texture", "art/terrains/terrain_texture.rng"))
+        LOGERROR(L"CTerrainTextureManager: failed to load grammar file 'art/terrains/terrain_texture.rng'");
+}
 
 CTerrainTextureManager::~CTerrainTextureManager()
 {

source/graphics/TextureConverter.cpp

@@ -96 +96 @@
 CTextureConverter::SettingsFile* CTextureConverter::LoadSettings(const VfsPath& path) const
 {
     CXeromyces XeroFile;
-    if (XeroFile.Load(m_VFS, path) != PSRETURN_OK)
+    if (XeroFile.Load(m_VFS, path, "texture") != PSRETURN_OK)
         return NULL;
 
     // Define all the elements used in the XML file

source/gui/CGUI.cpp

@@ -923 +923 @@
     Paths.insert(Filename);
 
     CXeromyces XeroFile;
-    if (XeroFile.Load(g_VFS, Filename) != PSRETURN_OK)
+    if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
         // Fail silently
         return;
 
@@ -1347 +1347 @@
                 if (!directory.empty())
                     LOGWARNING(L"GUI: Include element found with file name (%ls) and directory name (%ls). Only the file will be processed.", filename.c_str(), directory.c_str());
 
-                Paths.insert(filename);
-
                 CXeromyces XeroIncluded;
-                if (XeroIncluded.Load(g_VFS, filename) != PSRETURN_OK)
+                if (XeroIncluded.Load(g_VFS, filename, "gui") != PSRETURN_OK)
                 {
                     LOGERROR(L"GUI: Error reading included XML: '%ls'", filename.c_str());
                     continue;
@@ -1374 +1372 @@
                     // one might use the same parts of the GUI in different situations
                     Paths.insert(*it);
                     CXeromyces XeroIncluded;
-                    if (XeroIncluded.Load(g_VFS, *it) != PSRETURN_OK)
+                    if (XeroIncluded.Load(g_VFS, *it, "gui") != PSRETURN_OK)
                     {
                         LOGERROR(L"GUI: Error reading included XML: '%ls'", (*it).string().c_str());
                         continue;

source/gui/GUIManager.cpp

@@ -58 +58 @@
     m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIManager", m_ScriptRuntime));
     m_ScriptInterface->SetCallbackData(this);
     m_ScriptInterface->LoadGlobalScripts();
+
+    if (!CXeromyces::AddValidator(g_VFS, "gui_page", "gui/gui_page.rng"))
+        LOGERROR(L"CGUIManager: failed to load GUI page grammar file 'gui/gui_page.rng'");
+    if (!CXeromyces::AddValidator(g_VFS, "gui", "gui/gui.rng"))
+        LOGERROR(L"CGUIManager: failed to load GUI XML grammar file 'gui/gui.rng'");
+
     RegisterFileReloadFunc(ReloadChangedFileCB, this);
 }
 
@@ -183 +189 @@
     page.inputs.insert(path);
 
     CXeromyces xero;
-    if (xero.Load(g_VFS, path) != PSRETURN_OK)
+    if (xero.Load(g_VFS, path, "gui_page") != PSRETURN_OK)
         // Fail silently (Xeromyces reported the error)
         return;
 

source/gui/MiniMap.cpp

@@ -38 +38 @@
 #include "ps/Game.h"
 #include "ps/Profile.h"
 #include "ps/World.h"
+#include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
@@ -70 +71 @@
     m_Clicking = false;
     m_MouseHovering = false;
     
+    // Register Relax NG validator
+    CXeromyces::AddValidator(g_VFS, "pathfinder", "simulation/data/pathfinder.rng");
+
     // Get the maximum height for unit passage in water.
     CParamNode externalParamNode;
-    CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml");
+    CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml", "pathfinder");
     const CParamNode pathingSettings = externalParamNode.GetChild("Pathfinder").GetChild("PassabilityClasses");
     if (pathingSettings.GetChild("default").IsOk() && pathingSettings.GetChild("default").GetChild("MaxWaterDepth").IsOk())
         m_ShallowPassageHeight = pathingSettings.GetChild("default").GetChild("MaxWaterDepth").ToFloat();

source/ps/GameSetup/GameSetup.cpp

@@ -1014 +1014 @@
 
     ogl_WarnIfError();
 
+    // TODO: where should this go?
+    CXeromyces::AddValidator(g_VFS, "map", "maps/scenario.rng");
+
     try
     {
         if (!Autostart(args))

source/ps/XML/RelaxNG.cpp

@@ -22 +22 @@
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
+#include "ps/Filesystem.h"
 
 #include <libxml/relaxng.h>
 #include <map>
@@ -28 +29 @@
 
 TIMER_ADD_CLIENT(xml_validation);
 
+static void relaxNGErrorHandler(void* UNUSED(userData), xmlErrorPtr error)
+{
+    // Strip a trailing newline
+    std::string message = error->message;
+    if (message.length() > 0 && message[message.length()-1] == '\n')
+        message.erase(message.length()-1);
+
+    LOGERROR(L"RelaxNGValidator: Validation %ls: %hs:%d: %hs",
+        error->level == XML_ERR_WARNING ? L"warning" : L"error",
+        error->file, error->line, message.c_str());
+}
+
 /*
  * libxml2 leaks memory when parsing schemas: https://bugzilla.gnome.org/show_bug.cgi?id=615767
  * To minimise that problem, keep a global cache of parsed schemas, so we don't
@@ -70 +83 @@
 
 bool RelaxNGValidator::LoadGrammar(const std::string& grammar)
 {
-    TIMER_ACCRUE(xml_validation);
-
     shared_ptr<RelaxNGSchema> schema;
 
     {
@@ -89 +100 @@
     }
 
     m_Schema = schema->m_Schema;
-
     if (!m_Schema)
         return false;
+
+    MD5 hash;
+    hash.Update((const u8*)grammar.c_str(), grammar.length());
+    m_Hash = hash;
+
     return true;
 }
 
-bool RelaxNGValidator::Validate(const std::wstring& filename, const std::wstring& document)
+bool RelaxNGValidator::LoadGrammarFile(const PIVFS& vfs, const VfsPath& grammarPath)
 {
+    CVFSFile file;
+    if (file.Load(vfs, grammarPath) != PSRETURN_OK)
+        return false;
+
+    return LoadGrammar(file.DecodeUTF8());
+}
+
+bool RelaxNGValidator::Validate(const std::wstring& filename, const std::wstring& document) const
+{
     std::string docutf8 = "<?xml version='1.0' encoding='utf-8'?>" + utf8_from_wstring(document);
 
     return ValidateEncoded(filename, docutf8);
 }
 
-bool RelaxNGValidator::ValidateEncoded(const std::wstring& filename, const std::string& document)
+bool RelaxNGValidator::ValidateEncoded(const std::wstring& filename, const std::string& document) const
 {
     TIMER_ACCRUE(xml_validation);
 
@@ -115 +139 @@
     xmlDocPtr doc = xmlReadMemory(document.c_str(), (int)document.size(), utf8_from_wstring(filename).c_str(), NULL, XML_PARSE_NONET);
     if (doc == NULL)
     {
-        LOGERROR(L"RelaxNGValidator: Failed to parse document");
+        LOGERROR(L"RelaxNGValidator: Failed to parse document '%ls'", filename.c_str());
         return false;
     }
 
+    bool ret = ValidateEncoded(doc);
+    xmlFreeDoc(doc);
+    return ret;
+}
+
+bool RelaxNGValidator::ValidateEncoded(xmlDocPtr doc) const
+{
     xmlRelaxNGValidCtxtPtr ctxt = xmlRelaxNGNewValidCtxt(m_Schema);
+    xmlRelaxNGSetValidStructuredErrors(ctxt, &relaxNGErrorHandler, NULL);
     int ret = xmlRelaxNGValidateDoc(ctxt, doc);
     xmlRelaxNGFreeValidCtxt(ctxt);
-    xmlFreeDoc(doc);
-
+    
     if (ret == 0)
     {
         return true;
@@ -130 +161 @@
     }
     else if (ret > 0)
     {
-        LOGERROR(L"RelaxNGValidator: Validation failed");
+        LOGERROR(L"RelaxNGValidator: Validation failed for '%hs'", doc->name);
         return false;
     }
     else
@@ -139 +170 @@
         return false;
     }
 }
+
+bool RelaxNGValidator::CanValidate() const
+{
+    return m_Schema != NULL;
+}

source/ps/XML/RelaxNG.h

@@ -18 +18 @@
 #ifndef INCLUDED_RELAXNG
 #define INCLUDED_RELAXNG
 
+#include "lib/file/vfs/vfs.h"
+#include "maths/MD5.h"
+
 typedef struct _xmlRelaxNG xmlRelaxNG;
 typedef xmlRelaxNG *xmlRelaxNGPtr;
+typedef struct _xmlDoc xmlDoc;
+typedef xmlDoc *xmlDocPtr;
 
+class IRelaxNGGrammar;
+
 class RelaxNGValidator
 {
 public:
@@ -29 +36 @@
 
     bool LoadGrammar(const std::string& grammar);
 
-    bool Validate(const std::wstring& filename, const std::wstring& document);
+    bool LoadGrammarFile(const PIVFS& vfs, const VfsPath& grammarPath);
 
-    bool ValidateEncoded(const std::wstring& filename, const std::string& document);
+    MD5 GetGrammarHash() const { return m_Hash; }
 
+    bool Validate(const std::wstring& filename, const std::wstring& document) const;
+
+    bool ValidateEncoded(const std::wstring& filename, const std::string& document) const;
+
+    bool ValidateEncoded(xmlDocPtr doc) const;
+
+    bool CanValidate() const;
+
 private:
+    MD5 m_Hash;
     xmlRelaxNGPtr m_Schema;
 };
 

source/ps/XML/tests/test_RelaxNG.h

@@ -44 +44 @@
         {
             TestLogger logger;
             TS_ASSERT(!v.Validate(L"doc", L"<bogus/>"));
-            TS_ASSERT_WSTR_CONTAINS(logger.GetOutput(), L"Parse error: doc:1: Expecting element test, got bogus");
+            TS_ASSERT_WSTR_CONTAINS(logger.GetOutput(), L"Validation error: doc:1: Expecting element test, got bogus");
         }
 
         {

source/ps/XML/Xeromyces.cpp

@@ -27 +27 @@
 #include "ps/CacheLoader.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
+#include "RelaxNG.h"
 #include "Xeromyces.h"
 
 #include <libxml/parser.h>
@@ -45 +46 @@
     // so the caching is less transparent than it should be
 }
 
+static CMutex g_ValidatorCacheLock;
+static std::map<const std::string, RelaxNGValidator> g_ValidatorCache;
 static bool g_XeromycesStarted = false;
 void CXeromyces::Startup()
 {
@@ -52 +55 @@
     xmlInitParser();
     xmlSetStructuredErrorFunc(NULL, &errorHandler);
     g_XeromycesStarted = true;
+
+    g_ValidatorCache.insert(std::make_pair("", RelaxNGValidator()));
 }
 
 void CXeromyces::Terminate()
@@ -59 +64 @@
     ENSURE(g_XeromycesStarted);
     xmlCleanupParser();
     xmlSetStructuredErrorFunc(NULL, NULL);
+    g_ValidatorCache.clear();
     g_XeromycesStarted = false;
 }
 
+bool CXeromyces::AddValidator(const PIVFS& vfs, const std::string& name, const VfsPath& grammarPath)
+{
+    ENSURE(g_XeromycesStarted);
+    
+    RelaxNGValidator validator;
+    if (!validator.LoadGrammarFile(vfs, grammarPath))
+    {
+        LOGERROR(L"CXeromyces: failed adding validator for '%ls'", grammarPath.string().c_str());
+        return false;
+    }
+    {
+        CScopeLock lock(g_ValidatorCacheLock);
+        std::map<const std::string, RelaxNGValidator>::iterator it = g_ValidatorCache.find(name);
+        if (it != g_ValidatorCache.end())
+            g_ValidatorCache.erase(it);
+        g_ValidatorCache.insert(std::make_pair(name, validator));
+    }
+    return true;
+}
+
+RelaxNGValidator& CXeromyces::GetValidator(const std::string &name)
+{
+    CScopeLock lock(g_ValidatorCacheLock);
+    if (g_ValidatorCache.find(name) == g_ValidatorCache.end())
+        return g_ValidatorCache.find("")->second;
+    return g_ValidatorCache.find(name)->second;
+}
+
 PSRETURN CXeromyces::Load(const PIVFS& vfs, const VfsPath& filename)
 {
+    return Load(vfs, filename, "");
+}
+
+PSRETURN CXeromyces::Load(const PIVFS& vfs, const VfsPath& filename, const std::string& validatorName)
+{
     ENSURE(g_XeromycesStarted);
 
     CCacheLoader cacheLoader(vfs, L".xmb");
 
+    RelaxNGValidator& validator = GetValidator(validatorName);
     VfsPath xmbPath;
-    Status ret = cacheLoader.TryLoadingCached(filename, MD5(), XMBVersion, xmbPath);
+    Status ret = cacheLoader.TryLoadingCached(filename, validator.GetGrammarHash(), XMBVersion, xmbPath);
 
     if (ret == INFO::OK)
     {
@@ -94 +134 @@
     }
 
     // XMB isn't up to date with the XML, so rebuild it
-    return ConvertFile(vfs, filename, xmbPath);
+    return ConvertFile(vfs, filename, xmbPath, validatorName);
 }
 
 bool CXeromyces::GenerateCachedXMB(const PIVFS& vfs, const VfsPath& sourcePath, VfsPath& archiveCachePath)
 {
+    return GenerateCachedXMB(vfs, sourcePath, archiveCachePath, "");
+}
+
+bool CXeromyces::GenerateCachedXMB(const PIVFS& vfs, const VfsPath& sourcePath, VfsPath& archiveCachePath, const std::string& validatorName)
+{
     CCacheLoader cacheLoader(vfs, L".xmb");
 
     archiveCachePath = cacheLoader.ArchiveCachePath(sourcePath);
 
-    return (ConvertFile(vfs, sourcePath, VfsPath("cache") / archiveCachePath) == PSRETURN_OK);
+    return (ConvertFile(vfs, sourcePath, VfsPath("cache") / archiveCachePath, validatorName) == PSRETURN_OK);
 }
 
-PSRETURN CXeromyces::ConvertFile(const PIVFS& vfs, const VfsPath& filename, const VfsPath& xmbPath)
+PSRETURN CXeromyces::ConvertFile(const PIVFS& vfs, const VfsPath& filename, const VfsPath& xmbPath, const std::string& validatorName)
 {
     CVFSFile input;
     if (input.Load(vfs, filename))
@@ -115 +160 @@
         return PSRETURN_Xeromyces_XMLOpenFailed;
     }
 
-    CStr8 filename8(CStrW(filename.string()).ToUTF8());
-    xmlDocPtr doc = xmlReadMemory((const char*)input.GetBuffer(), (int)input.GetBufferSize(),
-        filename8.c_str(), NULL, XML_PARSE_NONET|XML_PARSE_NOCDATA);
-    if (! doc)
+    xmlDocPtr doc = xmlReadMemory((const char*)input.GetBuffer(), input.GetBufferSize(), CStrW(filename.string()).ToUTF8().c_str(), NULL,
+        XML_PARSE_NONET|XML_PARSE_NOCDATA);
+    if (!doc)
     {
         LOGERROR(L"CXeromyces: Failed to parse XML file %ls", filename.string().c_str());
         return PSRETURN_Xeromyces_XMLParseError;
     }
 
+    RelaxNGValidator& validator = GetValidator(validatorName);
+    if (validator.CanValidate() && !validator.ValidateEncoded(doc))
+    {
+        // For now, log the error and continue, in the future we might fail
+        LOGERROR(L"CXeromyces: failed to validate XML file %ls", filename.string().c_str());
+    }
+
     WriteBuffer writeBuffer;
     CreateXMB(doc, writeBuffer);
 
@@ -162 +213 @@
 
 PSRETURN CXeromyces::LoadString(const char* xml)
 {
+    return LoadString(xml, "");
+}
+
+PSRETURN CXeromyces::LoadString(const char* xml, const std::string& validatorName)
+{
     ENSURE(g_XeromycesStarted);
 
-    xmlDocPtr doc = xmlReadMemory(xml, (int)strlen(xml), "", NULL, XML_PARSE_NONET|XML_PARSE_NOCDATA);
-    if (! doc)
+    xmlDocPtr doc = xmlReadMemory(xml, (int)strlen(xml), "(no file)", NULL, XML_PARSE_NONET|XML_PARSE_NOCDATA);
+    if (!doc)
     {
         LOGERROR(L"CXeromyces: Failed to parse XML string");
         return PSRETURN_Xeromyces_XMLParseError;
     }
 
+    RelaxNGValidator& validator = GetValidator(validatorName);
+    if (validator.CanValidate() && !validator.ValidateEncoded(doc))
+    {
+        // For now, log the error and continue, in the future we might fail
+        LOGERROR(L"CXeromyces: failed to validate XML string");
+    }
+
     WriteBuffer writeBuffer;
     CreateXMB(doc, writeBuffer);
 

source/ps/XML/Xeromyces.h

@@ -33 +33 @@
 
 #include "lib/file/vfs/vfs.h"
 
+class RelaxNGValidator;
 class WriteBuffer;
-class MD5;
 
 typedef struct _xmlDoc xmlDoc;
 typedef xmlDoc* xmlDocPtr;
@@ -47 +47 @@
      * Load from an XML file (with invisible XMB caching).
      */
     PSRETURN Load(const PIVFS& vfs, const VfsPath& filename);
+    PSRETURN Load(const PIVFS& vfs, const VfsPath& filename, const std::string& validatorName);
 
     /**
      * Load from an in-memory XML string (with no caching).
      */
     PSRETURN LoadString(const char* xml);
+    PSRETURN LoadString(const char* xml, const std::string& validatorName);
 
     /**
      * Convert the given XML file into an XMB in the archive cache.
@@ -59 +61 @@
      * Returns false on error.
      */
     bool GenerateCachedXMB(const PIVFS& vfs, const VfsPath& sourcePath, VfsPath& archiveCachePath);
+    bool GenerateCachedXMB(const PIVFS& vfs, const VfsPath& sourcePath, VfsPath& archiveCachePath, const std::string& validatorName);
 
     /**
      * Call once when initialising the program, to load libxml2.
@@ -71 +74 @@
      */
     static void Terminate();
 
+    static bool AddValidator(const PIVFS& vfs, const std::string& name, const VfsPath& grammarPath);
+
+    static RelaxNGValidator& GetValidator(const std::string& name);
+
 private:
-    PSRETURN ConvertFile(const PIVFS& vfs, const VfsPath& filename, const VfsPath& xmbPath);
+    PSRETURN ConvertFile(const PIVFS& vfs, const VfsPath& filename, const VfsPath& xmbPath, const std::string& validatorName);
 
     bool ReadXMBFile(const PIVFS& vfs, const VfsPath& filename);
 

source/simulation2/components/CCmpPathfinder.cpp

@@ -27 +27 @@
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/Profile.h"
+#include "ps/XML/Xeromyces.h"
 #include "renderer/Scene.h"
 #include "simulation2/MessageTypes.h"
 #include "simulation2/components/ICmpObstruction.h"
@@ -56 +57 @@
 
     m_SameTurnMovesCount = 0;
 
+    // Register Relax NG validator
+    CXeromyces::AddValidator(g_VFS, "pathfinder", "simulation/data/pathfinder.rng");
+
     // Since this is used as a system component (not loaded from an entity template),
     // we can't use the real paramNode (it won't get handled properly when deserializing),
     // so load the data from a special XML file.
     CParamNode externalParamNode;
-    CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml");
+    CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml", "pathfinder");
 
     // Previously all move commands during a turn were
     // queued up and processed asynchronously at the start

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -27 +27 @@
 #include "maths/MathUtil.h"
 #include "maths/Vector2D.h"
 #include "ps/Overlay.h"
+#include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "renderer/Scene.h"
 #include "renderer/TerrainOverlay.h"
@@ -123 +124 @@
 
         m_AnimTime = 0.0;
 
+        // Register Relax NG validator
+        CXeromyces::AddValidator(g_VFS, "territorymanager", "simulation/data/territorymanager.rng");
+
         CParamNode externalParamNode;
-        CParamNode::LoadXML(externalParamNode, L"simulation/data/territorymanager.xml");
+        CParamNode::LoadXML(externalParamNode, L"simulation/data/territorymanager.xml", "territorymanager");
 
         int impassableCost = externalParamNode.GetChild("TerritoryManager").GetChild("ImpassableCost").ToInt();
         ENSURE(0 <= impassableCost && impassableCost <= 255);

source/simulation2/system/ParamNode.cpp

@@ -47 +47 @@
     ret.ApplyLayer(xmb, xmb.GetRoot(), sourceIdentifier);
 }
 
-void CParamNode::LoadXML(CParamNode& ret, const VfsPath& path)
+void CParamNode::LoadXML(CParamNode& ret, const VfsPath& path, const std::string& validatorName)
 {
     CXeromyces xero;
-    PSRETURN ok = xero.Load(g_VFS, path);
+    PSRETURN ok = xero.Load(g_VFS, path, validatorName);
     if (ok != PSRETURN_OK)
         return; // (Xeromyces already logged an error)
 

source/simulation2/system/ParamNode.h

@@ -134 +134 @@
      * Any existing data in @a ret will be overwritten or else kept, so this
      * can be called multiple times to build up a node from multiple inputs.
      */
-    static void LoadXML(CParamNode& ret, const VfsPath& path);
+    static void LoadXML(CParamNode& ret, const VfsPath& path, const std::string& validatorName);
 
     /**
      * See LoadXML, but parses the XML string @a xml.

source/soundmanager/scripting/SoundGroup.cpp

@@ -283 +283 @@
 bool CSoundGroup::LoadSoundGroup(const VfsPath& pathnameXML)
 {
     CXeromyces XeroFile;
-    if (XeroFile.Load(g_VFS, pathnameXML) != PSRETURN_OK)
+    if (XeroFile.Load(g_VFS, pathnameXML, "sound_group") != PSRETURN_OK)
     {
         HandleError(L"error loading file", pathnameXML, ERR::FAIL);
         return false;

source/soundmanager/SoundManager.cpp

@@ -29 +29 @@
 #include "ps/CStr.h"
 #include "ps/Filesystem.h"
 #include "ps/Profiler2.h"
+#include "ps/XML/Xeromyces.h"
 
 ISoundManager* g_SoundManager = NULL;
 
@@ -266 +267 @@
         m_PlayListItems = new PlayList;
     }
 
+    if (!CXeromyces::AddValidator(g_VFS, "sound_group", "audio/sound_group.rng"))
+        LOGERROR(L"CSoundManager: failed to load grammar file 'audio/sound_group.rng'");
+
     RegisterFileReloadFunc(ReloadChangedFileCB, this);
 }