Merge commit '40c6fe0d026ca10fc83bd8bf6691f38c6618cdf2' into installer

Lauris Kaplinski · Lauris Kaplinski · commit 6c2f0272fd4a · 2026-03-09T13:22:56.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -64,7 +64,7 @@ if(LIBCDOC_WITH_DOCS)
             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
             COMMENT "Generating API documentation with Doxygen" VERBATIM
         )
-        install(DIRECTORY ${CMAKE_BINARY_DIR}/doc/ DESTINATION ${CMAKE_INSTALL_DOCDIR})
+        install(DIRECTORY ${PROJECT_BINARY_DIR}/doc/ DESTINATION ${CMAKE_INSTALL_DOCDIR})
         install(DIRECTORY doc/ DESTINATION ${CMAKE_INSTALL_DOCDIR})
     endif()
 endif()
diff --git a/cdoc/CDoc1Writer.cpp b/cdoc/CDoc1Writer.cpp
@@ -18,6 +18,7 @@
 
 #include "CDoc1Writer.h"
 
+#include "Certificate.h"
 #include "Crypto.h"
 #include "DDocWriter.h"
 #include "Recipient.h"
@@ -119,27 +120,10 @@ int64_t CDoc1Writer::Private::writeDocument(bool use_ddoc, const std::vector<Rec
 int64_t CDoc1Writer::Private::writeRecipient(const std::vector<uint8_t> &recipient, const Crypto::Key& transportKey)
 {
     auto peerCert = Crypto::toX509(recipient);
-	if(!peerCert)
+    if(!peerCert)
         return UNSPECIFIED_ERROR;
-	std::string cn = [&]{
-		std::string cn;
-		X509_NAME *name = X509_get_subject_name(peerCert.get());
-		if(!name)
-			return cn;
-		int pos = X509_NAME_get_index_by_NID(name, NID_commonName, 0);
-		if(pos == -1)
-			return cn;
-		X509_NAME_ENTRY *e = X509_NAME_get_entry(name, pos);
-		if(!e)
-			return cn;
-		char *data = nullptr;
-		int size = ASN1_STRING_to_UTF8((uint8_t**)&data, X509_NAME_ENTRY_get_data(e));
-
-		cn.assign(data, size_t(size));
-		OPENSSL_free(data);
-		return cn;
-	}();
-    return writeElement(DENC, "EncryptedKey", {{"Recipient", cn}}, [&] -> int64_t {
+    return writeElement(DENC, "EncryptedKey",
+            {{"Recipient", Certificate::getName(peerCert.get(), NID_commonName)}}, [&] -> int64_t {
 		std::vector<uint8_t> encryptedData;
 		auto *peerPKey = X509_get0_pubkey(peerCert.get());
 		switch(EVP_PKEY_base_id(peerPKey))
@@ -169,18 +153,19 @@ int64_t CDoc1Writer::Private::writeRecipient(const std::vector<uint8_t> &recipie
             oid.resize(size_t(OBJ_obj2txt(oid.data(), int(oid.size()), obj.get(), 1)));
             std::vector<uint8_t> SsDer = Crypto::toPublicKeyDer(ephKey.get());
 
-			std::string encryptionMethod(libcdoc::Crypto::KWAES256_MTH);
-			std::string concatDigest = libcdoc::Crypto::SHA384_MTH;
-			switch ((SsDer.size() - 1) / 2) {
-			case 32: concatDigest = libcdoc::Crypto::SHA256_MTH; break;
-			case 48: concatDigest = libcdoc::Crypto::SHA384_MTH; break;
-			default: concatDigest = libcdoc::Crypto::SHA512_MTH; break;
-			}
+            std::string encryptionMethod(libcdoc::Crypto::KWAES256_MTH);
+            const std::string &concatDigest = [&] -> const std::string & {
+                switch ((SsDer.size() - 1) / 2) {
+                case 32: return libcdoc::Crypto::SHA256_MTH; break;
+                case 48: return libcdoc::Crypto::SHA384_MTH; break;
+                default: return libcdoc::Crypto::SHA512_MTH; break;
+                }
+            }();
 
-			std::vector<uint8_t> AlgorithmID(documentFormat.cbegin(), documentFormat.cend());
-			std::vector<uint8_t> encryptionKey = libcdoc::Crypto::concatKDF(concatDigest, libcdoc::Crypto::keySize(encryptionMethod), sharedSecret,
-				AlgorithmID, SsDer, recipient);
-			encryptedData = libcdoc::Crypto::AESWrap(encryptionKey, transportKey.key, true);
+            std::vector<uint8_t> AlgorithmID(documentFormat.cbegin(), documentFormat.cend());
+            std::vector<uint8_t> encryptionKey = libcdoc::Crypto::concatKDF(concatDigest,
+                libcdoc::Crypto::keySize(encryptionMethod), sharedSecret, AlgorithmID, SsDer, recipient);
+            encryptedData = libcdoc::Crypto::AESWrap(encryptionKey, transportKey.key, true);
 
             LOG_TRACE_KEY("Ss {}", SsDer);
             LOG_TRACE_KEY("Ksr {}", sharedSecret);
@@ -197,25 +182,25 @@ int64_t CDoc1Writer::Private::writeRecipient(const std::vector<uint8_t> &recipie
                             {"PartyUInfo", "00" + toHex(SsDer)},
                             {"PartyVInfo", "00" + toHex(recipient)}}, [&] {
                             return writeElement(DS, "DigestMethod", {{"Algorithm", concatDigest}});
-						});
+                        });
                     }));
                     RET_ERROR(writeElement(DENC, "OriginatorKeyInfo", [&] {
                         return writeElement(DS, "KeyValue", [&] {
                             return writeElement(DSIG11, "ECKeyValue", [&] {
                                 RET_ERROR(writeElement(DSIG11, "NamedCurve", {{"URI", "urn:oid:" + oid}}));
                                 return writeBase64Element(DSIG11, "PublicKey", SsDer);
-							});
-						});
+                            });
+                        });
                     }));
                     return writeElement(DENC, "RecipientKeyInfo", [&] {
                         return writeElement(DS, "X509Data", [&] {
                             return writeBase64Element(DS, "X509Certificate", recipient);
-						});
-					});
-				});
+                        });
+                    });
+                });
             }));
