replaced boost by manual xml writing, to improve serialization perfs

src/libs/core/impl/String.cpp

@@ -44,10 +44,20 @@ namespace lms::core::stringUtils
 
         constexpr std::pair<char, std::string_view> jsonEscapeChars[]{
             { '\\', "\\\\" },
+            { '"', "\\\"" },
+            { '\b', "\\b" },
+            { '\f', "\\f" },
             { '\n', "\\n" },
             { '\r', "\\r" },
             { '\t', "\\t" },
-            { '"', "\\\"" },
+        };
+
+        constexpr std::pair<char, std::string_view> xmlEscapeChars[]{
+            { '&', "&amp;" },
+            { '<', "&lt;" },
+            { '>', "&gt;" },
+            { '\'', "&apos;" },
+            { '"', "&quot;" },
         };
 
         template<std::size_t N>
@@ -442,6 +452,16 @@ namespace lms::core::stringUtils
         details::writeEscapedString(os, str, details::jsonEscapeChars);
     }
 
+    std::string xmlEscape(std::string_view str)
+    {
+        return details::escape(str, details::xmlEscapeChars);
+    }
+
+    void writeXmlEscapedString(std::ostream& os, std::string_view str)
+    {
+        details::writeEscapedString(os, str, details::xmlEscapeChars);
+    }
+
     std::string escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar)
     {
         std::string res;

src/libs/core/include/core/String.hpp

@@ -105,6 +105,9 @@ namespace lms::core::stringUtils
     void writeJSEscapedString(std::ostream& os, std::string_view str);
     void writeJsonEscapedString(std::ostream& os, std::string_view str);
 
+    [[nodiscard]] std::string xmlEscape(std::string_view str);
+    void writeXmlEscapedString(std::ostream& os, std::string_view str);
+
     [[nodiscard]] std::string escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar);
     [[nodiscard]] std::string unescapeString(std::string_view str, char escapeChar);
 

src/libs/core/test/String.cpp

@@ -221,6 +221,27 @@ namespace lms::core::stringUtils::tests
         EXPECT_EQ(jsonEscape(R"(Test'.mp3)"), R"(Test'.mp3)");
         EXPECT_EQ(jsonEscape(R"(Test"".mp3)"), R"(Test\"\".mp3)");
         EXPECT_EQ(jsonEscape(R"(\Test\.mp3)"), R"(\\Test\\.mp3)");
+        EXPECT_EQ(jsonEscape("Line1\nLine2"), R"(Line1\nLine2)");
+        EXPECT_EQ(jsonEscape("Line1\rLine2"), R"(Line1\rLine2)");
+        EXPECT_EQ(jsonEscape("Col1\tCol2"), R"(Col1\tCol2)");
+        EXPECT_EQ(jsonEscape("Hello\bWorld"), R"(Hello\bWorld)");
+        EXPECT_EQ(jsonEscape("Hello\fWorld"), R"(Hello\fWorld)");
+        EXPECT_EQ(jsonEscape("Hello\nWorld"), R"(Hello\nWorld)");
+    }
+
+    TEST(StringUtils, escapeXmlString)
+    {
+        EXPECT_EQ(xmlEscape(""), "");
+        EXPECT_EQ(xmlEscape("Test.mp3"), "Test.mp3");
+        EXPECT_EQ(xmlEscape("A & B"), "A & B");
+        EXPECT_EQ(xmlEscape("<tag>"), "&lt;tag&gt;");
+        EXPECT_EQ(xmlEscape(R"(He said "Hello")"), "He said &quot;Hello&quot;");
+        EXPECT_EQ(xmlEscape("It's fine"), "It&apos;s fine");
+        EXPECT_EQ(xmlEscape(R"(<tag attr="val & val2">O'Hara</tag>)"), "&lt;tag attr=&quot;val &amp; val2&quot;&gt;O&apos;Hara&lt;/tag&gt;");
+        EXPECT_EQ(xmlEscape(R"(\Test\.mp3)"), R"(\Test\.mp3)");
+        EXPECT_EQ(xmlEscape("Café & Tea"), "Café &amp; Tea");
+        EXPECT_EQ(xmlEscape(R"(&<>'")"), "&amp;&lt;&gt;&apos;&quot;");
+        EXPECT_EQ(xmlEscape("Line1\nLine2"), "Line1\nLine2");
     }
 
     TEST(StringUtils, escapeString)

src/libs/subsonic/CMakeLists.txt

@@ -64,6 +64,10 @@ target_link_libraries(lmssubsonic PUBLIC
 	Wt::Wt
 	)
 
+if(BUILD_TESTING)
+	add_subdirectory(test)
+endif()
+
 if (BUILD_BENCHMARKS)
        add_subdirectory(bench)
 endif()

src/libs/subsonic/impl/SubsonicResponse.cpp

@@ -23,9 +23,8 @@
 #include <climits>
 #include <cmath>
 
-#include <boost/property_tree/xml_parser.hpp>
-
 #include "core/String.hpp"
+#include "core/Utils.hpp"
 #include "core/Version.hpp"
 
 #include "ProtocolVersion.hpp"
@@ -113,133 +112,90 @@ namespace lms::api::subsonic
         setAttribute("version", std::to_string(protocolVersion.major) + "." + std::to_string(protocolVersion.minor) + "." + std::to_string(protocolVersion.patch));
     }
 
