VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/xml.cpp@ 103914

Last change on this file since 103914 was 103439, checked in by vboxsync, 9 months ago

IPRT/xml.cpp: Simplified the XmlFileWriter::write() path handling. bugref:3409

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 66.0 KB
Line 
1/* $Id: xml.cpp 103439 2024-02-19 13:43:33Z vboxsync $ */
2/** @file
3 * IPRT - XML Manipulation API.
4 *
5 * @note Not available in no-CRT mode because it relies too heavily on
6 * exceptions, as well as using std::list and std::map.
7 */
8
9/*
10 * Copyright (C) 2007-2023 Oracle and/or its affiliates.
11 *
12 * This file is part of VirtualBox base platform packages, as
13 * available from https://www.virtualbox.org.
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation, in version 3 of the
18 * License.
19 *
20 * This program is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, see <https://www.gnu.org/licenses>.
27 *
28 * The contents of this file may alternatively be used under the terms
29 * of the Common Development and Distribution License Version 1.0
30 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
31 * in the VirtualBox distribution, in which case the provisions of the
32 * CDDL are applicable instead of those of the GPL.
33 *
34 * You may elect to license modified versions of this file under the
35 * terms and conditions of either the GPL or the CDDL or both.
36 *
37 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
38 */
39
40
41/*********************************************************************************************************************************
42* Header Files *
43*********************************************************************************************************************************/
44#include <iprt/cpp/xml.h>
45
46#include <iprt/dir.h>
47#include <iprt/file.h>
48#include <iprt/err.h>
49#include <iprt/log.h>
50#include <iprt/param.h>
51#include <iprt/path.h>
52#include <iprt/cpp/lock.h>
53
54#include <libxml/tree.h>
55#include <libxml/parser.h>
56#include <libxml/globals.h>
57#include <libxml/xmlIO.h>
58#include <libxml/xmlsave.h>
59#include <libxml/uri.h>
60
61#include <libxml/xmlschemas.h>
62
63#include <map>
64
65
66/*********************************************************************************************************************************
67* Strict / debug helpers *
68*********************************************************************************************************************************/
69#ifdef DEBUG_andy
70/** Enable the following to get strict assertions if the XML got some invalid values for attributes. */
71# define VBOX_XML_STRICT_ASSERT_FAILED { AssertMsgFailed(("Invalid value '%s' for %s/@%s\n", pcsz, m_pcszName, pcszMatch)); }
72#else
73# define VBOX_XML_STRICT_ASSERT_FAILED void(0)
74#endif
75
76
77/*********************************************************************************************************************************
78* Global Variables *
79*********************************************************************************************************************************/
80/**
81 * Global module initialization structure. This is to wrap non-reentrant bits
82 * of libxml, among other things.
83 *
84 * The constructor and destructor of this structure are used to perform global
85 * module initialization and cleanup. There must be only one global variable of
86 * this structure.
87 */
88static class Global
89{
90public:
91
92 Global()
93 {
94 /* Check the parser version. The docs say it will kill the app if
95 * there is a serious version mismatch, but I couldn't find it in the
96 * source code (it only prints the error/warning message to the console) so
97 * let's leave it as is for informational purposes. */
98 LIBXML_TEST_VERSION
99
100 /* Init libxml */
101 xmlInitParser();
102
103 /* Save the default entity resolver before someone has replaced it */
104 sxml.defaultEntityLoader = xmlGetExternalEntityLoader();
105 }
106
107 ~Global()
108 {
109 /* Shutdown libxml */
110 xmlCleanupParser();
111 }
112
113 struct
114 {
115 xmlExternalEntityLoader defaultEntityLoader;
116
117 /** Used to provide some thread safety missing in libxml2 (see e.g.
118 * XmlTreeBackend::read()) */
119 RTCLockMtx lock;
120 }
121 sxml; /* XXX naming this xml will break with gcc-3.3 */
122} gGlobal;
123
124
125
126namespace xml
127{
128
129////////////////////////////////////////////////////////////////////////////////
130//
131// Exceptions
132//
133////////////////////////////////////////////////////////////////////////////////
134
135LogicError::LogicError(RT_SRC_POS_DECL)
136 : RTCError(NULL)
137{
138 char *msg = NULL;
139 RTStrAPrintf(&msg, "In '%s', '%s' at #%d",
140 pszFunction, pszFile, iLine);
141 setWhat(msg);
142 RTStrFree(msg);
143}
144
145XmlError::XmlError(xmlErrorPtr aErr)
146{
147 if (!aErr)
148 throw EInvalidArg(RT_SRC_POS);
149
150 char *msg = Format(aErr);
151 setWhat(msg);
152 RTStrFree(msg);
153}
154
155/**
156 * Composes a single message for the given error. The caller must free the
157 * returned string using RTStrFree() when no more necessary.
158 */
159/* static */ char *XmlError::Format(xmlErrorPtr aErr)
160{
161 const char *msg = aErr->message ? aErr->message : "<none>";
162 size_t msgLen = strlen(msg);
163 /* strip spaces, trailing EOLs and dot-like char */
164 while (msgLen && strchr(" \n.?!", msg [msgLen - 1]))
165 --msgLen;
166
167 char *finalMsg = NULL;
168 RTStrAPrintf(&finalMsg, "%.*s.\nLocation: '%s', line %d (%d), column %d",
169 msgLen, msg, aErr->file, aErr->line, aErr->int1, aErr->int2);
170
171 return finalMsg;
172}
173
174EIPRTFailure::EIPRTFailure(int aRC, const char *pszContextFmt, ...)
175 : RuntimeError(NULL)
176 , mRC(aRC)
177{
178 va_list va;
179 va_start(va, pszContextFmt);
180 m_strMsg.printfVNoThrow(pszContextFmt, va);
181 va_end(va);
182 m_strMsg.appendPrintfNoThrow(" %Rrc (%Rrs)", aRC, aRC);
183}
184
185////////////////////////////////////////////////////////////////////////////////
186//
187// File Class
188//
189//////////////////////////////////////////////////////////////////////////////
190
191struct File::Data
192{
193 Data(RTFILE a_hHandle, const char *a_pszFilename, bool a_fFlushOnClose)
194 : strFileName(a_pszFilename)
195 , handle(a_hHandle)
196 , opened(a_hHandle != NIL_RTFILE)
197 , flushOnClose(a_fFlushOnClose)
198 { }
199
200 ~Data()
201 {
202 if (flushOnClose)
203 {
204 RTFileFlush(handle);
205 if (!strFileName.isEmpty())
206 RTDirFlushParent(strFileName.c_str());
207 }
208
209 if (opened)
210 {
211 RTFileClose(handle);
212 handle = NIL_RTFILE;
213 opened = false;
214 }
215 }
216
217 RTCString strFileName;
218 RTFILE handle;
219 bool opened : 1;
220 bool flushOnClose : 1;
221};
222
223File::File(Mode aMode, const char *aFileName, bool aFlushIt /* = false */)
224 : m(NULL)
225{
226 /* Try open the file first, as the destructor will not be invoked if we throw anything from here. For details see:
227 https://stackoverflow.com/questions/9971782/destructor-not-invoked-when-an-exception-is-thrown-in-the-constructor */
228 uint32_t flags = 0;
229 const char *pcszMode = "???";
230 switch (aMode)
231 {
232 /** @todo change to RTFILE_O_DENY_WRITE where appropriate. */
233 case Mode_Read:
234 flags = RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE;
235 pcszMode = "reading";
236 break;
237 case Mode_WriteCreate: // fail if file exists
238 flags = RTFILE_O_WRITE | RTFILE_O_CREATE | RTFILE_O_DENY_NONE;
239 pcszMode = "writing";
240 break;
241 case Mode_Overwrite: // overwrite if file exists
242 flags = RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_NONE;
243 pcszMode = "overwriting";
244 break;
245 case Mode_ReadWrite:
246 flags = RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE;
247 pcszMode = "reading/writing";
248 break;
249 }
250 RTFILE hFile = NIL_RTFILE;
251 int vrc = RTFileOpen(&hFile, aFileName, flags);
252 if (RT_FAILURE(vrc))
253 throw EIPRTFailure(vrc, "Runtime error opening '%s' for %s", aFileName, pcszMode);
254
255 /* Now we can create the data and stuff: */
256 try
257 {
258 m = new Data(hFile, aFileName, aFlushIt && (flags & RTFILE_O_ACCESS_MASK) != RTFILE_O_READ);
259 }
260 catch (std::bad_alloc &)
261 {
262 RTFileClose(hFile);
263 throw;
264 }
265}
266
267File::File(RTFILE aHandle, const char *aFileName /* = NULL */, bool aFlushIt /* = false */)
268 : m(NULL)
269{
270 if (aHandle == NIL_RTFILE)
271 throw EInvalidArg(RT_SRC_POS);
272
273 m = new Data(aHandle, aFileName, aFlushIt);
274
275 setPos(0);
276}
277
278File::~File()
279{
280 if (m)
281 {
282 delete m;
283 m = NULL;
284 }
285}
286
287const char *File::uri() const
288{
289 return m->strFileName.c_str();
290}
291
292uint64_t File::pos() const
293{
294 uint64_t p = 0;
295 int vrc = RTFileSeek(m->handle, 0, RTFILE_SEEK_CURRENT, &p);
296 if (RT_SUCCESS(vrc))
297 return p;
298
299 throw EIPRTFailure(vrc, "Runtime error seeking in file '%s'", m->strFileName.c_str());
300}
301
302void File::setPos(uint64_t aPos)
303{
304 uint64_t p = 0;
305 unsigned method = RTFILE_SEEK_BEGIN;
306 int vrc = VINF_SUCCESS;
307
308 /* check if we overflow int64_t and move to INT64_MAX first */
309 if ((int64_t)aPos < 0)
310 {
311 vrc = RTFileSeek(m->handle, INT64_MAX, method, &p);
312 aPos -= (uint64_t)INT64_MAX;
313 method = RTFILE_SEEK_CURRENT;
314 }
315 /* seek the rest */
316 if (RT_SUCCESS(vrc))
317 vrc = RTFileSeek(m->handle, (int64_t) aPos, method, &p);
318 if (RT_SUCCESS(vrc))
319 return;
320
321 throw EIPRTFailure(vrc, "Runtime error seeking in file '%s'", m->strFileName.c_str());
322}
323
324int File::read(char *aBuf, int aLen)
325{
326 size_t len = aLen;
327 int vrc = RTFileRead(m->handle, aBuf, len, &len);
328 if (RT_SUCCESS(vrc))
329 return (int)len;
330
331 throw EIPRTFailure(vrc, "Runtime error reading from file '%s'", m->strFileName.c_str());
332}
333
334int File::write(const char *aBuf, int aLen)
335{
336 size_t len = aLen;
337 int vrc = RTFileWrite(m->handle, aBuf, len, &len);
338 if (RT_SUCCESS(vrc))
339 return (int)len;
340
341 throw EIPRTFailure(vrc, "Runtime error writing to file '%s'", m->strFileName.c_str());
342}
343
344void File::truncate()
345{
346 int vrc = RTFileSetSize(m->handle, pos());
347 if (RT_SUCCESS(vrc))
348 return;
349
350 throw EIPRTFailure(vrc, "Runtime error truncating file '%s'", m->strFileName.c_str());
351}
352
353////////////////////////////////////////////////////////////////////////////////
354//
355// MemoryBuf Class
356//
357//////////////////////////////////////////////////////////////////////////////
358
359struct MemoryBuf::Data
360{
361 Data()
362 : buf(NULL), len(0), uri(NULL), pos(0) {}
363
364 const char *buf;
365 size_t len;
366 char *uri;
367
368 size_t pos;
369};
370
371MemoryBuf::MemoryBuf(const char *aBuf, size_t aLen, const char *aURI /* = NULL */)
372 : m(new Data())
373{
374 if (aBuf == NULL)
375 throw EInvalidArg(RT_SRC_POS);
376
377 m->buf = aBuf;
378 m->len = aLen;
379 m->uri = RTStrDup(aURI);
380}
381
382MemoryBuf::~MemoryBuf()
383{
384 RTStrFree(m->uri);
385}
386
387const char *MemoryBuf::uri() const
388{
389 return m->uri;
390}
391
392uint64_t MemoryBuf::pos() const
393{
394 return m->pos;
395}
396
397void MemoryBuf::setPos(uint64_t aPos)
398{
399 size_t off = (size_t)aPos;
400 if ((uint64_t) off != aPos)
401 throw EInvalidArg();
402
403 if (off > m->len)
404 throw EInvalidArg();
405
406 m->pos = off;
407}
408
409int MemoryBuf::read(char *aBuf, int aLen)
410{
411 if (m->pos >= m->len)
412 return 0 /* nothing to read */;
413
414 size_t len = m->pos + aLen < m->len ? aLen : m->len - m->pos;
415 memcpy(aBuf, m->buf + m->pos, len);
416 m->pos += len;
417
418 return (int)len;
419}
420
421////////////////////////////////////////////////////////////////////////////////
422//
423// GlobalLock class
424//
425////////////////////////////////////////////////////////////////////////////////
426
427struct GlobalLock::Data
428{
429 PFNEXTERNALENTITYLOADER pfnOldLoader;
430 RTCLock lock;
431
432 Data()
433 : pfnOldLoader(NULL)
434 , lock(gGlobal.sxml.lock)
435 {
436 }
437};
438
439GlobalLock::GlobalLock()
440 : m(new Data())
441{
442}
443
444GlobalLock::~GlobalLock()
445{
446 if (m->pfnOldLoader)
447 xmlSetExternalEntityLoader(m->pfnOldLoader);
448 delete m;
449 m = NULL;
450}
451
452void GlobalLock::setExternalEntityLoader(PFNEXTERNALENTITYLOADER pfnLoader)
453{
454 m->pfnOldLoader = (PFNEXTERNALENTITYLOADER)xmlGetExternalEntityLoader();
455 xmlSetExternalEntityLoader(pfnLoader);
456}
457
458// static
459xmlParserInput* GlobalLock::callDefaultLoader(const char *aURI,
460 const char *aID,
461 xmlParserCtxt *aCtxt)
462{
463 return gGlobal.sxml.defaultEntityLoader(aURI, aID, aCtxt);
464}
465
466
467
468////////////////////////////////////////////////////////////////////////////////
469//
470// Node class
471//
472////////////////////////////////////////////////////////////////////////////////
473
474Node::Node(EnumType type,
475 Node *pParent,
476 PRTLISTANCHOR pListAnchor,
477 xmlNode *pLibNode,
478 xmlAttr *pLibAttr)
479 : m_Type(type)
480 , m_pParent(pParent)
481 , m_pLibNode(pLibNode)
482 , m_pLibAttr(pLibAttr)
483 , m_pcszNamespacePrefix(NULL)
484 , m_pcszNamespaceHref(NULL)
485 , m_pcszName(NULL)
486 , m_pParentListAnchor(pListAnchor)
487{
488 RTListInit(&m_listEntry);
489}
490
491Node::~Node()
492{
493}
494
495/**
496 * Returns the name of the node, which is either the element name or
497 * the attribute name. For other node types it probably returns NULL.
498 * @return
499 */
500const char *Node::getName() const
501{
502 return m_pcszName;
503}
504
505/**
506 * Returns the name of the node, which is either the element name or
507 * the attribute name. For other node types it probably returns NULL.
508 * @return
509 */
510const char *Node::getPrefix() const
511{
512 return m_pcszNamespacePrefix;
513}
514
515/**
516 * Returns the XML namespace URI, which is the attribute name. For other node types it probably
517 * returns NULL.
518 * @return
519 */
520const char *Node::getNamespaceURI() const
521{
522 return m_pcszNamespaceHref;
523}
524
525/**
526 * Variant of nameEquals that checks the namespace as well.
527 * @param pcszNamespace
528 * @param pcsz
529 * @return
530 */
531bool Node::nameEqualsNS(const char *pcszNamespace, const char *pcsz) const
532{
533 if (m_pcszName == pcsz)
534 return true;
535 if (m_pcszName == NULL)
536 return false;
537 if (pcsz == NULL)
538 return false;
539 if (strcmp(m_pcszName, pcsz))
540 return false;
541
542 // name matches: then check namespaces as well
543 if (!pcszNamespace)
544 return true;
545 // caller wants namespace:
546 if (!m_pcszNamespacePrefix)
547 // but node has no namespace:
548 return false;
549 return !strcmp(m_pcszNamespacePrefix, pcszNamespace);
550}
551
552/**
553 * Variant of nameEquals that checks the namespace as well.
554 *
555 * @returns true if equal, false if not.
556 * @param pcsz The element name.
557 * @param cchMax The maximum number of character from @a pcsz to
558 * match.
559 * @param pcszNamespace The name space prefix or NULL (default).
560 */
561bool Node::nameEqualsN(const char *pcsz, size_t cchMax, const char *pcszNamespace /* = NULL*/) const
562{
563 /* Match the name. */
564 if (!m_pcszName)
565 return false;
566 if (!pcsz || cchMax == 0)
567 return false;
568 if (strncmp(m_pcszName, pcsz, cchMax))
569 return false;
570 if (strlen(m_pcszName) > cchMax)
571 return false;
572
573 /* Match name space. */
574 if (!pcszNamespace)
575 return true; /* NULL, anything goes. */
576 if (!m_pcszNamespacePrefix)
577 return false; /* Element has no namespace. */
578 return !strcmp(m_pcszNamespacePrefix, pcszNamespace);
579}
580
581/**
582 * Returns the value of a node. If this node is an attribute, returns
583 * the attribute value; if this node is an element, then this returns
584 * the element text content.
585 * @return
586 */
587const char *Node::getValue() const
588{
589 if ( m_pLibAttr
590 && m_pLibAttr->children
591 )
592 // libxml hides attribute values in another node created as a
593 // single child of the attribute node, and it's in the content field
594 return (const char *)m_pLibAttr->children->content;
595
596 if ( m_pLibNode
597 && m_pLibNode->children)
598 return (const char *)m_pLibNode->children->content;
599
600 return NULL;
601}
602
603/**
604 * Returns the value of a node. If this node is an attribute, returns
605 * the attribute value; if this node is an element, then this returns
606 * the element text content.
607 * @return
608 * @param cchValueLimit If the length of the returned value exceeds this
609 * limit a EIPRTFailure exception will be thrown.
610 */
611const char *Node::getValueN(size_t cchValueLimit) const
612{
613 if ( m_pLibAttr
614 && m_pLibAttr->children
615 )
616 {
617 // libxml hides attribute values in another node created as a
618 // single child of the attribute node, and it's in the content field
619 AssertStmt(strlen((const char *)m_pLibAttr->children->content) <= cchValueLimit, throw EIPRTFailure(VERR_BUFFER_OVERFLOW, "Attribute '%s' exceeds limit of %zu bytes", m_pcszName, cchValueLimit));
620 return (const char *)m_pLibAttr->children->content;
621 }
622
623 if ( m_pLibNode
624 && m_pLibNode->children)
625 {
626 AssertStmt(strlen((const char *)m_pLibNode->children->content) <= cchValueLimit, throw EIPRTFailure(VERR_BUFFER_OVERFLOW, "Element '%s' exceeds limit of %zu bytes", m_pcszName, cchValueLimit));
627 return (const char *)m_pLibNode->children->content;
628 }
629
630 return NULL;
631}
632
633/**
634 * Copies the value of a node into the given integer variable.
635 * Returns TRUE only if a value was found and was actually an
636 * integer of the given type.
637 * @return
638 */
639bool Node::copyValue(int32_t &i) const
640{
641 const char *pcsz;
642 if ( ((pcsz = getValue()))
643 && (VINF_SUCCESS == RTStrToInt32Ex(pcsz, NULL, 10, &i))
644 )
645 return true;
646
647 return false;
648}
649
650/**
651 * Copies the value of a node into the given integer variable.
652 * Returns TRUE only if a value was found and was actually an
653 * integer of the given type.
654 * @return
655 */
656bool Node::copyValue(uint32_t &i) const
657{
658 const char *pcsz;
659 if ( ((pcsz = getValue()))
660 && (VINF_SUCCESS == RTStrToUInt32Ex(pcsz, NULL, 10, &i))
661 )
662 return true;
663
664 return false;
665}
666
667/**
668 * Copies the value of a node into the given integer variable.
669 * Returns TRUE only if a value was found and was actually an
670 * integer of the given type.
671 * @return
672 */
673bool Node::copyValue(int64_t &i) const
674{
675 const char *pcsz;
676 if ( ((pcsz = getValue()))
677 && (VINF_SUCCESS == RTStrToInt64Ex(pcsz, NULL, 10, &i))
678 )
679 return true;
680
681 return false;
682}
683
684/**
685 * Copies the value of a node into the given integer variable.
686 * Returns TRUE only if a value was found and was actually an
687 * integer of the given type.
688 * @return
689 */
690bool Node::copyValue(uint64_t &i) const
691{
692 const char *pcsz;
693 if ( ((pcsz = getValue()))
694 && (VINF_SUCCESS == RTStrToUInt64Ex(pcsz, NULL, 10, &i))
695 )
696 return true;
697
698 return false;
699}
700
701/**
702 * Returns the line number of the current node in the source XML file.
703 * Useful for error messages.
704 * @return
705 */
706int Node::getLineNumber() const
707{
708 if (m_pLibAttr)
709 return m_pParent->m_pLibNode->line;
710
711 return m_pLibNode->line;
712}
713
714/**
715 * Private element constructor.
716 *
717 * @param pElmRoot Pointer to the root element.
718 * @param pParent Pointer to the parent element (always an ElementNode,
719 * despite the type). NULL for the root node.
720 * @param pListAnchor Pointer to the m_children member of the parent. NULL
721 * for the root node.
722 * @param pLibNode Pointer to the libxml2 node structure.
723 */
724ElementNode::ElementNode(const ElementNode *pElmRoot,
725 Node *pParent,
726 PRTLISTANCHOR pListAnchor,
727 xmlNode *pLibNode)
728 : Node(IsElement,
729 pParent,
730 pListAnchor,
731 pLibNode,
732 NULL)
733{
734 m_pElmRoot = pElmRoot ? pElmRoot : this; // If NULL is passed, then this is the root element.
735 m_pcszName = (const char *)pLibNode->name;
736
737 if (pLibNode->ns)
738 {
739 m_pcszNamespacePrefix = (const char *)m_pLibNode->ns->prefix;
740 m_pcszNamespaceHref = (const char *)m_pLibNode->ns->href;
741 }
742
743 RTListInit(&m_children);
744 RTListInit(&m_attributes);
745}
746
747ElementNode::~ElementNode()
748{
749 Node *pCur, *pNext;
750 RTListForEachSafeCpp(&m_children, pCur, pNext, Node, m_listEntry)
751 {
752 delete pCur;
753 }
754 RTListInit(&m_children);
755
756 RTListForEachSafeCpp(&m_attributes, pCur, pNext, Node, m_listEntry)
757 {
758 delete pCur;
759 }
760 RTListInit(&m_attributes);
761}
762
763
764ElementNode const *ElementNode::getNextTreeElement(ElementNode const *pElmRoot /*= NULL */) const
765{
766 /*
767 * Consider children first.
768 */
769 ElementNode const *pChild = getFirstChildElement();
770 if (pChild)
771 return pChild;
772
773 /*
774 * Then siblings, aunts and uncles.
775 */
776 ElementNode const *pCur = this;
777 do
778 {
779 ElementNode const *pSibling = pCur->getNextSibilingElement();
780 if (pSibling != NULL)
781 return pSibling;
782
783 pCur = static_cast<const xml::ElementNode *>(pCur->m_pParent);
784 Assert(pCur || pCur == pElmRoot);
785 } while (pCur != pElmRoot);
786
787 return NULL;
788}
789
790
791/**
792 * Private implementation.
793 *
794 * @param pElmRoot The root element.
795 */
796/*static*/ void ElementNode::buildChildren(ElementNode *pElmRoot) // protected
797{
798 for (ElementNode *pCur = pElmRoot; pCur; pCur = pCur->getNextTreeElement(pElmRoot))
799 {
800 /*
801 * Go thru this element's attributes creating AttributeNodes for them.
802 */
803 for (xmlAttr *pLibAttr = pCur->m_pLibNode->properties; pLibAttr; pLibAttr = pLibAttr->next)
804 {
805 AttributeNode *pNew = new AttributeNode(pElmRoot, pCur, &pCur->m_attributes, pLibAttr);
806 RTListAppend(&pCur->m_attributes, &pNew->m_listEntry);
807 }
808
809 /*
810 * Go thru this element's child elements (element and text nodes).
811 */
812 for (xmlNodePtr pLibNode = pCur->m_pLibNode->children; pLibNode; pLibNode = pLibNode->next)
813 {
814 Node *pNew;
815 if (pLibNode->type == XML_ELEMENT_NODE)
816 pNew = new ElementNode(pElmRoot, pCur, &pCur->m_children, pLibNode);
817 else if (pLibNode->type == XML_TEXT_NODE)
818 pNew = new ContentNode(pCur, &pCur->m_children, pLibNode);
819 else
820 continue;
821 RTListAppend(&pCur->m_children, &pNew->m_listEntry);
822 }
823 }
824}
825
826
827/**
828 * Builds a list of direct child elements of the current element that
829 * match the given string; if pcszMatch is NULL, all direct child
830 * elements are returned.
831 * @param children out: list of nodes to which children will be appended.
832 * @param pcszMatch in: match string, or NULL to return all children.
833 * @return Number of items appended to the list (0 if none).
834 */
835int ElementNode::getChildElements(ElementNodesList &children,
836 const char *pcszMatch /*= NULL*/)
837 const
838{
839 int i = 0;
840 Node *p;
841 RTListForEachCpp(&m_children, p, Node, m_listEntry)
842 {
843 // export this child node if ...
844 if (p->isElement())
845 if ( !pcszMatch // ... the caller wants all nodes or ...
846 || !strcmp(pcszMatch, p->getName()) // ... the element name matches.
847 )
848 {
849 children.push_back(static_cast<ElementNode *>(p));
850 ++i;
851 }
852 }
853 return i;
854}
855
856/**
857 * Returns the first child element whose name matches pcszMatch.
858 *
859 * @param pcszNamespace Namespace prefix (e.g. "vbox") or NULL to match any namespace.
860 * @param pcszMatch Element name to match.
861 * @return
862 */
863const ElementNode *ElementNode::findChildElementNS(const char *pcszNamespace, const char *pcszMatch) const
864{
865 Node *p;
866 RTListForEachCpp(&m_children, p, Node, m_listEntry)
867 {
868 if (p->isElement())
869 {
870 ElementNode *pelm = static_cast<ElementNode*>(p);
871 if (pelm->nameEqualsNS(pcszNamespace, pcszMatch))
872 return pelm;
873 }
874 }
875 return NULL;
876}
877
878/**
879 * Returns the first child element whose "id" attribute matches pcszId.
880 * @param pcszId identifier to look for.
881 * @return child element or NULL if not found.
882 */
883const ElementNode *ElementNode::findChildElementFromId(const char *pcszId) const
884{
885 const Node *p;
886 RTListForEachCpp(&m_children, p, Node, m_listEntry)
887 {
888 if (p->isElement())
889 {
890 const ElementNode *pElm = static_cast<const ElementNode *>(p);
891 const AttributeNode *pAttr = pElm->findAttribute("id");
892 if (pAttr && !strcmp(pAttr->getValue(), pcszId))
893 return pElm;
894 }
895 }
896 return NULL;
897}
898
899const ElementNode *ElementNode::findChildElementP(const char *pcszPath, const char *pcszNamespace /*= NULL*/) const
900{
901 const char *pszElm = strchr(pcszPath, '/');
902 size_t const cchThis = pszElm ? pszElm - pcszPath : 0;
903 if (!cchThis)
904 return findChildElementNS(pcszNamespace, pcszPath);
905
906 /** @todo Can be done without recursion as we have both sibling lists and parent
907 * pointers in this variant. */
908 const Node *p;
909 RTListForEachCpp(&m_children, p, Node, m_listEntry)
910 {
911 if (p->isElement())
912 {
913 const ElementNode *pElm = static_cast<const ElementNode *>(p);
914 if (pElm->nameEqualsN(pcszPath, cchThis, pcszNamespace))
915 {
916 pElm = findChildElementP(pcszPath + cchThis, pcszNamespace);
917 if (pElm)
918 return pElm;
919 }
920 }
921 }
922
923 return NULL;
924}
925
926const ElementNode *ElementNode::getFirstChildElement() const
927{
928 const Node *p;
929 RTListForEachCpp(&m_children, p, Node, m_listEntry)
930 {
931 if (p->isElement())
932 return static_cast<const ElementNode *>(p);
933 }
934 return NULL;
935}
936
937const ElementNode *ElementNode::getLastChildElement() const
938{
939 const Node *p;
940 RTListForEachReverseCpp(&m_children, p, Node, m_listEntry)
941 {
942 if (p->isElement())
943 return static_cast<const ElementNode *>(p);
944 }
945 return NULL;
946}
947
948const ElementNode *ElementNode::getPrevSibilingElement() const
949{
950 if (!m_pParent)
951 return NULL;
952 const Node *pSibling = this;
953 for (;;)
954 {
955 pSibling = RTListGetPrevCpp(m_pParentListAnchor, pSibling, const Node, m_listEntry);
956 if (!pSibling)
957 return NULL;
958 if (pSibling->isElement())
959 return static_cast<const ElementNode *>(pSibling);
960 }
961}
962
963const ElementNode *ElementNode::getNextSibilingElement() const
964{
965 if (!m_pParent)
966 return NULL;
967 const Node *pSibling = this;
968 for (;;)
969 {
970 pSibling = RTListGetNextCpp(m_pParentListAnchor, pSibling, const Node, m_listEntry);
971 if (!pSibling)
972 return NULL;
973 if (pSibling->isElement())
974 return static_cast<const ElementNode *>(pSibling);
975 }
976}
977
978const ElementNode *ElementNode::findPrevSibilingElement(const char *pcszMatch, const char *pcszNamespace /*= NULL*/) const
979{
980 if (!m_pParent)
981 return NULL;
982 const Node *pSibling = this;
983 for (;;)
984 {
985 pSibling = RTListGetPrevCpp(m_pParentListAnchor, pSibling, const Node, m_listEntry);
986 if (!pSibling)
987 return NULL;
988 if (pSibling->isElement())
989 {
990 const ElementNode *pElem = static_cast<const ElementNode *>(pSibling);
991 if (pElem->nameEqualsNS(pcszNamespace, pcszMatch))
992 return pElem;
993 }
994 }
995}
996
997const ElementNode *ElementNode::findNextSibilingElement(const char *pcszMatch, const char *pcszNamespace /*= NULL*/) const
998{
999 if (!m_pParent)
1000 return NULL;
1001 const Node *pSibling = this;
1002 for (;;)
1003 {
1004 pSibling = RTListGetNextCpp(m_pParentListAnchor, pSibling, const Node, m_listEntry);
1005 if (!pSibling)
1006 return NULL;
1007 if (pSibling->isElement())
1008 {
1009 const ElementNode *pElem = static_cast<const ElementNode *>(pSibling);
1010 if (pElem->nameEqualsNS(pcszNamespace, pcszMatch))
1011 return pElem;
1012 }
1013 }
1014}
1015
1016
1017/**
1018 * Looks up the given attribute node in this element's attribute map.
1019 *
1020 * @param pcszMatch The name of the attribute to find.
1021 * @param pcszNamespace The attribute name space prefix or NULL.
1022 */
1023const AttributeNode *ElementNode::findAttribute(const char *pcszMatch, const char *pcszNamespace /*= NULL*/) const
1024{
1025 AttributeNode *p;
1026 RTListForEachCpp(&m_attributes, p, AttributeNode, m_listEntry)
1027 {
1028 if (p->nameEqualsNS(pcszNamespace, pcszMatch))
1029 return p;
1030 }
1031 return NULL;
1032}
1033
1034/**
1035 * Convenience method which attempts to find the attribute with the given
1036 * name and returns its value as a string.
1037 *
1038 * @param pcszMatch Name of attribute to find.
1039 * @param ppcsz Where to return the attribute.
1040 * @param pcszNamespace The attribute name space prefix or NULL.
1041 * @returns Boolean success indicator.
1042 */
1043bool ElementNode::getAttributeValue(const char *pcszMatch, const char **ppcsz, const char *pcszNamespace /*= NULL*/) const
1044{
1045 const AttributeNode *pAttr = findAttribute(pcszMatch, pcszNamespace);
1046 if (pAttr)
1047 {
1048 *ppcsz = pAttr->getValue();
1049 return true;
1050 }
1051 return false;
1052}
1053
1054/**
1055 * Convenience method which attempts to find the attribute with the given
1056 * name and returns its value as a string.
1057 *
1058 * @param pcszMatch Name of attribute to find.
1059 * @param pStr Pointer to the string object that should receive the
1060 * attribute value.
1061 * @param pcszNamespace The attribute name space prefix or NULL.
1062 * @returns Boolean success indicator.
1063 *
1064 * @throws Whatever the string class may throw on assignment.
1065 */
1066bool ElementNode::getAttributeValue(const char *pcszMatch, RTCString *pStr, const char *pcszNamespace /*= NULL*/) const
1067{
1068 const AttributeNode *pAttr = findAttribute(pcszMatch, pcszNamespace);
1069 if (pAttr)
1070 {
1071 *pStr = pAttr->getValue();
1072 return true;
1073 }
1074
1075 return false;
1076}
1077
1078/**
1079 * Like getAttributeValue (ministring variant), but makes sure that all backslashes
1080 * are converted to forward slashes.
1081 *
1082 * @param pcszMatch Name of attribute to find.
1083 * @param pStr Pointer to the string object that should
1084 * receive the attribute path value.
1085 * @param pcszNamespace The attribute name space prefix or NULL.
1086 * @returns Boolean success indicator.
1087 */
1088bool ElementNode::getAttributeValuePath(const char *pcszMatch, RTCString *pStr, const char *pcszNamespace /*= NULL*/) const
1089{
1090 if (getAttributeValue(pcszMatch, pStr, pcszNamespace))
1091 {
1092 pStr->findReplace('\\', '/');
1093 return true;
1094 }
1095
1096 return false;
1097}
1098
1099/**
1100 * Convenience method which attempts to find the attribute with the given
1101 * name and returns its value as a signed 32-bit integer.
1102 *
1103 * @param pcszMatch Name of attribute to find.
1104 * @param piValue Where to return the value.
1105 * @param pcszNamespace The attribute name space prefix or NULL.
1106 * @returns Boolean success indicator.
1107 */
1108bool ElementNode::getAttributeValue(const char *pcszMatch, int32_t *piValue, const char *pcszNamespace /*= NULL*/) const
1109{
1110 const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
1111 if (pcsz)
1112 {
1113 int rc = RTStrToInt32Ex(pcsz, NULL, 0, piValue);
1114 if (rc == VINF_SUCCESS)
1115 return true;
1116 VBOX_XML_STRICT_ASSERT_FAILED;
1117 }
1118 return false;
1119}
1120
1121/**
1122 * Convenience method which attempts to find the attribute with the given
1123 * name and returns its value as an unsigned 32-bit integer.
1124 *
1125 * @param pcszMatch Name of attribute to find.
1126 * @param puValue Where to return the value.
1127 * @param pcszNamespace The attribute name space prefix or NULL.
1128 * @returns Boolean success indicator.
1129 */
1130bool ElementNode::getAttributeValue(const char *pcszMatch, uint32_t *puValue, const char *pcszNamespace /*= NULL*/) const
1131{
1132 const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
1133 if (pcsz)
1134 {
1135 int rc = RTStrToUInt32Ex(pcsz, NULL, 0, puValue);
1136 if (rc == VINF_SUCCESS)
1137 return true;
1138 VBOX_XML_STRICT_ASSERT_FAILED;
1139 }
1140 return false;
1141}
1142
1143/**
1144 * Convenience method which attempts to find the attribute with the given
1145 * name and returns its value as a signed 64-bit integer.
1146 *
1147 * @param pcszMatch Name of attribute to find.
1148 * @param piValue Where to return the value.
1149 * @param pcszNamespace The attribute name space prefix or NULL.
1150 * @returns Boolean success indicator.
1151 */
1152bool ElementNode::getAttributeValue(const char *pcszMatch, int64_t *piValue, const char *pcszNamespace /*= NULL*/) const
1153{
1154 const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
1155 if (pcsz)
1156 {
1157 int rc = RTStrToInt64Ex(pcsz, NULL, 0, piValue);
1158 if (rc == VINF_SUCCESS)
1159 return true;
1160 VBOX_XML_STRICT_ASSERT_FAILED;
1161 }
1162 return false;
1163}
1164
1165/**
1166 * Convenience method which attempts to find the attribute with the given
1167 * name and returns its value as an unsigned 64-bit integer.
1168 *
1169 * @param pcszMatch Name of attribute to find.
1170 * @param puValue Where to return the value.
1171 * @param pcszNamespace The attribute name space prefix or NULL.
1172 * @returns Boolean success indicator.
1173 */
1174bool ElementNode::getAttributeValue(const char *pcszMatch, uint64_t *puValue, const char *pcszNamespace /*= NULL*/) const
1175{
1176 const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
1177 if (pcsz)
1178 {
1179 int rc = RTStrToUInt64Ex(pcsz, NULL, 0, puValue);
1180 if (rc == VINF_SUCCESS)
1181 return true;
1182 VBOX_XML_STRICT_ASSERT_FAILED;
1183 }
1184 return false;
1185}
1186
1187/**
1188 * Convenience method which attempts to find the attribute with the given
1189 * name and returns its value as a boolean. This accepts "true", "false",
1190 * "yes", "no", "1" or "0" as valid values.
1191 *
1192 * @param pcszMatch Name of attribute to find.
1193 * @param pfValue Where to return the value.
1194 * @param pcszNamespace The attribute name space prefix or NULL.
1195 * @returns Boolean success indicator.
1196 */
1197bool ElementNode::getAttributeValue(const char *pcszMatch, bool *pfValue, const char *pcszNamespace /*= NULL*/) const
1198{
1199 const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
1200 if (pcsz)
1201 {
1202 if ( !strcmp(pcsz, "true")
1203 || !strcmp(pcsz, "yes")
1204 || !strcmp(pcsz, "1")
1205 )
1206 {
1207 *pfValue = true;
1208 return true;
1209 }
1210 if ( !strcmp(pcsz, "false")
1211 || !strcmp(pcsz, "no")
1212 || !strcmp(pcsz, "0")
1213 )
1214 {
1215 *pfValue = false;
1216 return true;
1217 }
1218 VBOX_XML_STRICT_ASSERT_FAILED;
1219 }
1220 return false;
1221}
1222
1223/**
1224 * Convenience method which attempts to find the attribute with the given
1225 * name and returns its value as a string.
1226 *
1227 * @param pcszMatch Name of attribute to find.
1228 * @param ppcsz Where to return the attribute.
1229 * @param cchValueLimit If the length of the returned value exceeds this
1230 * limit a EIPRTFailure exception will be thrown.
1231 * @param pcszNamespace The attribute name space prefix or NULL.
1232 * @returns Boolean success indicator.
1233 */
1234bool ElementNode::getAttributeValueN(const char *pcszMatch, const char **ppcsz, size_t cchValueLimit, const char *pcszNamespace /*= NULL*/) const
1235{
1236 const AttributeNode *pAttr = findAttribute(pcszMatch, pcszNamespace);
1237 if (pAttr)
1238 {
1239 *ppcsz = pAttr->getValueN(cchValueLimit);
1240 return true;
1241 }
1242 return false;
1243}
1244
1245/**
1246 * Convenience method which attempts to find the attribute with the given
1247 * name and returns its value as a string.
1248 *
1249 * @param pcszMatch Name of attribute to find.
1250 * @param pStr Pointer to the string object that should receive the
1251 * attribute value.
1252 * @param cchValueLimit If the length of the returned value exceeds this
1253 * limit a EIPRTFailure exception will be thrown.
1254 * @param pcszNamespace The attribute name space prefix or NULL.
1255 * @returns Boolean success indicator.
1256 *
1257 * @throws Whatever the string class may throw on assignment.
1258 */
1259bool ElementNode::getAttributeValueN(const char *pcszMatch, RTCString *pStr, size_t cchValueLimit, const char *pcszNamespace /*= NULL*/) const
1260{
1261 const AttributeNode *pAttr = findAttribute(pcszMatch, pcszNamespace);
1262 if (pAttr)
1263 {
1264 *pStr = pAttr->getValueN(cchValueLimit);
1265 return true;
1266 }
1267
1268 return false;
1269}
1270
1271/**
1272 * Like getAttributeValue (ministring variant), but makes sure that all backslashes
1273 * are converted to forward slashes.
1274 *
1275 * @param pcszMatch Name of attribute to find.
1276 * @param pStr Pointer to the string object that should
1277 * receive the attribute path value.
1278 * @param cchValueLimit If the length of the returned value exceeds this
1279 * limit a EIPRTFailure exception will be thrown.
1280 * @param pcszNamespace The attribute name space prefix or NULL.
1281 * @returns Boolean success indicator.
1282 */
1283bool ElementNode::getAttributeValuePathN(const char *pcszMatch, RTCString *pStr, size_t cchValueLimit, const char *pcszNamespace /*= NULL*/) const
1284{
1285 if (getAttributeValueN(pcszMatch, pStr, cchValueLimit, pcszNamespace))
1286 {
1287 pStr->findReplace('\\', '/');
1288 return true;
1289 }
1290
1291 return false;
1292}
1293
1294
1295bool ElementNode::getElementValue(int32_t *piValue) const
1296{
1297 const char *pszValue = getValue();
1298 if (pszValue)
1299 {
1300 int rc = RTStrToInt32Ex(pszValue, NULL, 0, piValue);
1301 if (rc == VINF_SUCCESS)
1302 return true;
1303 }
1304 return false;
1305}
1306
1307bool ElementNode::getElementValue(uint32_t *puValue) const
1308{
1309 const char *pszValue = getValue();
1310 if (pszValue)
1311 {
1312 int rc = RTStrToUInt32Ex(pszValue, NULL, 0, puValue);
1313 if (rc == VINF_SUCCESS)
1314 return true;
1315 }
1316 return false;
1317}
1318
1319bool ElementNode::getElementValue(int64_t *piValue) const
1320{
1321 const char *pszValue = getValue();
1322 if (pszValue)
1323 {
1324 int rc = RTStrToInt64Ex(pszValue, NULL, 0, piValue);
1325 if (rc == VINF_SUCCESS)
1326 return true;
1327 }
1328 return false;
1329}
1330
1331bool ElementNode::getElementValue(uint64_t *puValue) const
1332{
1333 const char *pszValue = getValue();
1334 if (pszValue)
1335 {
1336 int rc = RTStrToUInt64Ex(pszValue, NULL, 0, puValue);
1337 if (rc == VINF_SUCCESS)
1338 return true;
1339 }
1340 return false;
1341}
1342
1343bool ElementNode::getElementValue(bool *pfValue) const
1344{
1345 const char *pszValue = getValue();
1346 if (pszValue)
1347 {
1348 if ( !strcmp(pszValue, "true")
1349 || !strcmp(pszValue, "yes")
1350 || !strcmp(pszValue, "1")
1351 )
1352 {
1353 *pfValue = true;
1354 return true;
1355 }
1356 if ( !strcmp(pszValue, "false")
1357 || !strcmp(pszValue, "no")
1358 || !strcmp(pszValue, "0")
1359 )
1360 {
1361 *pfValue = true;
1362 return true;
1363 }
1364 }
1365 return false;
1366}
1367
1368
1369/**
1370 * Creates a new child element node and appends it to the list
1371 * of children in "this".
1372 *
1373 * @param pcszElementName
1374 * @return
1375 */
1376ElementNode *ElementNode::createChild(const char *pcszElementName)
1377{
1378 // we must be an element, not an attribute
1379 if (!m_pLibNode)
1380 throw ENodeIsNotElement(RT_SRC_POS);
1381
1382 // libxml side: create new node
1383 xmlNode *pLibNode;
1384 if (!(pLibNode = xmlNewNode(NULL, // namespace
1385 (const xmlChar*)pcszElementName)))
1386 throw std::bad_alloc();
1387 xmlAddChild(m_pLibNode, pLibNode);
1388
1389 // now wrap this in C++
1390 ElementNode *p = new ElementNode(m_pElmRoot, this, &m_children, pLibNode);
1391 RTListAppend(&m_children, &p->m_listEntry);
1392
1393 return p;
1394}
1395
1396
1397/**
1398 * Creates a content node and appends it to the list of children
1399 * in "this".
1400 *
1401 * @param pcszContent
1402 * @return
1403 */
1404ContentNode *ElementNode::addContent(const char *pcszContent)
1405{
1406 // libxml side: create new node
1407 xmlNode *pLibNode = xmlNewText((const xmlChar*)pcszContent);
1408 if (!pLibNode)
1409 throw std::bad_alloc();
1410 xmlAddChild(m_pLibNode, pLibNode);
1411
1412 // now wrap this in C++
1413 ContentNode *p = new ContentNode(this, &m_children, pLibNode);
1414 RTListAppend(&m_children, &p->m_listEntry);
1415
1416 return p;
1417}
1418
1419/**
1420 * Changes the contents of node and appends it to the list of
1421 * children
1422 *
1423 * @param pcszContent
1424 * @return
1425 */
1426ContentNode *ElementNode::setContent(const char *pcszContent)
1427{
1428// 1. Update content
1429 xmlNodeSetContent(m_pLibNode, (const xmlChar*)pcszContent);
1430
1431// 2. Remove Content node from the list
1432 /* Check that the order is right. */
1433 xml::Node * pNode;
1434 RTListForEachCpp(&m_children, pNode, xml::Node, m_listEntry)
1435 {
1436 bool fLast = RTListNodeIsLast(&m_children, &pNode->m_listEntry);
1437
1438 if (pNode->isContent())
1439 {
1440 RTListNodeRemove(&pNode->m_listEntry);
1441 }
1442
1443 if (fLast)
1444 break;
1445 }
1446
1447// 3. Create a new node and append to the list
1448 // now wrap this in C++
1449 ContentNode *pCNode = new ContentNode(this, &m_children, m_pLibNode);
1450 RTListAppend(&m_children, &pCNode->m_listEntry);
1451
1452 return pCNode;
1453}
1454
1455/**
1456 * Sets the given attribute; overloaded version for const char *.
1457 *
1458 * If an attribute with the given name exists, it is overwritten,
1459 * otherwise a new attribute is created. Returns the attribute node
1460 * that was either created or changed.
1461 *
1462 * @param pcszName The attribute name.
1463 * @param pcszValue The attribute value.
1464 * @return Pointer to the attribute node that was created or modified.
1465 */
1466AttributeNode *ElementNode::setAttribute(const char *pcszName, const char *pcszValue)
1467{
1468 /*
1469 * Do we already have an attribute and should we just update it?
1470 */
1471 AttributeNode *pAttr;
1472 RTListForEachCpp(&m_attributes, pAttr, AttributeNode, m_listEntry)
1473 {
1474 if (pAttr->nameEquals(pcszName))
1475 {
1476 /* Overwrite existing libxml attribute node ... */
1477 xmlAttrPtr pLibAttr = xmlSetProp(m_pLibNode, (xmlChar *)pcszName, (xmlChar *)pcszValue);
1478
1479 /* ... and update our C++ wrapper in case the attrib pointer changed. */
1480 pAttr->m_pLibAttr = pLibAttr;
1481 return pAttr;
1482 }
1483 }
1484
1485 /*
1486 * No existing attribute, create a new one.
1487 */
1488 /* libxml side: xmlNewProp creates an attribute. */
1489 xmlAttr *pLibAttr = xmlNewProp(m_pLibNode, (xmlChar *)pcszName, (xmlChar *)pcszValue);
1490
1491 /* C++ side: Create an attribute node around it. */
1492 pAttr = new AttributeNode(m_pElmRoot, this, &m_attributes, pLibAttr);
1493 RTListAppend(&m_attributes, &pAttr->m_listEntry);
1494
1495 return pAttr;
1496}
1497
1498/**
1499 * Like setAttribute (ministring variant), but replaces all backslashes with forward slashes
1500 * before calling that one.
1501 * @param pcszName
1502 * @param strValue
1503 * @return
1504 */
1505AttributeNode* ElementNode::setAttributePath(const char *pcszName, const RTCString &strValue)
1506{
1507 RTCString strTemp(strValue);
1508 strTemp.findReplace('\\', '/');
1509 return setAttribute(pcszName, strTemp.c_str());
1510}
1511
1512/**
1513 * Sets the given attribute; overloaded version for int32_t.
1514 *
1515 * If an attribute with the given name exists, it is overwritten,
1516 * otherwise a new attribute is created. Returns the attribute node
1517 * that was either created or changed.
1518 *
1519 * @param pcszName
1520 * @param i
1521 * @return
1522 */
1523AttributeNode* ElementNode::setAttribute(const char *pcszName, int32_t i)
1524{
1525 char szValue[12]; // negative sign + 10 digits + \0
1526 RTStrPrintf(szValue, sizeof(szValue), "%RI32", i);
1527 AttributeNode *p = setAttribute(pcszName, szValue);
1528 return p;
1529}
1530
1531/**
1532 * Sets the given attribute; overloaded version for uint32_t.
1533 *
1534 * If an attribute with the given name exists, it is overwritten,
1535 * otherwise a new attribute is created. Returns the attribute node
1536 * that was either created or changed.
1537 *
1538 * @param pcszName
1539 * @param u
1540 * @return
1541 */
1542AttributeNode* ElementNode::setAttribute(const char *pcszName, uint32_t u)
1543{
1544 char szValue[11]; // 10 digits + \0
1545 RTStrPrintf(szValue, sizeof(szValue), "%RU32", u);
1546 AttributeNode *p = setAttribute(pcszName, szValue);
1547 return p;
1548}
1549
1550/**
1551 * Sets the given attribute; overloaded version for int64_t.
1552 *
1553 * If an attribute with the given name exists, it is overwritten,
1554 * otherwise a new attribute is created. Returns the attribute node
1555 * that was either created or changed.
1556 *
1557 * @param pcszName
1558 * @param i
1559 * @return
1560 */
1561AttributeNode* ElementNode::setAttribute(const char *pcszName, int64_t i)
1562{
1563 char szValue[21]; // negative sign + 19 digits + \0
1564 RTStrPrintf(szValue, sizeof(szValue), "%RI64", i);
1565 AttributeNode *p = setAttribute(pcszName, szValue);
1566 return p;
1567}
1568
1569/**
1570 * Sets the given attribute; overloaded version for uint64_t.
1571 *
1572 * If an attribute with the given name exists, it is overwritten,
1573 * otherwise a new attribute is created. Returns the attribute node
1574 * that was either created or changed.
1575 *
1576 * @param pcszName
1577 * @param u
1578 * @return
1579 */
1580AttributeNode* ElementNode::setAttribute(const char *pcszName, uint64_t u)
1581{
1582 char szValue[21]; // 20 digits + \0
1583 RTStrPrintf(szValue, sizeof(szValue), "%RU64", u);
1584 AttributeNode *p = setAttribute(pcszName, szValue);
1585 return p;
1586}
1587
1588/**
1589 * Sets the given attribute to the given uint32_t, outputs a hexadecimal string.
1590 *
1591 * If an attribute with the given name exists, it is overwritten,
1592 * otherwise a new attribute is created. Returns the attribute node
1593 * that was either created or changed.
1594 *
1595 * @param pcszName
1596 * @param u
1597 * @return
1598 */
1599AttributeNode* ElementNode::setAttributeHex(const char *pcszName, uint32_t u)
1600{
1601 char szValue[11]; // "0x" + 8 digits + \0
1602 RTStrPrintf(szValue, sizeof(szValue), "0x%RX32", u);
1603 AttributeNode *p = setAttribute(pcszName, szValue);
1604 return p;
1605}
1606
1607/**
1608 * Sets the given attribute; overloaded version for bool.
1609 *
1610 * If an attribute with the given name exists, it is overwritten,
1611 * otherwise a new attribute is created. Returns the attribute node
1612 * that was either created or changed.
1613 *
1614 * @param pcszName The attribute name.
1615 * @param f The attribute value.
1616 * @return
1617 */
1618AttributeNode* ElementNode::setAttribute(const char *pcszName, bool f)
1619{
1620 return setAttribute(pcszName, (f) ? "true" : "false");
1621}
1622
1623/**
1624 * Private constructor for a new attribute node.
1625 *
1626 * @param pElmRoot Pointer to the root element. Needed for getting the
1627 * default name space.
1628 * @param pParent Pointer to the parent element (always an ElementNode,
1629 * despite the type). NULL for the root node.
1630 * @param pListAnchor Pointer to the m_children member of the parent. NULL
1631 * for the root node.
1632 * @param pLibAttr Pointer to the libxml2 attribute structure.
1633 */
1634AttributeNode::AttributeNode(const ElementNode *pElmRoot,
1635 Node *pParent,
1636 PRTLISTANCHOR pListAnchor,
1637 xmlAttr *pLibAttr)
1638 : Node(IsAttribute,
1639 pParent,
1640 pListAnchor,
1641 NULL,
1642 pLibAttr)
1643{
1644 m_pcszName = (const char *)pLibAttr->name;
1645 RT_NOREF_PV(pElmRoot);
1646
1647 if ( pLibAttr->ns
1648 && pLibAttr->ns->prefix)
1649 {
1650 m_pcszNamespacePrefix = (const char *)pLibAttr->ns->prefix;
1651 m_pcszNamespaceHref = (const char *)pLibAttr->ns->href;
1652 }
1653}
1654
1655ContentNode::ContentNode(Node *pParent, PRTLISTANCHOR pListAnchor, xmlNode *pLibNode)
1656 : Node(IsContent,
1657 pParent,
1658 pListAnchor,
1659 pLibNode,
1660 NULL)
1661{
1662}
1663
1664/*
1665 * NodesLoop
1666 *
1667 */
1668
1669struct NodesLoop::Data
1670{
1671 ElementNodesList listElements;
1672 ElementNodesList::const_iterator it;
1673};
1674
1675NodesLoop::NodesLoop(const ElementNode &node, const char *pcszMatch /* = NULL */)
1676{
1677 m = new Data;
1678 node.getChildElements(m->listElements, pcszMatch);
1679 m->it = m->listElements.begin();
1680}
1681
1682NodesLoop::~NodesLoop()
1683{
1684 delete m;
1685}
1686
1687
1688/**
1689 * Handy convenience helper for looping over all child elements. Create an
1690 * instance of NodesLoop on the stack and call this method until it returns
1691 * NULL, like this:
1692 * <code>
1693 * xml::ElementNode node; // should point to an element
1694 * xml::NodesLoop loop(node, "child"); // find all "child" elements under node
1695 * const xml::ElementNode *pChild = NULL;
1696 * while (pChild = loop.forAllNodes())
1697 * ...;
1698 * </code>
1699 * @return
1700 */
1701const ElementNode* NodesLoop::forAllNodes() const
1702{
1703 const ElementNode *pNode = NULL;
1704
1705 if (m->it != m->listElements.end())
1706 {
1707 pNode = *(m->it);
1708 ++(m->it);
1709 }
1710
1711 return pNode;
1712}
1713
1714////////////////////////////////////////////////////////////////////////////////
1715//
1716// Document class
1717//
1718////////////////////////////////////////////////////////////////////////////////
1719
1720struct Document::Data
1721{
1722 xmlDocPtr plibDocument;
1723 ElementNode *pRootElement;
1724 ElementNode *pComment;
1725
1726 Data()
1727 {
1728 plibDocument = NULL;
1729 pRootElement = NULL;
1730 pComment = NULL;
1731 }
1732
1733 ~Data()
1734 {
1735 reset();
1736 }
1737
1738 void reset()
1739 {
1740 if (plibDocument)
1741 {
1742 xmlFreeDoc(plibDocument);
1743 plibDocument = NULL;
1744 }
1745 if (pRootElement)
1746 {
1747 delete pRootElement;
1748 pRootElement = NULL;
1749 }
1750 if (pComment)
1751 {
1752 delete pComment;
1753 pComment = NULL;
1754 }
1755 }
1756
1757 void copyFrom(const Document::Data *p)
1758 {
1759 if (p->plibDocument)
1760 {
1761 plibDocument = xmlCopyDoc(p->plibDocument,
1762 1); // recursive == copy all
1763 }
1764 }
1765};
1766
1767Document::Document()
1768 : m(new Data)
1769{
1770}
1771
1772Document::Document(const Document &x)
1773 : m(new Data)
1774{
1775 m->copyFrom(x.m);
1776}
1777
1778Document& Document::operator=(const Document &x)
1779{
1780 m->reset();
1781 m->copyFrom(x.m);
1782 return *this;
1783}
1784
1785Document::~Document()
1786{
1787 delete m;
1788}
1789
1790/**
1791 * private method to refresh all internal structures after the internal pDocument
1792 * has changed. Called from XmlFileParser::read(). m->reset() must have been
1793 * called before to make sure all members except the internal pDocument are clean.
1794 */
1795void Document::refreshInternals() // private
1796{
1797 m->pRootElement = new ElementNode(NULL, NULL, NULL, xmlDocGetRootElement(m->plibDocument));
1798
1799 ElementNode::buildChildren(m->pRootElement);
1800}
1801
1802/**
1803 * Returns the root element of the document, or NULL if the document is empty.
1804 * Const variant.
1805 * @return
1806 */
1807const ElementNode *Document::getRootElement() const
1808{
1809 return m->pRootElement;
1810}
1811
1812/**
1813 * Returns the root element of the document, or NULL if the document is empty.
1814 * Non-const variant.
1815 * @return
1816 */
1817ElementNode *Document::getRootElement()
1818{
1819 return m->pRootElement;
1820}
1821
1822/**
1823 * Creates a new element node and sets it as the root element.
1824 *
1825 * This will only work if the document is empty; otherwise EDocumentNotEmpty is
1826 * thrown.
1827 */
1828ElementNode *Document::createRootElement(const char *pcszRootElementName,
1829 const char *pcszComment /* = NULL */)
1830{
1831 if (m->pRootElement || m->plibDocument)
1832 throw EDocumentNotEmpty(RT_SRC_POS);
1833
1834 // libxml side: create document, create root node
1835 m->plibDocument = xmlNewDoc((const xmlChar *)"1.0");
1836 xmlNode *plibRootNode = xmlNewNode(NULL /*namespace*/ , (const xmlChar *)pcszRootElementName);
1837 if (!plibRootNode)
1838 throw std::bad_alloc();
1839 xmlDocSetRootElement(m->plibDocument, plibRootNode);
1840
1841 // now wrap this in C++
1842 m->pRootElement = new ElementNode(NULL, NULL, NULL, plibRootNode);
1843
1844 // add document global comment if specified
1845 if (pcszComment != NULL)
1846 {
1847 xmlNode *pComment = xmlNewDocComment(m->plibDocument, (const xmlChar *)pcszComment);
1848 if (!pComment)
1849 throw std::bad_alloc();
1850 xmlAddPrevSibling(plibRootNode, pComment);
1851
1852 // now wrap this in C++
1853 m->pComment = new ElementNode(NULL, NULL, NULL, pComment);
1854 }
1855
1856 return m->pRootElement;
1857}
1858
1859////////////////////////////////////////////////////////////////////////////////
1860//
1861// XmlParserBase class
1862//
1863////////////////////////////////////////////////////////////////////////////////
1864
1865static void xmlParserBaseGenericError(void *pCtx, const char *pszMsg, ...) RT_NOTHROW_DEF
1866{
1867 NOREF(pCtx);
1868 va_list args;
1869 va_start(args, pszMsg);
1870 RTLogRelPrintfV(pszMsg, args);
1871 va_end(args);
1872}
1873
1874static void xmlParserBaseStructuredError(void *pCtx, xmlErrorPtr error) RT_NOTHROW_DEF
1875{
1876 NOREF(pCtx);
1877 /* we expect that there is always a trailing NL */
1878 LogRel(("XML error at '%s' line %d: %s", error->file, error->line, error->message));
1879}
1880
1881XmlParserBase::XmlParserBase()
1882{
1883 m_ctxt = xmlNewParserCtxt();
1884 if (m_ctxt == NULL)
1885 throw std::bad_alloc();
1886 /* per-thread so it must be here */
1887 xmlSetGenericErrorFunc(NULL, xmlParserBaseGenericError);
1888 xmlSetStructuredErrorFunc(NULL, xmlParserBaseStructuredError);
1889}
1890
1891XmlParserBase::~XmlParserBase()
1892{
1893 xmlSetStructuredErrorFunc(NULL, NULL);
1894 xmlSetGenericErrorFunc(NULL, NULL);
1895 xmlFreeParserCtxt (m_ctxt);
1896 m_ctxt = NULL;
1897}
1898
1899////////////////////////////////////////////////////////////////////////////////
1900//
1901// XmlMemParser class
1902//
1903////////////////////////////////////////////////////////////////////////////////
1904
1905XmlMemParser::XmlMemParser()
1906 : XmlParserBase()
1907{
1908}
1909
1910XmlMemParser::~XmlMemParser()
1911{
1912}
1913
1914/**
1915 * Parse the given buffer and fills the given Document object with its contents.
1916 * Throws XmlError on parsing errors.
1917 *
1918 * The document that is passed in will be reset before being filled if not empty.
1919 *
1920 * @param pvBuf Memory buffer to parse.
1921 * @param cbSize Size of the memory buffer.
1922 * @param strFilename Refernece to the name of the file we're parsing.
1923 * @param doc Reference to the output document. This will be reset
1924 * and filled with data according to file contents.
1925 */
1926void XmlMemParser::read(const void *pvBuf, size_t cbSize,
1927 const RTCString &strFilename,
1928 Document &doc)
1929{
1930 GlobalLock lock;
1931// global.setExternalEntityLoader(ExternalEntityLoader);
1932
1933 const char *pcszFilename = strFilename.c_str();
1934
1935 doc.m->reset();
1936 const int options = XML_PARSE_NOBLANKS /* remove blank nodes */
1937 | XML_PARSE_NONET /* forbit any network access */
1938#if LIBXML_VERSION >= 20700
1939 | XML_PARSE_HUGE /* don't restrict the node depth
1940 to 256 (bad for snapshots!) */
1941#endif
1942 ;
1943 if (!(doc.m->plibDocument = xmlCtxtReadMemory(m_ctxt,
1944 (const char*)pvBuf,
1945 (int)cbSize,
1946 pcszFilename,
1947 NULL, // encoding = auto
1948 options)))
1949 throw XmlError(xmlCtxtGetLastError(m_ctxt));
1950
1951 doc.refreshInternals();
1952}
1953
1954////////////////////////////////////////////////////////////////////////////////
1955//
1956// XmlMemWriter class
1957//
1958////////////////////////////////////////////////////////////////////////////////
1959
1960XmlMemWriter::XmlMemWriter()
1961 : m_pBuf(0)
1962{
1963}
1964
1965XmlMemWriter::~XmlMemWriter()
1966{
1967 if (m_pBuf)
1968 xmlFree(m_pBuf);
1969}
1970
1971void XmlMemWriter::write(const Document &doc, void **ppvBuf, size_t *pcbSize)
1972{
1973 if (m_pBuf)
1974 {
1975 xmlFree(m_pBuf);
1976 m_pBuf = 0;
1977 }
1978 int size;
1979 xmlDocDumpFormatMemory(doc.m->plibDocument, (xmlChar**)&m_pBuf, &size, 1);
1980 *ppvBuf = m_pBuf;
1981 *pcbSize = size;
1982}
1983
1984
1985////////////////////////////////////////////////////////////////////////////////
1986//
1987// XmlStringWriter class
1988//
1989////////////////////////////////////////////////////////////////////////////////
1990
1991XmlStringWriter::XmlStringWriter()
1992 : m_pStrDst(NULL), m_fOutOfMemory(false)
1993{
1994}
1995
1996int XmlStringWriter::write(const Document &rDoc, RTCString *pStrDst)
1997{
1998 /*
1999 * Clear the output string and take the global libxml2 lock so we can
2000 * safely configure the output formatting.
2001 */
2002 pStrDst->setNull();
2003
2004 GlobalLock lock;
2005
2006 xmlIndentTreeOutput = 1;
2007 xmlTreeIndentString = " ";
2008 xmlSaveNoEmptyTags = 0;
2009
2010 /*
2011 * Do a pass to calculate the size.
2012 */
2013 size_t cbOutput = 1; /* zero term */
2014
2015 xmlSaveCtxtPtr pSaveCtx= xmlSaveToIO(WriteCallbackForSize, CloseCallback, &cbOutput, NULL /*pszEncoding*/, XML_SAVE_FORMAT);
2016 if (!pSaveCtx)
2017 return VERR_NO_MEMORY;
2018
2019 long rcXml = xmlSaveDoc(pSaveCtx, rDoc.m->plibDocument);
2020 xmlSaveClose(pSaveCtx);
2021 if (rcXml == -1)
2022 return VERR_GENERAL_FAILURE;
2023
2024 /*
2025 * Try resize the string.
2026 */
2027 int rc = pStrDst->reserveNoThrow(cbOutput);
2028 if (RT_SUCCESS(rc))
2029 {
2030 /*
2031 * Do the real run where we feed output to the string.
2032 */
2033 m_pStrDst = pStrDst;
2034 m_fOutOfMemory = false;
2035 pSaveCtx = xmlSaveToIO(WriteCallbackForReal, CloseCallback, this, NULL /*pszEncoding*/, XML_SAVE_FORMAT);
2036 if (pSaveCtx)
2037 {
2038 rcXml = xmlSaveDoc(pSaveCtx, rDoc.m->plibDocument);
2039 xmlSaveClose(pSaveCtx);
2040 m_pStrDst = NULL;
2041 if (rcXml != -1)
2042 {
2043 if (!m_fOutOfMemory)
2044 return VINF_SUCCESS;
2045
2046 rc = VERR_NO_STR_MEMORY;
2047 }
2048 else
2049 rc = VERR_GENERAL_FAILURE;
2050 }
2051 else
2052 rc = VERR_NO_MEMORY;
2053 pStrDst->setNull();
2054 m_pStrDst = NULL;
2055 }
2056 return rc;
2057}
2058
2059/*static*/ int XmlStringWriter::WriteCallbackForSize(void *pvUser, const char *pachBuf, int cbToWrite) RT_NOTHROW_DEF
2060{
2061 if (cbToWrite > 0)
2062 *(size_t *)pvUser += (unsigned)cbToWrite;
2063 RT_NOREF(pachBuf);
2064 return cbToWrite;
2065}
2066
2067/*static*/ int XmlStringWriter::WriteCallbackForReal(void *pvUser, const char *pachBuf, int cbToWrite) RT_NOTHROW_DEF
2068{
2069 XmlStringWriter *pThis = static_cast<XmlStringWriter*>(pvUser);
2070 if (!pThis->m_fOutOfMemory)
2071 {
2072 if (cbToWrite > 0)
2073 {
2074 try
2075 {
2076 pThis->m_pStrDst->append(pachBuf, (size_t)cbToWrite);
2077 }
2078 catch (std::bad_alloc &)
2079 {
2080 pThis->m_fOutOfMemory = true;
2081 return -1;
2082 }
2083 }
2084 return cbToWrite;
2085 }
2086 return -1; /* failure */
2087}
2088
2089/*static*/ int XmlStringWriter::CloseCallback(void *pvUser) RT_NOTHROW_DEF
2090{
2091 /* Nothing to do here. */
2092 RT_NOREF(pvUser);
2093 return 0;
2094}
2095
2096
2097
2098////////////////////////////////////////////////////////////////////////////////
2099//
2100// XmlFileParser class
2101//
2102////////////////////////////////////////////////////////////////////////////////
2103
2104struct XmlFileParser::Data
2105{
2106 RTCString strXmlFilename;
2107
2108 Data()
2109 {
2110 }
2111
2112 ~Data()
2113 {
2114 }
2115};
2116
2117XmlFileParser::XmlFileParser()
2118 : XmlParserBase(),
2119 m(new Data())
2120{
2121}
2122
2123XmlFileParser::~XmlFileParser()
2124{
2125 delete m;
2126 m = NULL;
2127}
2128
2129struct IOContext
2130{
2131 File file;
2132 RTCString error;
2133
2134 IOContext(const char *pcszFilename, File::Mode mode, bool fFlush = false)
2135 : file(mode, pcszFilename, fFlush)
2136 {
2137 }
2138
2139 void setError(const RTCError &x)
2140 {
2141 error = x.what();
2142 }
2143
2144 void setError(const std::exception &x)
2145 {
2146 error = x.what();
2147 }
2148
2149private:
2150 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(IOContext); /* (shuts up C4626 and C4625 MSC warnings) */
2151};
2152
2153struct ReadContext : IOContext
2154{
2155 ReadContext(const char *pcszFilename)
2156 : IOContext(pcszFilename, File::Mode_Read)
2157 {
2158 }
2159
2160private:
2161 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ReadContext); /* (shuts up C4626 and C4625 MSC warnings) */
2162};
2163
2164struct WriteContext : IOContext
2165{
2166 WriteContext(const char *pcszFilename, bool fFlush)
2167 : IOContext(pcszFilename, File::Mode_Overwrite, fFlush)
2168 {
2169 }
2170
2171private:
2172 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(WriteContext); /* (shuts up C4626 and C4625 MSC warnings) */
2173};
2174
2175/**
2176 * Reads the given file and fills the given Document object with its contents.
2177 * Throws XmlError on parsing errors.
2178 *
2179 * The document that is passed in will be reset before being filled if not empty.
2180 *
2181 * @param strFilename in: name fo file to parse.
2182 * @param doc out: document to be reset and filled with data according to file contents.
2183 */
2184void XmlFileParser::read(const RTCString &strFilename,
2185 Document &doc)
2186{
2187 GlobalLock lock;
2188// global.setExternalEntityLoader(ExternalEntityLoader);
2189
2190 m->strXmlFilename = strFilename;
2191 const char *pcszFilename = strFilename.c_str();
2192
2193 ReadContext context(pcszFilename);
2194 doc.m->reset();
2195 const int options = XML_PARSE_NOBLANKS /* remove blank nodes */
2196 | XML_PARSE_NONET /* forbit any network access */
2197#if LIBXML_VERSION >= 20700
2198 | XML_PARSE_HUGE /* don't restrict the node depth
2199 to 256 (bad for snapshots!) */
2200#endif
2201 ;
2202 if (!(doc.m->plibDocument = xmlCtxtReadIO(m_ctxt,
2203 ReadCallback,
2204 CloseCallback,
2205 &context,
2206 pcszFilename,
2207 NULL, // encoding = auto
2208 options)))
2209 throw XmlError(xmlCtxtGetLastError(m_ctxt));
2210
2211 doc.refreshInternals();
2212}
2213
2214/*static*/ int XmlFileParser::ReadCallback(void *aCtxt, char *aBuf, int aLen) RT_NOTHROW_DEF
2215{
2216 ReadContext *pContext = static_cast<ReadContext*>(aCtxt);
2217
2218 /* To prevent throwing exceptions while inside libxml2 code, we catch
2219 * them and forward to our level using a couple of variables. */
2220
2221 try
2222 {
2223 return pContext->file.read(aBuf, aLen);
2224 }
2225 catch (const xml::EIPRTFailure &err) { pContext->setError(err); }
2226 catch (const RTCError &err) { pContext->setError(err); }
2227 catch (const std::exception &err) { pContext->setError(err); }
2228 catch (...) { pContext->setError(xml::LogicError(RT_SRC_POS)); }
2229
2230 return -1 /* failure */;
2231}
2232
2233/*static*/ int XmlFileParser::CloseCallback(void *aCtxt) RT_NOTHROW_DEF
2234{
2235 /// @todo to be written
2236 NOREF(aCtxt);
2237
2238 return -1;
2239}
2240
2241////////////////////////////////////////////////////////////////////////////////
2242//
2243// XmlFileWriter class
2244//
2245////////////////////////////////////////////////////////////////////////////////
2246
2247struct XmlFileWriter::Data
2248{
2249 Document *pDoc;
2250};
2251
2252XmlFileWriter::XmlFileWriter(Document &doc)
2253{
2254 m = new Data();
2255 m->pDoc = &doc;
2256}
2257
2258XmlFileWriter::~XmlFileWriter()
2259{
2260 delete m;
2261}
2262
2263void XmlFileWriter::writeInternal(const char *pcszFilename, bool fSafe)
2264{
2265 WriteContext context(pcszFilename, fSafe);
2266
2267 GlobalLock lock;
2268
2269 /* serialize to the stream */
2270 xmlIndentTreeOutput = 1;
2271 xmlTreeIndentString = " ";
2272 xmlSaveNoEmptyTags = 0;
2273
2274 xmlSaveCtxtPtr saveCtxt;
2275 if (!(saveCtxt = xmlSaveToIO(WriteCallback,
2276 CloseCallback,
2277 &context,
2278 NULL,
2279 XML_SAVE_FORMAT)))
2280 throw xml::LogicError(RT_SRC_POS);
2281
2282 long rc = xmlSaveDoc(saveCtxt, m->pDoc->m->plibDocument);
2283 if (rc == -1)
2284 {
2285 /* look if there was a forwarded exception from the lower level */
2286// if (m->trappedErr.get() != NULL)
2287// m->trappedErr->rethrow();
2288
2289 /* there must be an exception from the Output implementation,
2290 * otherwise the save operation must always succeed. */
2291 throw xml::LogicError(RT_SRC_POS);
2292 }
2293
2294 xmlSaveClose(saveCtxt);
2295}
2296
2297void XmlFileWriter::write(const char *pcszFilename, bool fSafe)
2298{
2299 if (!fSafe)
2300 writeInternal(pcszFilename, fSafe);
2301 else
2302 {
2303 /* Empty string and directory spec must be avoid. */
2304 if (RTPathFilename(pcszFilename) == NULL)
2305 throw xml::LogicError(RT_SRC_POS);
2306
2307 /* Construct both filenames first to ease error handling. */
2308 size_t const cchFilename = strlen(pcszFilename);
2309 size_t const cchTmpSuff = strlen(s_pszTmpSuff);
2310 size_t const cchPrevSuff = strlen(s_pszPrevSuff);
2311 AssertStmt(cchFilename + RT_MAX(cchTmpSuff, cchPrevSuff) < RTPATH_MAX,
2312 throw EIPRTFailure(VERR_BUFFER_OVERFLOW, "filename to long (%zu)", cchFilename));
2313
2314 char szTmpFilename[RTPATH_MAX];
2315 memcpy(mempcpy(szTmpFilename, pcszFilename, cchFilename), s_pszTmpSuff, cchTmpSuff + 1);
2316
2317 char szPrevFilename[RTPATH_MAX];
2318 memcpy(mempcpy(szPrevFilename, pcszFilename, cchFilename), s_pszPrevSuff, cchPrevSuff + 1);
2319
2320 /* Write the XML document to the temporary file. */
2321 writeInternal(szTmpFilename, fSafe);
2322
2323 /* Make a backup of any existing file (ignore failure). */
2324 uint64_t cbPrevFile;
2325 int rc = RTFileQuerySizeByPath(pcszFilename, &cbPrevFile);
2326 if (RT_SUCCESS(rc) && cbPrevFile >= 16)
2327 RTFileRename(pcszFilename, szPrevFilename, RTPATHRENAME_FLAGS_REPLACE);
2328
2329 /* Commit the temporary file. Just leave the tmp file behind on failure. */
2330 rc = RTFileRename(szTmpFilename, pcszFilename, RTPATHRENAME_FLAGS_REPLACE);
2331 if (RT_FAILURE(rc))
2332 throw EIPRTFailure(rc, "Failed to replace '%s' with '%s'", pcszFilename, szTmpFilename);
2333
2334 /* Flush the directory changes (required on linux at least). */
2335 RTPathStripFilename(szTmpFilename);
2336 rc = RTDirFlush(szTmpFilename);
2337 AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_SUPPORTED || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
2338 }
2339}
2340
2341/*static*/ int XmlFileWriter::WriteCallback(void *aCtxt, const char *aBuf, int aLen) RT_NOTHROW_DEF
2342{
2343 WriteContext *pContext = static_cast<WriteContext*>(aCtxt);
2344
2345 /* To prevent throwing exceptions while inside libxml2 code, we catch
2346 * them and forward to our level using a couple of variables. */
2347 try
2348 {
2349 return pContext->file.write(aBuf, aLen);
2350 }
2351 catch (const xml::EIPRTFailure &err) { pContext->setError(err); }
2352 catch (const RTCError &err) { pContext->setError(err); }
2353 catch (const std::exception &err) { pContext->setError(err); }
2354 catch (...) { pContext->setError(xml::LogicError(RT_SRC_POS)); }
2355
2356 return -1 /* failure */;
2357}
2358
2359/*static*/ int XmlFileWriter::CloseCallback(void *aCtxt) RT_NOTHROW_DEF
2360{
2361 /// @todo to be written
2362 NOREF(aCtxt);
2363
2364 return -1;
2365}
2366
2367/*static*/ const char * const XmlFileWriter::s_pszTmpSuff = "-tmp";
2368/*static*/ const char * const XmlFileWriter::s_pszPrevSuff = "-prev";
2369
2370
2371} // end namespace xml
2372
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette