632 lines
18 KiB
C++
632 lines
18 KiB
C++
/**
|
|
* utils.cpp
|
|
* Yet Another Jabber Component Protocol Stack
|
|
* This file is part of the YATE Project http://YATE.null.ro
|
|
*
|
|
* Yet Another Telephony Engine - a fully featured software PBX and IVR
|
|
* Copyright (C) 2004-2006 Null Team
|
|
*
|
|
* This program 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 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <xmpputils.h>
|
|
#include <string.h>
|
|
|
|
using namespace TelEngine;
|
|
|
|
static XMPPNamespace s_ns;
|
|
static XMPPError s_err;
|
|
|
|
TokenDict XMPPServerInfo::s_flagName[] = {
|
|
{"noautorestart", NoAutoRestart},
|
|
{"keeproster", KeepRoster},
|
|
{"noversion1", NoVersion1},
|
|
{"tlsrequired", TlsRequired},
|
|
{"sasl", Sasl},
|
|
{"allowplainauth", AllowPlainAuth},
|
|
{0,0}
|
|
};
|
|
|
|
TokenDict XMPPDirVal::s_names[] = {
|
|
{"none", None},
|
|
{"to", To},
|
|
{"from", From},
|
|
{"both", Both},
|
|
{0,0},
|
|
};
|
|
|
|
/**
|
|
* XMPPNamespace
|
|
*/
|
|
TokenDict XMPPNamespace::s_value[] = {
|
|
{"http://etherx.jabber.org/streams", Stream},
|
|
{"jabber:client", Client},
|
|
{"jabber:server", Server},
|
|
{"jabber:component:accept", ComponentAccept},
|
|
{"jabber:component:connect", ComponentConnect},
|
|
{"urn:ietf:params:xml:ns:xmpp-streams", StreamError},
|
|
{"urn:ietf:params:xml:ns:xmpp-stanzas", StanzaError},
|
|
{"http://jabber.org/features/iq-register", Register},
|
|
{"jabber:iq:auth", IqAuth},
|
|
{"http://jabber.org/features/iq-auth", IqAuthFeature},
|
|
{"urn:ietf:params:xml:ns:xmpp-tls", Starttls},
|
|
{"urn:ietf:params:xml:ns:xmpp-sasl", Sasl},
|
|
{"urn:ietf:params:xml:ns:xmpp-session", Session},
|
|
{"urn:ietf:params:xml:ns:xmpp-bind", Bind},
|
|
{"jabber:iq:roster", Roster},
|
|
{"http://jabber.org/protocol/disco#info", DiscoInfo},
|
|
{"http://jabber.org/protocol/disco#items", DiscoItems},
|
|
{"http://www.google.com/session", Jingle},
|
|
{"http://www.google.com/session/phone", JingleAudio},
|
|
{"http://www.google.com/transport/p2p", JingleTransport},
|
|
{"http://jabber.org/protocol/jingle/info/dtmf", Dtmf},
|
|
{"http://jabber.org/protocol/jingle/info/dtmf#errors", DtmfError},
|
|
{"http://jabber.org/protocol/commands", Command},
|
|
{"http://www.google.com/xmpp/protocol/voice/v1", CapVoiceV1},
|
|
{0,0}
|
|
};
|
|
|
|
bool XMPPNamespace::isText(Type index, const char* txt)
|
|
{
|
|
const char* tmp = lookup(index,s_value,0);
|
|
if (!(txt && tmp))
|
|
return false;
|
|
return 0 == strcmp(tmp,txt);
|
|
}
|
|
|
|
/**
|
|
* XMPPError
|
|
*/
|
|
TokenDict XMPPError::s_value[] = {
|
|
{"cancel", TypeCancel},
|
|
{"continue", TypeContinue},
|
|
{"modify", TypeModify},
|
|
{"auth", TypeAuth},
|
|
{"wait", TypeWait},
|
|
{"bad-format", BadFormat},
|
|
{"bad-namespace-prefix", BadNamespace},
|
|
{"connection-timeout", ConnTimeout},
|
|
{"host-gone", HostGone},
|
|
{"host-unknown", HostUnknown},
|
|
{"improper-addressing", BadAddressing},
|
|
{"internal-server-error", Internal},
|
|
{"invalid-from", InvalidFrom},
|
|
{"invalid-id", InvalidId},
|
|
{"invalid-namespace", InvalidNamespace},
|
|
{"invalid-xml", InvalidXml},
|
|
{"not-authorized", NotAuth},
|
|
{"policy-violation", Policy},
|
|
{"remote-connection-failed", RemoteConn},
|
|
{"resource-constraint", ResConstraint},
|
|
{"restricted-xml", RestrictedXml},
|
|
{"see-other-host", SeeOther},
|
|
{"system-shutdown", Shutdown},
|
|
{"undefined-condition", UndefinedCondition},
|
|
{"unsupported-encoding", UnsupportedEnc},
|
|
{"unsupported-stanza-type", UnsupportedStanza},
|
|
{"unsupported-version", UnsupportedVersion},
|
|
{"xml-not-well-formed", Xml},
|
|
// Auth failures
|
|
{"aborted", Aborted},
|
|
{"incorrect-encoding", IncorrectEnc},
|
|
{"invalid-authzid", InvalidAuth},
|
|
{"invalid-mechanism", InvalidMechanism},
|
|
{"mechanism-too-weak", MechanismTooWeak},
|
|
{"not-authorized", NotAuthorized},
|
|
{"temporary-auth-failure", TempAuthFailure},
|
|
// Stanza errors
|
|
{"bad-request", SBadRequest},
|
|
{"conflict", SConflict},
|
|
{"feature-not-implemented", SFeatureNotImpl},
|
|
{"forbidden", SForbidden},
|
|
{"gone", SGone},
|
|
{"internal-server-error", SInternal},
|
|
{"item-not-found", SItemNotFound},
|
|
{"jid-malformed", SBadJid},
|
|
{"not-acceptable", SNotAcceptable},
|
|
{"not-allowed", SNotAllowed},
|
|
{"payment-required", SPayment},
|
|
{"recipient-unavailable", SUnavailable},
|
|
{"redirect", SRedirect},
|
|
{"registration-required", SReg},
|
|
{"remote-server-not-found", SNoRemote},
|
|
{"remote-server-timeout", SRemoteTimeout},
|
|
{"resource-constraint", SResource},
|
|
{"service-unavailable", SServiceUnavailable},
|
|
{"subscription-required", SSubscription},
|
|
{"undefined-condition", SUndefinedCondition},
|
|
{"unexpected-request", SRequest},
|
|
{"unsupported-dtmf-method", DtmfNoMethod},
|
|
{0,0}
|
|
};
|
|
|
|
bool XMPPError::isText(int index, const char* txt)
|
|
{
|
|
const char* tmp = lookup(index,s_value,0);
|
|
if (!(txt && tmp))
|
|
return false;
|
|
return 0 == strcmp(tmp,txt);
|
|
}
|
|
|
|
/**
|
|
* JabberID
|
|
*/
|
|
void JabberID::set(const char* jid)
|
|
{
|
|
this->assign(jid);
|
|
parse();
|
|
}
|
|
|
|
void JabberID::set(const char* node, const char* domain, const char* resource)
|
|
{
|
|
if (node != m_node.c_str())
|
|
m_node = node;
|
|
if (domain != m_domain.c_str())
|
|
m_domain = domain;
|
|
if (resource != m_resource.c_str())
|
|
m_resource = resource;
|
|
clear();
|
|
if (m_node)
|
|
*this << m_node << "@";
|
|
*this << m_domain;
|
|
m_bare = *this;
|
|
if (m_node && m_resource)
|
|
*this << "/" << m_resource;
|
|
}
|
|
|
|
bool JabberID::valid(const String& value)
|
|
{
|
|
if (value.null())
|
|
return true;
|
|
return s_regExpValid.matches(value);
|
|
}
|
|
|
|
Regexp JabberID::s_regExpValid("^\\([[:alnum:]]*\\)");
|
|
|
|
#if 0
|
|
~`!#$%^*_-+=()[]{}|\;?.
|
|
#endif
|
|
|
|
void JabberID::parse()
|
|
{
|
|
String tmp = *this;
|
|
int i = tmp.find('@');
|
|
if (i == -1)
|
|
m_node = "";
|
|
else {
|
|
m_node = tmp.substr(0,i);
|
|
tmp = tmp.substr(i+1,tmp.length()-i-1);
|
|
}
|
|
i = tmp.find('/');
|
|
if (i == -1) {
|
|
m_domain = tmp;
|
|
m_resource = "";
|
|
}
|
|
else {
|
|
m_domain = tmp.substr(0,i);
|
|
m_resource = tmp.substr(i+1,tmp.length()-i-1);
|
|
}
|
|
// Set bare JID
|
|
m_bare = "";
|
|
if (m_node)
|
|
m_bare << m_node << "@";
|
|
m_bare << m_domain;
|
|
}
|
|
|
|
/**
|
|
* JIDIdentity
|
|
*/
|
|
TokenDict JIDIdentity::s_category[] = {
|
|
{"account", Account},
|
|
{"client", Client},
|
|
{"component", Component},
|
|
{"gateway", Gateway},
|
|
{0,0},
|
|
};
|
|
|
|
TokenDict JIDIdentity::s_type[] = {
|
|
{"registered", AccountRegistered},
|
|
{"phone", ClientPhone},
|
|
{"generic", ComponentGeneric},
|
|
{"presence", ComponentPresence},
|
|
{"generic", GatewayGeneric},
|
|
{0,0},
|
|
};
|
|
|
|
XMLElement* JIDIdentity::toXML()
|
|
{
|
|
return XMPPUtils::createIdentity(categoryText(m_category),typeText(m_type),m_name);
|
|
}
|
|
|
|
bool JIDIdentity::fromXML(const XMLElement* element)
|
|
{
|
|
if (!element)
|
|
return false;
|
|
XMLElement* id = ((XMLElement*)element)->findFirstChild("identity");
|
|
if (!id)
|
|
return false;
|
|
m_category = categoryValue(id->getAttribute("category"));
|
|
m_type = typeValue(id->getAttribute("type"));
|
|
id->getAttribute("name",m_name);
|
|
TelEngine::destruct(id);
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* JIDFeatureSasl
|
|
*/
|
|
TokenDict JIDFeatureSasl::s_authMech[] = {
|
|
{"DIGEST-MD5", MechMD5},
|
|
{"DIGEST-SHA1", MechSHA1},
|
|
{"PLAIN", MechPlain},
|
|
{0,0}
|
|
};
|
|
|
|
/**
|
|
* JIDFeatureList
|
|
*/
|
|
|
|
// Find a specific feature
|
|
JIDFeature* JIDFeatureList::get(XMPPNamespace::Type feature)
|
|
{
|
|
ObjList* obj = m_features.skipNull();
|
|
for (; obj; obj = obj->skipNext()) {
|
|
JIDFeature* f = static_cast<JIDFeature*>(obj->get());
|
|
if (*f == feature)
|
|
return f;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Build an XML element and add it to the destination
|
|
XMLElement* JIDFeatureList::addTo(XMLElement* element)
|
|
{
|
|
if (!element)
|
|
return 0;
|
|
ObjList* obj = m_features.skipNull();
|
|
for (; obj; obj = obj->skipNext()) {
|
|
JIDFeature* f = static_cast<JIDFeature*>(obj->get());
|
|
XMLElement* feature = new XMLElement(XMLElement::Feature);
|
|
feature->setAttribute("var",s_ns[*f]);
|
|
element->addChild(feature);
|
|
}
|
|
return element;
|
|
}
|
|
|
|
|
|
/**
|
|
* XMPPUtils
|
|
*/
|
|
TokenDict XMPPUtils::s_iq[] = {
|
|
{"set", IqSet},
|
|
{"get", IqGet},
|
|
{"result", IqResult},
|
|
{"error", IqError},
|
|
{0,0}
|
|
};
|
|
|
|
TokenDict XMPPUtils::s_commandAction[] = {
|
|
{"execute", CommExecute},
|
|
{"cancel", CommCancel},
|
|
{"prev", CommPrev},
|
|
{"next", CommNext},
|
|
{"complete", CommComplete},
|
|
{0,0}
|
|
};
|
|
|
|
TokenDict XMPPUtils::s_commandStatus[] = {
|
|
{"executing", CommExecuting},
|
|
{"completed", CommCompleted},
|
|
{"cancelled", CommCancelled},
|
|
{0,0}
|
|
};
|
|
|
|
XMLElement* XMPPUtils::createElement(const char* name, XMPPNamespace::Type ns,
|
|
const char* text)
|
|
{
|
|
XMLElement* element = new XMLElement(name,0,text);
|
|
element->setAttribute("xmlns",s_ns[ns]);
|
|
return element;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createElement(XMLElement::Type type, XMPPNamespace::Type ns,
|
|
const char* text)
|
|
{
|
|
XMLElement* element = new XMLElement(type,0,text);
|
|
element->setAttribute("xmlns",s_ns[ns]);
|
|
return element;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createIq(IqType type, const char* from,
|
|
const char* to, const char* id)
|
|
{
|
|
XMLElement* iq = new XMLElement(XMLElement::Iq);
|
|
iq->setAttribute("type",lookup(type,s_iq,""));
|
|
iq->setAttributeValid("from",from);
|
|
iq->setAttributeValid("to",to);
|
|
iq->setAttributeValid("id",id);
|
|
return iq;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createIqBind( const char* from,
|
|
const char* to, const char* id, const ObjList& resources)
|
|
{
|
|
XMLElement* iq = createIq(IqSet,from,to,id);
|
|
XMLElement* bind = createElement(XMLElement::Bind,XMPPNamespace::Bind);
|
|
ObjList* obj = resources.skipNull();
|
|
for (; obj; obj = resources.skipNext()) {
|
|
String* s = static_cast<String*>(obj->get());
|
|
if (!(s && s->length()))
|
|
continue;
|
|
XMLElement* res = new XMLElement(XMLElement::Resource,0,*s);
|
|
bind->addChild(res);
|
|
}
|
|
iq->addChild(bind);
|
|
return iq;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createCommand(CommandAction action, const char* node,
|
|
const char* sessionId)
|
|
{
|
|
XMLElement* command = createElement(XMLElement::Command,XMPPNamespace::Command);
|
|
if (sessionId)
|
|
command->setAttribute("sessionid",sessionId);
|
|
command->setAttribute("node",node);
|
|
command->setAttribute("action",lookup(action,s_commandAction));
|
|
return command;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createIdentity(const char* category, const char* type,
|
|
const char* name)
|
|
{
|
|
XMLElement* id = new XMLElement("identity");
|
|
id->setAttribute("category",category);
|
|
id->setAttribute("type",type);
|
|
id->setAttribute("name",name);
|
|
return id;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createIqDisco(const char* from, const char* to,
|
|
const char* id, bool info)
|
|
{
|
|
XMLElement* xml = createIq(IqGet,from,to,id);
|
|
xml->addChild(createElement(XMLElement::Query,
|
|
info ? XMPPNamespace::DiscoInfo : XMPPNamespace::DiscoItems));
|
|
return xml;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createDiscoInfoRes(const char* from, const char* to,
|
|
const char* id, JIDFeatureList* features, JIDIdentity* identity)
|
|
{
|
|
XMLElement* iq = XMPPUtils::createIq(XMPPUtils::IqResult,from,to,id);
|
|
XMLElement* query = XMPPUtils::createElement(XMLElement::Query,XMPPNamespace::DiscoInfo);
|
|
if (identity)
|
|
query->addChild(identity->toXML());
|
|
if (features)
|
|
features->addTo(query);
|
|
iq->addChild(query);
|
|
return iq;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createError(XMPPError::ErrorType type,
|
|
XMPPError::Type condition, const char* text)
|
|
{
|
|
XMLElement* err = new XMLElement("error");
|
|
err->setAttribute("type",s_err[type]);
|
|
XMLElement* tmp = createElement(s_err[condition],XMPPNamespace::StanzaError);
|
|
err->addChild(tmp);
|
|
if (text) {
|
|
tmp = createElement(XMLElement::Text,XMPPNamespace::StanzaError,text);
|
|
err->addChild(tmp);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
// Create an error from a received element. Consume the received element
|
|
XMLElement* XMPPUtils::createError(XMLElement* xml, XMPPError::ErrorType type,
|
|
XMPPError::Type error, const char* text)
|
|
{
|
|
if (!xml)
|
|
return 0;
|
|
XMLElement* err = new XMLElement(*xml,true,false);
|
|
err->addChild(xml);
|
|
err->addChild(createError(type,error,text));
|
|
return err;
|
|
}
|
|
|
|
XMLElement* XMPPUtils::createStreamError(XMPPError::Type error, const char* text)
|
|
{
|
|
XMLElement* element = new XMLElement(XMLElement::StreamError);
|
|
XMLElement* err = createElement(s_err[error],XMPPNamespace::StreamError);
|
|
element->addChild(err);
|
|
if (text) {
|
|
XMLElement* txt = createElement(XMLElement::Text,XMPPNamespace::StreamError,text);
|
|
element->addChild(txt);
|
|
}
|
|
return element;
|
|
}
|
|
|
|
// Check if the given element has an attribute 'xmlns' equal to a given value
|
|
bool XMPPUtils::hasXmlns(XMLElement& element, XMPPNamespace::Type ns)
|
|
{
|
|
return element.hasAttribute("xmlns",s_ns[ns]);
|
|
}
|
|
|
|
// Decode an 'error' XML element
|
|
void XMPPUtils::decodeError(XMLElement* element, String& error, String& text)
|
|
{
|
|
if (!element)
|
|
return;
|
|
|
|
XMPPNamespace::Type nsErr;
|
|
error = "";
|
|
text = "";
|
|
XMLElement* child = 0;
|
|
switch (element->type()) {
|
|
case XMLElement::StreamError:
|
|
nsErr = XMPPNamespace::StreamError;
|
|
break;
|
|
case XMLElement::Error:
|
|
nsErr = XMPPNamespace::StanzaError;
|
|
break;
|
|
case XMLElement::Iq:
|
|
case XMLElement::Presence:
|
|
case XMLElement::Message:
|
|
child = element->findFirstChild(XMLElement::Error);
|
|
decodeError(child,error,text);
|
|
TelEngine::destruct(child);
|
|
default:
|
|
return;
|
|
}
|
|
|
|
while (0 != (child = element->findNextChild(child)))
|
|
if (hasXmlns(*child,nsErr)) {
|
|
error = child->name();
|
|
TelEngine::destruct(child);
|
|
break;
|
|
}
|
|
child = element->findFirstChild(XMLElement::Text);
|
|
if (child) {
|
|
text = child->getText();
|
|
TelEngine::destruct(child);
|
|
}
|
|
}
|
|
|
|
// Check if an element or attribute name restricts value output
|
|
static const char* check(const String& name, const char* ok)
|
|
{
|
|
#define RESTRICT_LEN 2
|
|
static String restrict[RESTRICT_LEN] = {"auth", "password"};
|
|
static const char* pwd = "********";
|
|
for (unsigned int i = 0; i < RESTRICT_LEN; i++)
|
|
if (restrict[i] == name)
|
|
return pwd;
|
|
return ok;
|
|
#undef RESTRICT_LEN
|
|
}
|
|
|
|
void XMPPUtils::print(String& xmlStr, XMLElement& element, const char* indent)
|
|
{
|
|
#define STARTLINE(indent) "\r\n" << indent
|
|
const char* enclose = "-----";
|
|
bool hasAttr = (0 != element.firstAttribute());
|
|
bool hasChild = element.hasChild(0);
|
|
const char* txt = element.getText();
|
|
bool root = false;
|
|
if (!(indent && *indent)) {
|
|
indent = "";
|
|
root = true;
|
|
}
|
|
if (root)
|
|
xmlStr << STARTLINE(indent) << enclose;
|
|
// Name
|
|
if (!(hasAttr || hasChild || txt)) {
|
|
// indent<element.name()/>
|
|
xmlStr << STARTLINE(indent) << '<' << element.name();
|
|
if ((element.name())[0] != '/')
|
|
xmlStr << '/';
|
|
xmlStr << '>';
|
|
if (root)
|
|
xmlStr << STARTLINE(indent) << enclose;
|
|
return;
|
|
}
|
|
// <element.name()> or <element.name()
|
|
xmlStr << STARTLINE(indent) << '<' << element.name();
|
|
if (hasChild)
|
|
xmlStr << '>';
|
|
String sindent = indent;
|
|
sindent << " ";
|
|
// Attributes
|
|
const TiXmlAttribute* attr = element.firstAttribute();
|
|
for (; attr; attr = attr->Next())
|
|
xmlStr << STARTLINE(sindent) << attr->Name() << "=\""
|
|
<< check(attr->Name(),attr->Value()) << '"';
|
|
// Text. Filter some known elements to avoid output of passwords
|
|
if (txt)
|
|
xmlStr << STARTLINE(sindent) << check(element.name(),txt);
|
|
// Children
|
|
XMLElement* child = element.findFirstChild();
|
|
String si = sindent;
|
|
for (; child; child = element.findNextChild(child))
|
|
print(xmlStr,*child,si);
|
|
// End tag
|
|
if (hasChild)
|
|
xmlStr << STARTLINE(indent) << "</" << element.name() << '>';
|
|
else
|
|
xmlStr << STARTLINE(indent) << "/>";
|
|
if (root)
|
|
xmlStr << STARTLINE(indent) << enclose;
|
|
#undef STARTLINE
|
|
}
|
|
|
|
bool XMPPUtils::split(NamedList& dest, const char* src, const char sep,
|
|
bool nameFirst)
|
|
{
|
|
if (!src)
|
|
return false;
|
|
unsigned int index = 1;
|
|
String s = src;
|
|
ObjList* obj = s.split(sep,false);
|
|
for (ObjList* o = obj->skipNull(); o; o = o->skipNext(), index++) {
|
|
String* tmp = static_cast<String*>(o->get());
|
|
if (nameFirst)
|
|
dest.addParam(*tmp,String(index));
|
|
else
|
|
dest.addParam(String(index),*tmp);
|
|
}
|
|
TelEngine::destruct(obj);
|
|
return true;
|
|
}
|
|
|
|
// Decode a comma separated list of flags and put them into an integr mask
|
|
int XMPPUtils::decodeFlags(const String& src, const TokenDict* dict)
|
|
{
|
|
if (!dict)
|
|
return 0;
|
|
int mask = 0;
|
|
ObjList* obj = src.split(',',false);
|
|
for (ObjList* o = obj->skipNull(); o; o = o->skipNext())
|
|
mask |= lookup(static_cast<String*>(o->get())->c_str(),dict);
|
|
TelEngine::destruct(obj);
|
|
return mask;
|
|
}
|
|
|
|
// Encode a mask of flags to a comma separated list.
|
|
void XMPPUtils::buildFlags(String& dest, int src, const TokenDict* dict)
|
|
{
|
|
if (!dict)
|
|
return;
|
|
for (; dict->token; dict++)
|
|
if (0 != (src & dict->value))
|
|
dest.append(dict->token,",");
|
|
}
|
|
|
|
// Add child elements from a list to a destination element
|
|
bool XMPPUtils::addChidren(XMLElement* dest, ObjList& list)
|
|
{
|
|
if (!dest)
|
|
return false;
|
|
ObjList* o = list.skipNull();
|
|
bool added = (0 != o);
|
|
for (; o; o = o->skipNext()) {
|
|
XMLElement* xml = static_cast<XMLElement*>(o->get());
|
|
dest->addChild(new XMLElement(*xml));
|
|
}
|
|
return added;
|
|
}
|
|
|
|
/* vi: set ts=8 sw=4 sts=4 noet: */
|