-    Response Response::createOkResponse(ProtocolVersion protocolVersion)
+    void Response::XmlSerializer::serializeNode(std::ostream& os, const Node& node, std::string_view tagName)
     {
-        return createResponseCommon(protocolVersion);
+        // Opening tag
+        os << '<' << tagName;
+
+        // Attributes
+        for (const auto& [key, value] : node._attributes)
+        {
+            os << ' ' << key.str() << '=';
+            os << '"';
+            serializeValue(os, value);
+            os << '"';
         }
 
-    Response Response::createFailedResponse(ProtocolVersion protocolVersion, const Error& error)
+        // Hack
+        if (tagName == "subsonic-response")
+            os << " xmlns=\"http://subsonic.org/restapi\"";
+
+        bool hasChildren = !node._children.empty() || !node._childrenArrays.empty() || !node._childrenValues.empty();
+        bool hasValue = node._value.has_value();
+
+        if (!hasChildren && !hasValue)
         {
-        return createResponseCommon(protocolVersion, &error);
+            os << "/>"; // Self-closing tag
+            return;
         }
 
-    Response Response::createResponseCommon(ProtocolVersion protocolVersion, const Error* error)
+        os << '>'; // End opening tag
-    {
-        Response response;
-        Node& responseNode{ response._root.createChild("subsonic-response") };
 
-        responseNode.setAttribute("status", error ? "failed" : "ok");
+        // Node value (text content)
-        responseNode.setVersionAttribute(protocolVersion);
+        if (hasValue)
+            serializeValue(os, *node._value);
 
-        if (error)
+        // Child nodes
+        for (const auto& [key, childNode] : node._children)
+            serializeNode(os, childNode, key.str());
+
+        // Child arrays
+        for (const auto& [key, childArrayNodes] : node._childrenArrays)
+            for (const Node& childNode : childArrayNodes)
+                serializeNode(os, childNode, key.str());
+
+        // Array values
+        for (const auto& [key, childValues] : node._childrenValues)
         {
-            Node& errorNode{ responseNode.createChild("error") };
+            for (const Node::ValueType& value : childValues)
-            errorNode.setAttribute("code", static_cast<int>(error->getCode()));
+            {
-            errorNode.setAttribute("message", error->getMessage());
+                os << '<' << key.str() << '>';
+                serializeValue(os, value);
+                os << "</" << key.str() << '>';
+            }
         }
 
-        // OpenSubsonic mandatory fields
+        // Closing tag
-        // No big deal to send them even for legacy clients
+        os << "</" << tagName << '>';
-        responseNode.setAttribute("type", "lms");
-        responseNode.setAttribute("serverVersion", core::getVersion());
-        responseNode.setAttribute("openSubsonic", true);
-
-        return response;
     }
 
-    void Response::addNode(Node::Key key, Node&& node)
+    void Response::XmlSerializer::serializeValue(std::ostream& os, const Node::ValueType& value)
     {
-        return _root._children["subsonic-response"].addChild(key, std::move(node));
+        std::visit(core::utils::overloads{
+                       [&](const Node::string& str) { core::stringUtils::writeXmlEscapedString(os, str); },
+                       [&](bool value) { os << (value ? "true" : "false"); },
+                       [&](float value) { os << value; },
+                       [&](long long value) { os << value; } },
+            value);
     }
 
-    Response::Node& Response::createNode(Node::Key key)
+    void Response::XmlSerializer::serializeEscapedString(std::ostream& os, std::string_view str)
     {
-        return _root._children["subsonic-response"].createChild(key);
+        core::stringUtils::writeXmlEscapedString(os, str);
-    }
-
-    Response::Node& Response::createArrayNode(Node::Key key)
-    {
-        return _root._children["subsonic-response"].createArrayChild(key);
-    }
-
-    void Response::write(std::ostream& os, ResponseFormat format) const
-    {
-        switch (format)
-        {
-        case ResponseFormat::xml:
-            writeXML(os);
-            break;
-        case ResponseFormat::json:
-            writeJSON(os);
-            break;
-        }
     }
 
     void Response::writeXML(std::ostream& os) const
     {
-        std::function<boost::property_tree::ptree(const Node&)> nodeToPropertyTree = [&](const Node& node) {
+        os << R"(<?xml version="1.0" encoding="utf-8"?>)" << '\n';
-            boost::property_tree::ptree res;
 
-            auto valueToPropertyTree = [](const Node::ValueType& value) {
+        XmlSerializer serializer;
-                boost::property_tree::ptree res;
-                std::visit([&](const auto& rawValue) {
-                    using RawValueType = std::decay_t<decltype(rawValue)>;
-                    if constexpr (std::is_same_v<RawValueType, Node::string>)
-                        res.put_value(core::stringUtils::replaceInString(rawValue, "\n", "\\n"));
-                    else
-                        res.put_value(rawValue);
-                },
-                    value);
 
-                return res;
+        assert(_root._children.size() == 1);
-            };
+        if (_root._children.size() == 1)
-
-            if (node._value)
         {
-                res = valueToPropertyTree(*node._value);
+            const auto& [tagName, node] = *_root._children.begin();
+            serializer.serializeNode(os, node, tagName.str());
         }
-            else
-            {
-                for (const auto& [key, childNode] : node._children)
-                {
-                    boost::property_tree::ptree& tree{ res.add_child(std::string{ key.str() }, nodeToPropertyTree(childNode)) };
-                    // Hardcoded attribute to simplify createOkResponse calls
-                    if (key == "subsonic-response")
-                        tree.put("<xmlattr>.xmlns", "http://subsonic.org/restapi");
-                }
-
-                for (const auto& [key, childArrayNodes] : node._childrenArrays)
-                {
-                    for (const Node& childNode : childArrayNodes)
-                        res.add_child(std::string{ key.str() }, nodeToPropertyTree(childNode));
-                }
-
-                for (const auto& [key, childArrayValues] : node._childrenValues)
-                {
-                    for (const Response::Node::ValueType& value : childArrayValues)
-                        res.add_child(std::string{ key.str() }, valueToPropertyTree(value));
-                }
-            }
-
-            for (const auto& [key, value] : node._attributes)
-            {
-                if (std::holds_alternative<Node::string>(value))
-                    res.put("<xmlattr>." + std::string{ key.str() }, std::get<Node::string>(value));
-                else if (std::holds_alternative<bool>(value))
-                    res.put("<xmlattr>." + std::string{ key.str() }, std::get<bool>(value));
-                else if (std::holds_alternative<float>(value))
-                    res.put("<xmlattr>." + std::string{ key.str() }, std::get<float>(value));
-                else if (std::holds_alternative<long long>(value))
-                    res.put("<xmlattr>." + std::string{ key.str() }, std::get<long long>(value));
-                else
-                    assert(false);
-            }
-
-            return res;
-        };
-
-        const boost::property_tree::ptree root{ nodeToPropertyTree(_root) };
-        boost::property_tree::write_xml(os, root);
     }
 
     void Response::JsonSerializer::serializeNode(std::ostream& os, const Response::Node& node)
@@ -325,30 +281,18 @@ namespace lms::api::subsonic
 
     void Response::JsonSerializer::serializeValue(std::ostream& os, const Node::ValueType& value)
     {
-        if (std::holds_alternative<Node::string>(value))
+        std::visit(
-        {
+            core::utils::overloads{
-            serializeEscapedString(os, std::get<Node::string>(value));
+                [&](const Node::string& str) { serializeEscapedString(os, str); },
-        }
+                [&](bool value) { os << (value ? "true" : "false"); },
-        else if (std::holds_alternative<bool>(value))
+                [&](float value) {
-        {
+                    if (std::isnan(value) || std::fabs(value) == std::numeric_limits<float>::infinity())
-            os << (std::get<bool>(value) ? "true" : "false");
-        }
-        else if (std::holds_alternative<float>(value))
-        {
-            const float d{ std::get<float>(value) };
-            if (std::isnan(d) || std::fabs(d) == std::numeric_limits<float>::infinity())
                         os << "null";
                     else
-                os << d;
+                        os << value;
-        }
+                },
-        else if (std::holds_alternative<long long>(value))
+                [&](long long value) { os << value; } },
-        {
+            value);
-            os << std::get<long long>(value);
-        }
-        else
-        {
-            assert(false);
-        }
     }
 
     void Response::JsonSerializer::serializeEscapedString(std::ostream& os, std::string_view str)
@@ -358,6 +302,68 @@ namespace lms::api::subsonic
         os << '\"';
     }
 