-			break;
-		}
+            break;
+        }
         default:
             return UNSPECIFIED_ERROR;
         }
@@ -224,8 +209,8 @@ int64_t CDoc1Writer::Private::writeRecipient(const std::vector<uint8_t> &recipie
             return UNSPECIFIED_ERROR;
         return writeElement(DENC, "CipherData", [&] {
             return writeBase64Element(DENC, "CipherValue", encryptedData);
-		});
-	});
+        });
+    });
 }
 
 /**
diff --git a/cdoc/CDocCipher.h b/cdoc/CDocCipher.h
@@ -23,6 +23,7 @@
 #include "CDocWriter.h"
 #include "RcptInfo.h"
 #include "ToolConf.h"
+#include "Exports.h"
 
 #include <map>
 #include <memory>
@@ -31,7 +32,7 @@ namespace libcdoc
 {
 
 
-class CDocCipher
+class CDOC_EXPORT CDocCipher
 {
 public:
     CDocCipher() = default;
diff --git a/cdoc/CMakeLists.txt b/cdoc/CMakeLists.txt
@@ -61,6 +61,7 @@ add_library(cdoc
     CDoc2.h
     Wrapper.h
     utils/memory.h
+    CDocCipher.cpp CDocCipher.h
 )
 set_target_properties(cdoc PROPERTIES
     VERSION ${PROJECT_VERSION}
@@ -92,9 +93,9 @@ target_link_libraries(cdoc PRIVATE
 )
 
 if(BUILD_TOOLS)
-    add_executable(cdoc-tool cdoc-tool.cpp CDocCipher.cpp)
+    add_executable(cdoc-tool cdoc-tool.cpp)
     target_include_directories(cdoc-tool PRIVATE ${OPENSSL_INCLUDE_DIR})
-    target_link_libraries(cdoc-tool cdoc_ver cdoc OpenSSL::SSL)
+    target_link_libraries(cdoc-tool cdoc_ver cdoc)
     set_target_properties(cdoc-tool PROPERTIES
         INSTALL_RPATH $<$<PLATFORM_ID:Darwin>:@executable_path/../lib>
     )
@@ -191,7 +192,7 @@ if(APPLE)
     list(TRANSFORM MODULE_LIST PREPEND "  header \"")
     list(TRANSFORM MODULE_LIST APPEND "\"")
     list(JOIN MODULE_LIST "\n" MODULE_LIST)
-    set(MODULE_MAP ${CMAKE_BINARY_DIR}/module.modulemap)
+    set(MODULE_MAP ${PROJECT_BINARY_DIR}/module.modulemap)
     file(WRITE ${MODULE_MAP} "framework module cdoc {
 ${MODULE_LIST}
   export *
diff --git a/cdoc/Certificate.cpp b/cdoc/Certificate.cpp
@@ -28,13 +28,12 @@ Certificate::Certificate(const std::vector<uint8_t>& cert)
 {
 }
 
-static std::string
-getName(const unique_free_t<X509>& cert, int NID)
+std::string Certificate::getName(X509 *cert, int NID)
 {
     std::string cn;
     if(!cert)
         return cn;
-    X509_NAME *name = X509_get_subject_name(cert.get());
+    X509_NAME *name = X509_get_subject_name(cert);
     if(!name)
         return cn;
     int pos = X509_NAME_get_index_by_NID(name, NID, -1);
@@ -44,34 +43,34 @@ getName(const unique_free_t<X509>& cert, int NID)
     if(!e)
         return cn;
     char *data = nullptr;
-    int size = ASN1_STRING_to_UTF8((uint8_t**)&data, X509_NAME_ENTRY_get_data(e));
-    cn.assign(data, size_t(size));
+    if(int size = ASN1_STRING_to_UTF8((uint8_t**)&data, X509_NAME_ENTRY_get_data(e)); size > 0)
+        cn.assign(data, size_t(size));
     OPENSSL_free(data);
     return cn;
 }
 
 std::string
 Certificate::getCommonName() const
 {
-	return getName(cert, NID_commonName);
+    return getName(cert.get(), NID_commonName);
 }
 
 std::string
 Certificate::getGivenName() const
 {
-	return getName(cert, NID_givenName);
+    return getName(cert.get(), NID_givenName);
 }
 
 std::string
 Certificate::getSurname() const
 {
-	return getName(cert, NID_surname);
+    return getName(cert.get(), NID_surname);
 }
 
 std::string
 Certificate::getSerialNumber() const
 {
-	return getName(cert, NID_serialNumber);
+    return getName(cert.get(), NID_serialNumber);
 }
 
 time_t
diff --git a/cdoc/Certificate.h b/cdoc/Certificate.h
@@ -19,8 +19,6 @@
 #ifndef SSLCERTIFICATE_H
 #define SSLCERTIFICATE_H
 
-#include "Exports.h"
-
 #include "utils/memory.h"
 
 #include <string>
@@ -48,9 +46,10 @@ class Certificate {
 
     explicit Certificate(const std::vector<uint8_t>& cert);
 
-	std::string getCommonName() const;
-	std::string getGivenName() const;
-	std::string getSurname() const;
+    static std::string getName(X509 *cert, int NID);
+    std::string getCommonName() const;
+    std::string getGivenName() const;
+    std::string getSurname() const;
     std::string getSerialNumber() const;
 
     EIDType getEIDType() const;
diff --git a/cdoc/XmlWriter.cpp b/cdoc/XmlWriter.cpp
@@ -45,17 +45,17 @@ XMLWriter::~XMLWriter() noexcept
         xmlTextWriterEndDocument(w.get());
 }
 
-int64_t XMLWriter::writeStartElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr)
+int64_t XMLWriter::writeStartElement(NS ns, const char *name, const std::map<const char *, std::string> &attr)
 {
     if(!w)
         return WRONG_ARGUMENTS;
     auto &count = nsmap[ns.prefix ? ns.prefix : std::string_view{}];
     count++;
-    if(xmlTextWriterStartElementNS(w.get(), pcxmlChar(ns.prefix), pcxmlChar(name.c_str()), count > 1 ? nullptr : pcxmlChar(ns.ns)) == -1)
+    if(xmlTextWriterStartElementNS(w.get(), pcxmlChar(ns.prefix), pcxmlChar(name), count > 1 ? nullptr : pcxmlChar(ns.ns)) == -1)
         return IO_ERROR;
     for(const auto &[name, content]: attr)
     {
-        if(xmlTextWriterWriteAttribute(w.get(), pcxmlChar(name.c_str()), pcxmlChar(content.c_str())) == -1)
+        if(xmlTextWriterWriteAttribute(w.get(), pcxmlChar(name), pcxmlChar(content.c_str())) == -1)
             return IO_ERROR;
     }
     return OK;
@@ -72,7 +72,7 @@ int64_t XMLWriter::writeEndElement(NS ns)
     return OK;
 }
 
-int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::function<int64_t()> &f)
+int64_t XMLWriter::writeElement(NS ns, const char *name, const std::function<int64_t()> &f)
 {
     if(auto rv = writeStartElement(ns, name, {}); rv != OK)
         return rv;
@@ -81,7 +81,7 @@ int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::funct
     return writeEndElement(ns);
 }
 
-int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr, const std::function<int64_t()> &f)
+int64_t XMLWriter::writeElement(NS ns, const char *name, const std::map<const char *, std::string> &attr, const std::function<int64_t()> &f)
 {
     if(auto rv = writeStartElement(ns, name, attr); rv != OK)
         return rv;
@@ -90,7 +90,7 @@ int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::map<s
     return writeEndElement(ns);
 }
 
-int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std::function<int64_t(DataConsumer&)> &f, const std::map<std::string, std::string> &attr)
+int64_t XMLWriter::writeBase64Element(NS ns, const char *name, const std::function<int64_t(DataConsumer&)> &f, const std::map<const char *, std::string> &attr)
 {
     if(auto rv = writeStartElement(ns, name, attr); rv != OK)
         return rv;
@@ -150,7 +150,7 @@ int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std:
     return writeEndElement(ns);
 }
 
-int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std::vector<xmlChar> &data, const std::map<std::string, std::string> &attr)
+int64_t XMLWriter::writeBase64Element(NS ns, const char *name, const std::vector<xmlChar> &data, const std::map<const char *, std::string> &attr)
 {
     if(auto rv = writeStartElement(ns, name, attr); rv != OK)
         return rv;
@@ -159,7 +159,7 @@ int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std:
     return writeEndElement(ns);
 }
 
-int64_t XMLWriter::writeTextElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr, const std::string &data)
+int64_t XMLWriter::writeTextElement(NS ns, const char *name, const std::map<const char *, std::string> &attr, const std::string &data)
 {
     if(auto rv = writeStartElement(ns, name, attr); rv != OK)
         return rv;
diff --git a/cdoc/XmlWriter.h b/cdoc/XmlWriter.h
@@ -39,13 +39,13 @@ class XMLWriter
     XMLWriter(DataConsumer &dst);
     virtual ~XMLWriter() noexcept;
 
-    int64_t writeStartElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr);
+    int64_t writeStartElement(NS ns, const char *name, const std::map<const char *, std::string> &attr);
     int64_t writeEndElement(NS ns);
-    int64_t writeElement(NS ns, const std::string &name, const std::function<int64_t()> &f = nullptr);
-    int64_t writeElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr, const std::function<int64_t()> &f = nullptr);
-    int64_t writeBase64Element(NS ns, const std::string &name, const std::function<int64_t(DataConsumer &)> &f, const std::map<std::string, std::string> &attr = {});
-    int64_t writeBase64Element(NS ns, const std::string &name, const std::vector<unsigned char> &data, const std::map<std::string, std::string> &attr = {});
-    int64_t writeTextElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr, const std::string &data);
+    int64_t writeElement(NS ns, const char *name, const std::function<int64_t()> &f = nullptr);
+    int64_t writeElement(NS ns, const char *name, const std::map<const char *, std::string> &attr, const std::function<int64_t()> &f = nullptr);
+    int64_t writeBase64Element(NS ns, const char *name, const std::function<int64_t(DataConsumer &)> &f, const std::map<const char *, std::string> &attr = {});
+    int64_t writeBase64Element(NS ns, const char *name, const std::vector<unsigned char> &data, const std::map<const char *, std::string> &attr = {});
+    int64_t writeTextElement(NS ns, const char *name, const std::map<const char *, std::string> &attr, const std::string &data);
 
 private:
     unique_free_t<_xmlTextWriter> w;
diff --git a/etc/Doxyfile.in b/etc/Doxyfile.in
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ if(LIBCDOC_WITH_DOCS)`
`64`	`64`	`WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}`
`65`	`65`	`COMMENT "Generating API documentation with Doxygen" VERBATIM`
`66`	`66`	`)`
`67`		`- install(DIRECTORY ${CMAKE_BINARY_DIR}/doc/ DESTINATION ${CMAKE_INSTALL_DOCDIR})`
	`67`	`+ install(DIRECTORY ${PROJECT_BINARY_DIR}/doc/ DESTINATION ${CMAKE_INSTALL_DOCDIR})`
`68`	`68`	`install(DIRECTORY doc/ DESTINATION ${CMAKE_INSTALL_DOCDIR})`
`69`	`69`	`endif()`
`70`	`70`	`endif()`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@`
`23`	`23`	`#include "CDocWriter.h"`
`24`	`24`	`#include "RcptInfo.h"`
`25`	`25`	`#include "ToolConf.h"`
	`26`	`+#include "Exports.h"`
`26`	`27`
`27`	`28`	`#include <map>`
`28`	`29`	`#include <memory>`
`@@ -31,7 +32,7 @@ namespace libcdoc`
`31`	`32`	`{`
`32`	`33`
`33`	`34`
`34`		`-class CDocCipher`
	`35`	`+class CDOC_EXPORT CDocCipher`
`35`	`36`	`{`
`36`	`37`	`public:`
`37`	`38`	`CDocCipher() = default;`
Original file line number	Diff line number	Diff line change
`@@ -28,13 +28,12 @@ Certificate::Certificate(const std::vector<uint8_t>& cert)`
`28`	`28`	`{`
`29`	`29`	`}`
`30`	`30`
`31`		`-static std::string`
`32`		`-getName(const unique_free_t<X509>& cert, int NID)`
	`31`	`+std::string Certificate::getName(X509 *cert, int NID)`
`33`	`32`	`{`
`34`	`33`	`std::string cn;`
`35`	`34`	`if(!cert)`
`36`	`35`	`return cn;`
`37`		`- X509_NAME *name = X509_get_subject_name(cert.get());`
	`36`	`+ X509_NAME *name = X509_get_subject_name(cert);`
`38`	`37`	`if(!name)`
`39`	`38`	`return cn;`
`40`	`39`	`int pos = X509_NAME_get_index_by_NID(name, NID, -1);`
`@@ -44,34 +43,34 @@ getName(const unique_free_t<X509>& cert, int NID)`
`44`	`43`	`if(!e)`
`45`	`44`	`return cn;`
`46`	`45`	`char *data = nullptr;`
`47`		`- int size = ASN1_STRING_to_UTF8((uint8_t**)&data, X509_NAME_ENTRY_get_data(e));`
`48`		`- cn.assign(data, size_t(size));`
	`46`	`+ if(int size = ASN1_STRING_to_UTF8((uint8_t**)&data, X509_NAME_ENTRY_get_data(e)); size > 0)`
	`47`	`+ cn.assign(data, size_t(size));`
`49`	`48`	`OPENSSL_free(data);`
`50`	`49`	`return cn;`
`51`	`50`	`}`
`52`	`51`
`53`	`52`	`std::string`
`54`	`53`	`Certificate::getCommonName() const`
`55`	`54`	`{`
`56`		`- return getName(cert, NID_commonName);`
	`55`	`+ return getName(cert.get(), NID_commonName);`
`57`	`56`	`}`
`58`	`57`
`59`	`58`	`std::string`
`60`	`59`	`Certificate::getGivenName() const`
`61`	`60`	`{`
`62`		`- return getName(cert, NID_givenName);`
	`61`	`+ return getName(cert.get(), NID_givenName);`
`63`	`62`	`}`
`64`	`63`
`65`	`64`	`std::string`
`66`	`65`	`Certificate::getSurname() const`
`67`	`66`	`{`
`68`		`- return getName(cert, NID_surname);`
	`67`	`+ return getName(cert.get(), NID_surname);`
`69`	`68`	`}`
`70`	`69`
`71`	`70`	`std::string`
`72`	`71`	`Certificate::getSerialNumber() const`
`73`	`72`	`{`
`74`		`- return getName(cert, NID_serialNumber);`
	`73`	`+ return getName(cert.get(), NID_serialNumber);`
`75`	`74`	`}`
`76`	`75`
`77`	`76`	`time_t`
Original file line number	Diff line number	Diff line change
`@@ -45,17 +45,17 @@ XMLWriter::~XMLWriter() noexcept`
`45`	`45`	`xmlTextWriterEndDocument(w.get());`
`46`	`46`	`}`
`47`	`47`
`48`		`-int64_t XMLWriter::writeStartElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr)`
	`48`	`+int64_t XMLWriter::writeStartElement(NS ns, const char name, const std::map<const char , std::string> &attr)`
`49`	`49`	`{`
`50`	`50`	`if(!w)`
`51`	`51`	`return WRONG_ARGUMENTS;`
`52`	`52`	`auto &count = nsmap[ns.prefix ? ns.prefix : std::string_view{}];`
`53`	`53`	`count++;`
`54`		`- if(xmlTextWriterStartElementNS(w.get(), pcxmlChar(ns.prefix), pcxmlChar(name.c_str()), count > 1 ? nullptr : pcxmlChar(ns.ns)) == -1)`
	`54`	`+ if(xmlTextWriterStartElementNS(w.get(), pcxmlChar(ns.prefix), pcxmlChar(name), count > 1 ? nullptr : pcxmlChar(ns.ns)) == -1)`
`55`	`55`	`return IO_ERROR;`
`56`	`56`	`for(const auto &[name, content]: attr)`
`57`	`57`	`{`
`58`		`- if(xmlTextWriterWriteAttribute(w.get(), pcxmlChar(name.c_str()), pcxmlChar(content.c_str())) == -1)`
	`58`	`+ if(xmlTextWriterWriteAttribute(w.get(), pcxmlChar(name), pcxmlChar(content.c_str())) == -1)`
`59`	`59`	`return IO_ERROR;`
`60`	`60`	`}`
`61`	`61`	`return OK;`
`@@ -72,7 +72,7 @@ int64_t XMLWriter::writeEndElement(NS ns)`
`72`	`72`	`return OK;`
`73`	`73`	`}`
`74`	`74`
`75`		`-int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::function<int64_t()> &f)`
	`75`	`+int64_t XMLWriter::writeElement(NS ns, const char *name, const std::function<int64_t()> &f)`
`76`	`76`	`{`
`77`	`77`	`if(auto rv = writeStartElement(ns, name, {}); rv != OK)`
`78`	`78`	`return rv;`
`@@ -81,7 +81,7 @@ int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::funct`
`81`	`81`	`return writeEndElement(ns);`
`82`	`82`	`}`
`83`	`83`
`84`		`-int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr, const std::function<int64_t()> &f)`
	`84`	`+int64_t XMLWriter::writeElement(NS ns, const char name, const std::map<const char , std::string> &attr, const std::function<int64_t()> &f)`
`85`	`85`	`{`
`86`	`86`	`if(auto rv = writeStartElement(ns, name, attr); rv != OK)`
`87`	`87`	`return rv;`
`@@ -90,7 +90,7 @@ int64_t XMLWriter::writeElement(NS ns, const std::string &name, const std::map<s`
`90`	`90`	`return writeEndElement(ns);`
`91`	`91`	`}`
`92`	`92`
`93`		`-int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std::function<int64_t(DataConsumer&)> &f, const std::map<std::string, std::string> &attr)`
	`93`	`+int64_t XMLWriter::writeBase64Element(NS ns, const char name, const std::function<int64_t(DataConsumer&)> &f, const std::map<const char , std::string> &attr)`
`94`	`94`	`{`
`95`	`95`	`if(auto rv = writeStartElement(ns, name, attr); rv != OK)`
`96`	`96`	`return rv;`
`@@ -150,7 +150,7 @@ int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std:`
`150`	`150`	`return writeEndElement(ns);`
`151`	`151`	`}`
`152`	`152`
`153`		`-int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std::vector<xmlChar> &data, const std::map<std::string, std::string> &attr)`
	`153`	`+int64_t XMLWriter::writeBase64Element(NS ns, const char name, const std::vector<xmlChar> &data, const std::map<const char , std::string> &attr)`
`154`	`154`	`{`
`155`	`155`	`if(auto rv = writeStartElement(ns, name, attr); rv != OK)`
`156`	`156`	`return rv;`
`@@ -159,7 +159,7 @@ int64_t XMLWriter::writeBase64Element(NS ns, const std::string &name, const std:`
`159`	`159`	`return writeEndElement(ns);`
`160`	`160`	`}`
`161`	`161`
`162`		`-int64_t XMLWriter::writeTextElement(NS ns, const std::string &name, const std::map<std::string, std::string> &attr, const std::string &data)`
	`162`	`+int64_t XMLWriter::writeTextElement(NS ns, const char name, const std::map<const char , std::string> &attr, const std::string &data)`
`163`	`163`	`{`
`164`	`164`	`if(auto rv = writeStartElement(ns, name, attr); rv != OK)`
`165`	`165`	`return rv;`