+    Response Response::createOkResponse(ProtocolVersion protocolVersion)
+    {
+        return createResponseCommon(protocolVersion);
+    }
+
+    Response Response::createFailedResponse(ProtocolVersion protocolVersion, const Error& error)
+    {
+        return createResponseCommon(protocolVersion, &error);
+    }
+
+    Response Response::createResponseCommon(ProtocolVersion protocolVersion, const Error* error)
+    {
+        Response response;
+        Node& responseNode{ response._root.createChild("subsonic-response") };
+
+        responseNode.setAttribute("status", error ? "failed" : "ok");
+        responseNode.setVersionAttribute(protocolVersion);
+
+        if (error)
+        {
+            Node& errorNode{ responseNode.createChild("error") };
+            errorNode.setAttribute("code", static_cast<int>(error->getCode()));
+            errorNode.setAttribute("message", error->getMessage());
+        }
+
+        // OpenSubsonic mandatory fields
+        // No big deal to send them even for legacy clients
+        responseNode.setAttribute("type", "lms");
+        responseNode.setAttribute("serverVersion", core::getVersion());
+        responseNode.setAttribute("openSubsonic", true);
+
+        return response;
+    }
+
+    void Response::addNode(Node::Key key, Node&& node)
+    {
+        return _root._children["subsonic-response"].addChild(key, std::move(node));
+    }
+
+    Response::Node& Response::createNode(Node::Key key)
+    {
+        return _root._children["subsonic-response"].createChild(key);
+    }
+
+    Response::Node& Response::createArrayNode(Node::Key key)
+    {
+        return _root._children["subsonic-response"].createArrayChild(key);
+    }
+
+    void Response::write(std::ostream& os, ResponseFormat format) const
+    {
+        switch (format)
+        {
+        case ResponseFormat::xml:
+            writeXML(os);
+            break;
+        case ResponseFormat::json:
+            writeJSON(os);
+            break;
+        }
+    }
+
     void Response::writeJSON(std::ostream& os) const
     {
         JsonSerializer serializer;

src/libs/subsonic/impl/SubsonicResponse.hpp

@@ -57,6 +57,11 @@ namespace lms::api::subsonic
         Error(Code code)
             : _code{ code } {}
 
+        virtual ~Error() = default;
+
+        Error(const Error&) = delete;
+        Error& operator=(const Error&) = delete;
+
         virtual std::string getMessage() const = 0;
 
         Code getCode() const { return _code; }
@@ -318,8 +323,16 @@ namespace lms::api::subsonic
         {
         public:
             void serializeNode(std::ostream& os, const Node& node);
-            void serializeValue(std::ostream& os, const Node::ValueType& value);
+            static void serializeValue(std::ostream& os, const Node::ValueType& value);
-            void serializeEscapedString(std::ostream&, std::string_view str);
+            static void serializeEscapedString(std::ostream&, std::string_view str);
+        };
+
+        class XmlSerializer
+        {
+        public:
+            void serializeNode(std::ostream& os, const Node& node, std::string_view tagName);
+            static void serializeValue(std::ostream& os, const Node::ValueType& value);
+            static void serializeEscapedString(std::ostream&, std::string_view str);
         };
 
         void writeJSON(std::ostream& os) const;

src/libs/subsonic/test/CMakeLists.txt

@@ -0,0 +1,20 @@
+include(GoogleTest)
+
+add_executable(test-subsonic
+	SubsonicResponseTest.cpp
+	)
+
+target_include_directories(test-subsonic PRIVATE
+	../impl
+	)
+
+target_link_libraries(test-subsonic PRIVATE
+	lmscore
+	lmssubsonic
+	GTest::GTest
+	)
+
+if (NOT CMAKE_CROSSCOMPILING)
+	gtest_discover_tests(test-subsonic)
+endif()
+

src/libs/subsonic/test/SubsonicResponseTest.cpp

@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2025 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sstream>
+
+#include <gtest/gtest.h>
+
+#include "ProtocolVersion.hpp"
+#include "SubsonicResponse.hpp"
+
+namespace lms::api::subsonic::tests
+{
+    namespace
+    {
+        Response generateFakeResponse()
+        {
+            Response response{ Response::createOkResponse(defaultServerProtocolVersion) };
+
+            Response::Node& node{ response.createNode("MyNode") };
+            node.setAttribute("Attr1", "value1");
+            node.setAttribute("Attr2", "value2");
+            node.setAttribute("attr3", "<value3=\"foo\">");
+            node.setAttribute("attr4", true);
+            node.setAttribute("attr5", false);
+            node.setAttribute("attr6", 3.14159265359);
+            node.setAttribute("attr7", 333666);
+
+            for (std::size_t i{}; i < 2; ++i)
+            {
+                Response::Node& childNode{ node.createArrayChild("MyArrayChild") };
+                childNode.setAttribute("Attr42", i);
+
+                node.addArrayValue("MyArray1", "value1");
+                node.addArrayValue("MyArray1", "value2");
+                for (std::size_t j{}; j < i; ++j)
+                    node.addArrayValue("MyArray2", j);
+            }
+
+            return response;
+        }
+    } // namespace
+
+    TEST(SubsonicResponse, emptyJson)
+    {
+        Response response{ Response::createOkResponse(ProtocolVersion{ 1, 16, 0 }) };
+
+        std::ostringstream oss;
+        response.write(oss, ResponseFormat::json);
+
+        EXPECT_EQ(oss.str(), R"({"subsonic-response":{"openSubsonic":true,"serverVersion":"v3.70.0","status":"ok","type":"lms","version":"1.16.0"}})");
+    }
+
+    TEST(SubsonicResponse, json)
+    {
+        Response response{ generateFakeResponse() };
+
+        std::ostringstream oss;
+        response.write(oss, ResponseFormat::json);
+
+        EXPECT_EQ(oss.str(), R"({"subsonic-response":{"openSubsonic":true,"serverVersion":"v3.70.0","status":"ok","type":"lms","version":"1.16.0","MyNode":{"Attr1":"value1","Attr2":"value2","attr3":"<value3=\"foo\">","attr4":true,"attr5":false,"attr6":3.14159,"attr7":333666,"MyArrayChild":[{"Attr42":0},{"Attr42":1}],"MyArray1":["value1","value2","value1","value2"],"MyArray2":[0]}}})");
+    }
+
+    TEST(SubsonicResponse, emptyXml)
+    {
+        Response response{ Response::createOkResponse(ProtocolVersion{ 1, 16, 0 }) };
+
+        std::ostringstream oss;
+        response.write(oss, ResponseFormat::xml);
+
+        EXPECT_EQ(oss.str(), R"(<?xml version="1.0" encoding="utf-8"?>
+<subsonic-response openSubsonic="true" serverVersion="v3.70.0" status="ok" type="lms" version="1.16.0" xmlns="http://subsonic.org/restapi"/>)");
+    }
+
+    TEST(SubsonicResponse, xml)
+    {
+        Response response{ generateFakeResponse() };
+
+        std::ostringstream oss;
+        response.write(oss, ResponseFormat::xml);
+
+        EXPECT_EQ(oss.str(), R"(<?xml version="1.0" encoding="utf-8"?>
+<subsonic-response openSubsonic="true" serverVersion="v3.70.0" status="ok" type="lms" version="1.16.0" xmlns="http://subsonic.org/restapi"><MyNode Attr1="value1" Attr2="value2" attr3="&lt;value3=&quot;foo&quot;&gt;" attr4="true" attr5="false" attr6="3.14159" attr7="333666"><MyArrayChild Attr42="0"/><MyArrayChild Attr42="1"/><MyArray1>value1</MyArray1><MyArray1>value2</MyArray1><MyArray1>value1</MyArray1><MyArray1>value2</MyArray1><MyArray2>0</MyArray2></MyNode></subsonic-response>)");
+    }
+
+} // namespace lms::api::subsonic::tests
+
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}