static void add_album_art(xmlNodePtr node, int64_t cover_id, query_t * q)
{
bg_db_object_t * cover;
bg_db_object_t * cover_thumb;
char * tmp_string;
xmlNodePtr child;
cover = bg_db_object_query(q->db, cover_id);
cover_thumb = bg_db_get_thumbnail(q->db, cover_id, 160, 160, "image/jpeg");
/* Cover thumbnail */
if(cover_thumb)
{
tmp_string = bg_sprintf("%smedia/%"PRId64, q->dev->url_base, bg_db_object_get_id(cover_thumb));
child = bg_didl_add_element_string(q->didl, node, "upnp:albumArtURI", tmp_string, NULL);
free(tmp_string);
if(child)
{
xmlNsPtr dlna_ns;
dlna_ns = xmlNewNs(child,
(xmlChar*)"urn:schemas-dlna-org:metadata-1-0/",
(xmlChar*)"dlna");
xmlSetNsProp(child, dlna_ns, (const xmlChar*)"profileID", (const xmlChar*)"JPEG_TN");
}
bg_db_object_unref(cover_thumb);
}
/* Original size */
tmp_string = bg_sprintf("%smedia/%"PRId64, q->dev->url_base, cover_id);
child = bg_didl_add_element_string(q->didl, node, "upnp:albumArtURI", tmp_string, NULL);
free(tmp_string);
if(child)
{
const char * dlna_id;
xmlNsPtr dlna_ns;
dlna_id = get_dlna_image_profile(cover);
if(dlna_id)
{
dlna_ns = xmlNewNs(child,
(xmlChar*)"urn:schemas-dlna-org:metadata-1-0/",
(xmlChar*)"dlna");
xmlSetNsProp(child, dlna_ns, (const xmlChar*)"profileID", (const xmlChar*)dlna_id);
}
}
bg_db_object_unref(cover);
}
static int node_set_attr(lua_State *L) {
xmlNodePtr node = lua_touserdata(L, 1);
const char *name = lua_tostring(L, 2);
const char *value = lua_tostring(L, 3);
const char *ns_str = lua_tostring(L, 4);
xmlNsPtr ns = NULL;
if (node == NULL) return luaL_error(L, "set_attribute: Invalid node");
if (node->type != XML_ELEMENT_NODE) return luaL_error(L, "set_attribute: Invalid node type (not element node)");
if (name == NULL) return luaL_error(L, "set_attribute: Specify attribute name");
if (value == NULL) return luaL_error(L, "set_attribute: Specify attribute value");
if (ns_str != NULL) {
ns = xmlSearchNsByHref(node->doc, node, BAD_CAST ns_str);
if (ns == NULL) return luaL_error(L, "Namespace not registered yet.");
if (ns->prefix == NULL) return luaL_error(L, "Namespace has not registered prefix.");
}
if (ns == NULL) {
xmlSetProp(node, BAD_CAST name, BAD_CAST value);
} else {
xmlSetNsProp(node, ns, BAD_CAST name, BAD_CAST value);
}
lua_pushlightuserdata(L, node);
luaL_setmetatable(L, WRAP_XMLNODE);
return 1;
}
static void
data_to_xml_cb (gpointer key,
gpointer value,
gpointer user_data)
{
struct data_to_xml_data *cb_data = user_data;
CongNodePtr new_node;
g_assert (cb_data->parent_node);
g_assert (cb_data->make_node_callback);
new_node = cb_data->make_node_callback (cb_data->parent_node->doc,
value);
xmlAddChild (cb_data->parent_node,
new_node);
if (key) {
xmlNsPtr ns;
ns = xmlSearchNsByHref (cb_data->parent_node->doc,
new_node,
XML_XML_NAMESPACE);
if (ns == NULL) {
g_warning ("FIXME couldn't find namespace %s ", XML_XML_NAMESPACE);
}
xmlSetNsProp (new_node,
ns,
(const xmlChar*)"lang",
key);
}
}
/*
* Extend the existing value for an attribute, appending the given value.
*/
static void
slaxNodeAttribExtend (slax_data_t *sdp, xmlNodePtr nodep,
const char *attrib, const char *value, const char *uri)
{
const xmlChar *uattrib = (const xmlChar *) attrib;
xmlChar *current = uri ? xmlGetProp(nodep, uattrib)
: xmlGetNsProp(nodep, uattrib, (const xmlChar *) uri);
int clen = current ? xmlStrlen(current) + 1 : 0;
int vlen = strlen(value) + 1;
unsigned char *newp = alloca(clen + vlen);
if (newp == NULL) {
xmlParserError(sdp->sd_ctxt, "%s:%d: out of memory",
sdp->sd_filename, sdp->sd_line);
return;
}
if (clen) {
memcpy(newp, current, clen - 1);
newp[clen - 1] = ' ';
xmlFree(current);
}
memcpy(newp + clen, value, vlen);
if (uri == NULL)
xmlSetProp(nodep, uattrib, newp);
else {
xmlNsPtr nsp = xmlSearchNsByHref(sdp->sd_docp, nodep,
(const xmlChar *) uri);
xmlSetNsProp(nodep, nsp, uattrib, newp);
}
}
// void setAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName, in DOMString value) raises(DOMException);
static void _setAttributeNS(Request& r, MethodParams& params) {
const xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
const xmlChar* qualifiedName=as_xmlqname(r, params, 1);
const xmlChar* attribute_value=as_xmlchar(r, params, 2, XML_VALUE_MUST_BE_STRING);
VXnode& vnode=GET_SELF(r, VXnode);
xmlNode& element=get_self_element(vnode);
VXdoc& vxdoc=vnode.get_vxdoc();
xmlDoc& xmldoc=vxdoc.get_xmldoc();
xmlChar* prefix=0;
xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
// @todo: name=xmlns
xmlAttr* attrNode;
if(localName) {
xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
attrNode=xmlSetNsProp(&element, &ns,
localName,
attribute_value);
} else {
attrNode=xmlSetProp(&element,
qualifiedName/*unqualified, actually*/,
attribute_value);
}
if(!attrNode)
throw XmlException(0, r);
}
static xmlAttrPtr
_soap_addressing_set_property(xmlNodePtr node, const xmlChar *name, const xmlChar *value)
{
xmlNsPtr ns;
ns = _soap_addressing_get_namespace(node);
return xmlSetNsProp(node, ns, name, value);
}
void XMLAttr::setAttributeValue(xmlNode * node, const char *prefix, const char *name, const char *value)
{
if (node && node->type == XML_ELEMENT_NODE)
{
xmlAttr *attrs = 0;
for (xmlAttr * cur = node->properties; cur; cur = cur->next)
{
if (cur->ns && !strcmp(name, (const char *)cur->name)
&& (!strcmp(prefix, (const char *)cur->ns->prefix) || !strcmp(prefix, (const char *)cur->ns->href)))
{
attrs = cur;
break;
}
}
if (attrs)
{
xmlSetNsProp(node, attrs->ns, (const xmlChar *)name, (const xmlChar *)value);
}
else
{
xmlNs *ns = 0;
if (!strncmp(prefix, "http://", strlen("http://")))
{
ns = xmlSearchNsByHref(node->doc, node, (const xmlChar *)prefix);
}
else
{
ns = xmlSearchNs(node->doc, node, (const xmlChar *)prefix);
}
if (ns)
{
xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
}
else
{
xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
}
}
}
}
static inline xmlAttrPtr XDR_A_dt_type(xmlAttrPtr xdr_attr, xmlNodePtr node)
{
xmlChar* str = get_attr_val(xdr_attr);
xmlAttrPtr attr;
TRACE("(%p, %p)\n", xdr_attr, node);
if (xmlStrEqual(str, xs_enumeration))
attr = NULL;
else
attr = xmlSetNsProp(node, get_dt_ns(node), DT_prefix, str);
xmlFree(str);
return attr;
}
/*
* call-seq:
* attr.value = "value"
*
* Sets the value of this attribute.
*/
VALUE rxml_attr_value_set(VALUE self, VALUE val)
{
xmlAttrPtr xattr;
Check_Type(val, T_STRING);
Data_Get_Struct(self, xmlAttr, xattr);
if (xattr->ns)
xmlSetNsProp(xattr->parent, xattr->ns, xattr->name,
(xmlChar*) StringValuePtr(val));
else
xmlSetProp(xattr->parent, xattr->name, (xmlChar*) StringValuePtr(val));
return (self);
}
static bool
hidrd_xml_snk_init(hidrd_snk *snk, char **perr, bool format, const char *schema)
{
bool result = false;
hidrd_xml_snk_inst *xml_snk = (hidrd_xml_snk_inst *)snk;
char *own_schema = NULL;
hidrd_xml_snk_state *state = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr root = NULL;
xmlNsPtr ns;
XML_ERR_FUNC_BACKUP_DECL;
if (perr != NULL)
*perr = strdup("");
XML_ERR_FUNC_SET(perr);
/* Copy schema file path */
own_schema = strdup(schema);
if (own_schema == NULL)
XML_ERR_CLNP("failed to allocate memory for the schema file path");
/* Create item state table stack */
state = malloc(sizeof(*state));
if (state == NULL)
XML_ERR_CLNP("failed to allocate memory for the state table");
state->prev = NULL;
state->usage_page = HIDRD_USAGE_PAGE_UNDEFINED;
/* Create the document */
doc = xmlNewDoc(BAD_CAST "1.0");
if (doc == NULL)
goto cleanup;
/* Create root node */
root = xmlNewNode(NULL, BAD_CAST "descriptor");
if (root == NULL)
goto cleanup;
/* Add and assign our namespace */
ns = xmlNewNs(root, BAD_CAST HIDRD_XML_PROP_NS, NULL);
if (ns == NULL)
goto cleanup;
xmlSetNs(root, ns);
/* Add XML schema instance namespace */
ns = xmlNewNs(root, BAD_CAST HIDRD_XML_PROP_NS_XSI, BAD_CAST "xsi");
if (ns == NULL)
goto cleanup;
/* Add xsi:schemaLocation attribute */
if (xmlSetNsProp(root, ns,
BAD_CAST "schemaLocation",
BAD_CAST HIDRD_XML_PROP_XSI_SCHEMA_LOCATION) == NULL)
goto cleanup;
/* Set root element */
xmlDocSetRootElement(doc, root);
/* Initialize the sink */
xml_snk->schema = own_schema;
xml_snk->format = format;
xml_snk->state = state;
xml_snk->doc = doc;
xml_snk->prnt = root;
xml_snk->err = strdup("");
own_schema = NULL;
state = NULL;
doc = NULL;
root = NULL;
result = true;
cleanup:
xmlFreeNode(root);
if (doc != NULL)
xmlFreeDoc(doc);
free(state);
free(own_schema);
XML_ERR_FUNC_RESTORE;
return result;
}
/**
* xsltAttribute:
* @ctxt: a XSLT process context
* @node: the current node in the source tree
* @inst: the xsl:attribute element
* @comp: precomputed information
*
* Process the xslt attribute node on the source node
*/
void
xsltAttribute(xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltStylePreCompPtr castedComp)
{
#ifdef XSLT_REFACTORED
xsltStyleItemAttributePtr comp =
(xsltStyleItemAttributePtr) castedComp;
#else
xsltStylePreCompPtr comp = castedComp;
#endif
xmlNodePtr targetElem;
xmlChar *prop = NULL;
const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
xmlChar *value = NULL;
xmlNsPtr ns = NULL;
xmlAttrPtr attr;
if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
(inst->type != XML_ELEMENT_NODE) )
return;
/*
* A comp->has_name == 0 indicates that we need to skip this instruction,
* since it was evaluated to be invalid already during compilation.
*/
if (!comp->has_name)
return;
/*
* BIG NOTE: This previously used xsltGetSpecialNamespace() and
* xsltGetNamespace(), but since both are not appropriate, we
* will process namespace lookup here to avoid adding yet another
* ns-lookup function to namespaces.c.
*/
/*
* SPEC XSLT 1.0: Error cases:
* - Creating nodes other than text nodes during the instantiation of
* the content of the xsl:attribute element; implementations may
* either signal the error or ignore the offending nodes."
*/
if (comp == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Internal error in xsltAttribute(): "
"The XSLT 'attribute' instruction was not compiled.\n");
return;
}
/*
* TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
* So report an internal error?
*/
if (ctxt->insert == NULL)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to a node that is not an element;
* implementations may either signal the error or ignore the attribute."
*
* TODO: I think we should signal such errors in the future, and maybe
* provide an option to ignore such errors.
*/
targetElem = ctxt->insert;
if (targetElem->type != XML_ELEMENT_NODE)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to an element after children have been added
* to it; implementations may either signal the error or ignore the
* attribute."
*
* TODO: We should decide whether not to report such errors or
* to ignore them; note that we *ignore* if the parent is not an
* element, but here we report an error.
*/
if (targetElem->children != NULL) {
/*
* NOTE: Ah! This seems to be intended to support streamed
* result generation!.
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: Cannot add attributes to an "
"element if children have been already added "
"to the element.\n");
return;
}
/*
* Process the name
* ----------------
*/
#ifdef WITH_DEBUGGER
if (ctxt->debugStatus != XSLT_DEBUG_NONE)
xslHandleDebugger(inst, contextNode, NULL, ctxt);
#endif
if (comp->name == NULL) {
/* TODO: fix attr acquisition wrt to the XSLT namespace */
prop = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "name", XSLT_NAMESPACE);
if (prop == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The attribute 'name' is missing.\n");
goto error;
}
if (xmlValidateQName(prop, 0)) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective name '%s' is not a "
"valid QName.\n", prop);
/* we fall through to catch any further errors, if possible */
}
/*
* Reject a name of "xmlns".
*/
if (xmlStrEqual(prop, BAD_CAST "xmlns")) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective name 'xmlns' is not allowed.\n");
xmlFree(prop);
goto error;
}
name = xsltSplitQName(ctxt->dict, prop, &prefix);
xmlFree(prop);
} else {
/*
* The "name" value was static.
*/
#ifdef XSLT_REFACTORED
prefix = comp->nsPrefix;
name = comp->name;
#else
name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
#endif
}
/*
* Process namespace semantics
* ---------------------------
*
* Evaluate the namespace name.
*/
if (comp->has_ns) {
/*
* The "namespace" attribute was existent.
*/
if (comp->ns != NULL) {
/*
* No AVT; just plain text for the namespace name.
*/
if (comp->ns[0] != 0)
nsName = comp->ns;
} else {
xmlChar *tmpNsName;
/*
* Eval the AVT.
*/
/* TODO: check attr acquisition wrt to the XSLT namespace */
tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "namespace", XSLT_NAMESPACE);
/*
* This fixes bug #302020: The AVT might also evaluate to the
* empty string; this means that the empty string also indicates
* "no namespace".
* SPEC XSLT 1.0:
* "If the string is empty, then the expanded-name of the
* attribute has a null namespace URI."
*/
if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
xmlFree(tmpNsName);
}
if (xmlStrEqual(nsName, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: Namespace http://www.w3.org/2000/xmlns/ "
"forbidden.\n");
goto error;
}
if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) {
prefix = BAD_CAST "xml";
} else if (xmlStrEqual(prefix, BAD_CAST "xml")) {
prefix = NULL;
}
} else if (prefix != NULL) {
/*
* SPEC XSLT 1.0:
* "If the namespace attribute is not present, then the QName is
* expanded into an expanded-name using the namespace declarations
* in effect for the xsl:attribute element, *not* including any
* default namespace declaration."
*/
ns = xmlSearchNs(inst->doc, inst, prefix);
if (ns == NULL) {
/*
* Note that this is treated as an error now (checked with
* Saxon, Xalan-J and MSXML).
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The QName '%s:%s' has no "
"namespace binding in scope in the stylesheet; "
"this is an error, since the namespace was not "
"specified by the instruction itself.\n", prefix, name);
} else
nsName = ns->href;
}
/*
* Find/create a matching ns-decl in the result tree.
*/
ns = NULL;
#if 0
if (0) {
/*
* OPTIMIZE TODO: How do we know if we are adding to a
* fragment or to the result tree?
*
* If we are adding to a result tree fragment (i.e., not to the
* actual result tree), we'll don't bother searching for the
* ns-decl, but just store it in the dummy-doc of the result
* tree fragment.
*/
if (nsName != NULL) {
/*
* TODO: Get the doc of @targetElem.
*/
ns = xsltTreeAcquireStoredNs(some doc, nsName, prefix);
}
}
#endif
if (nsName != NULL) {
/*
* Something about ns-prefixes:
* SPEC XSLT 1.0:
* "XSLT processors may make use of the prefix of the QName specified
* in the name attribute when selecting the prefix used for outputting
* the created attribute as XML; however, they are not required to do
* so and, if the prefix is xmlns, they must not do so"
*/
/*
* xsl:attribute can produce a scenario where the prefix is NULL,
* so generate a prefix.
*/
if ((prefix == NULL) || xmlStrEqual(prefix, BAD_CAST "xmlns")) {
xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");
ns = xsltGetSpecialNamespace(ctxt, inst, nsName, pref, targetElem);
xmlFree(pref);
} else {
ns = xsltGetSpecialNamespace(ctxt, inst, nsName, prefix,
targetElem);
}
if (ns == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Namespace fixup error: Failed to acquire an in-scope "
"namespace binding for the generated attribute '{%s}%s'.\n",
nsName, name);
goto error;
}
}
/*
* Construction of the value
* -------------------------
*/
if (inst->children == NULL) {
/*
* No content.
* TODO: Do we need to put the empty string in ?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
} else if ((inst->children->next == NULL) &&
((inst->children->type == XML_TEXT_NODE) ||
(inst->children->type == XML_CDATA_SECTION_NODE)))
{
xmlNodePtr copyTxt;
/*
* xmlSetNsProp() will take care of duplicates.
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
if (attr == NULL) /* TODO: report error ? */
goto error;
/*
* This was taken over from xsltCopyText() (transform.c).
*/
if (ctxt->internalized &&
(ctxt->insert->doc != NULL) &&
(ctxt->insert->doc->dict == ctxt->dict))
{
copyTxt = xmlNewText(NULL);
if (copyTxt == NULL) /* TODO: report error */
goto error;
/*
* This is a safe scenario where we don't need to lookup
* the dict.
*/
copyTxt->content = inst->children->content;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (inst->children->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
} else {
/*
* Copy the value.
*/
copyTxt = xmlNewText(inst->children->content);
if (copyTxt == NULL) /* TODO: report error */
goto error;
}
attr->children = attr->last = copyTxt;
copyTxt->parent = (xmlNodePtr) attr;
copyTxt->doc = attr->doc;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (inst->children->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
/*
* since we create the attribute without content IDness must be
* asserted as a second step
*/
if ((copyTxt->content != NULL) &&
(xmlIsID(attr->doc, attr->parent, attr)))
xmlAddID(NULL, attr->doc, copyTxt->content, attr);
} else {
/*
* The sequence constructor might be complex, so instantiate it.
*/
value = xsltEvalTemplateString(ctxt, contextNode, inst);
if (value != NULL) {
attr = xmlSetNsProp(ctxt->insert, ns, name, value);
xmlFree(value);
} else {
/*
* TODO: Do we have to add the empty string to the attr?
* TODO: Does a value of NULL indicate an
* error in xsltEvalTemplateString() ?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name,
(const xmlChar *) "");
}
}
error:
return;
}
int
lasso_ecp_process_response_msg(LassoEcp *ecp, const char *response_msg)
{
xmlDoc *doc;
xmlXPathContext *xpathCtx;
xmlXPathObject *xpathObj;
xmlNode *new_envelope, *header, *paos_response, *ecp_relay_state;
xmlNode *body = NULL;
xmlNs *soap_env_ns, *ecp_ns;
g_return_val_if_fail(LASSO_IS_ECP(ecp), LASSO_PARAM_ERROR_BAD_TYPE_OR_NULL_OBJ);
g_return_val_if_fail(response_msg != NULL, LASSO_PARAM_ERROR_INVALID_VALUE);
doc = lasso_xml_parse_memory(response_msg, strlen(response_msg));
xpathCtx = xmlXPathNewContext(doc);
xmlXPathRegisterNs(xpathCtx, (xmlChar*)"s", (xmlChar*)LASSO_SOAP_ENV_HREF);
xpathObj = xmlXPathEvalExpression((xmlChar*)"//s:Body", xpathCtx);
if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeNr) {
body = xmlCopyNode(xpathObj->nodesetval->nodeTab[0], 1);
}
xmlXPathFreeObject(xpathObj);
xmlXPathRegisterNs(xpathCtx, (xmlChar*)"ecp", (xmlChar*)LASSO_ECP_HREF);
xpathObj = xmlXPathEvalExpression((xmlChar*)"//ecp:Response", xpathCtx);
if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeNr) {
ecp->assertionConsumerURL = (char*)xmlGetProp(
xpathObj->nodesetval->nodeTab[0], (xmlChar*)"AssertionConsumerURL");
}
xmlXPathFreeObject(xpathObj);
xmlXPathFreeContext(xpathCtx);
xpathCtx = NULL;
xpathObj = NULL;
new_envelope = xmlNewNode(NULL, (xmlChar*)"Envelope");
xmlSetNs(new_envelope, xmlNewNs(new_envelope,
(xmlChar*)LASSO_SOAP_ENV_HREF, (xmlChar*)LASSO_SOAP_ENV_PREFIX));
xmlNewNs(new_envelope,
(xmlChar*)LASSO_SAML_ASSERTION_HREF, (xmlChar*)LASSO_SAML_ASSERTION_PREFIX);
header = xmlNewTextChild(new_envelope, NULL, (xmlChar*)"Header", NULL);
/* PAOS request header block */
soap_env_ns = xmlNewNs(new_envelope,
(xmlChar*)LASSO_SOAP_ENV_HREF, (xmlChar*)LASSO_SOAP_ENV_PREFIX);
paos_response = xmlNewNode(NULL, (xmlChar*)"Response");
xmlSetNs(paos_response, xmlNewNs(paos_response,
(xmlChar*)LASSO_PAOS_HREF, (xmlChar*)LASSO_PAOS_PREFIX));
xmlSetNsProp(paos_response, soap_env_ns, (xmlChar*)"mustUnderstand", (xmlChar*)"1");
xmlSetNsProp(paos_response, soap_env_ns, (xmlChar*)"actor",
(xmlChar*)LASSO_SOAP_ENV_ACTOR);
if (ecp->private_data->messageID) {
xmlSetNsProp(paos_response, soap_env_ns, (xmlChar*)"refToMessageID",
(xmlChar*)ecp->private_data->messageID);
}
xmlAddChild(header, paos_response);
/* ECP relay state block */
if (ecp->private_data->relay_state) {
ecp_relay_state = xmlNewNode(NULL, (xmlChar*)"RelayState");
xmlNodeSetContent(ecp_relay_state, (xmlChar*)ecp->private_data->relay_state);
ecp_ns = xmlNewNs(ecp_relay_state, (xmlChar*)LASSO_ECP_HREF,
(xmlChar*)LASSO_ECP_PREFIX);
xmlSetNs(ecp_relay_state, ecp_ns);
xmlSetNsProp(ecp_relay_state, soap_env_ns, (xmlChar*)"mustUnderstand",
(xmlChar*)"1");
xmlSetNsProp(ecp_relay_state, soap_env_ns, (xmlChar*)"actor",
(xmlChar*)LASSO_SOAP_ENV_ACTOR);
xmlAddChild(header, ecp_relay_state);
}
xmlAddChild(new_envelope, body);
lasso_assign_new_string(LASSO_PROFILE(ecp)->msg_body,
lasso_xmlnode_to_string(new_envelope, 0, 0))
lasso_release_doc(doc);
return 0;
}
int ds_sds_compose_add_component_with_ref(xmlDocPtr doc, xmlNodePtr datastream, const char* filepath, const char* cref_id)
{
xmlNsPtr ds_ns = xmlSearchNsByHref(doc, datastream, BAD_CAST datastream_ns_uri);
xmlNsPtr xlink_ns = xmlSearchNsByHref(doc, datastream, BAD_CAST xlink_ns_uri);
xmlNsPtr cat_ns = xmlSearchNsByHref(doc, datastream, BAD_CAST cat_ns_uri);
// In case we already have this component we just return, no need to add
// it twice. We will typically have many references to OVAL files, adding
// component for each reference would create unnecessarily huge datastreams
int result = ds_sds_compose_has_component_ref(doc, datastream, filepath, cref_id);
if (result == 0)
{
return 0;
}
if (result == -1)
{
// no need to free anything
// oscap_seterr has already been called
return -1;
}
xmlNodePtr cref_catalog = xmlNewNode(cat_ns, BAD_CAST "catalog");
xmlNodePtr cref_parent;
bool extended_component = false;
struct oscap_source *component_source = oscap_source_new_from_file(filepath);
oscap_document_type_t doc_type = oscap_source_get_scap_type(component_source);
if (doc_type == OSCAP_DOCUMENT_XCCDF)
{
cref_parent = node_get_child_element(datastream, "checklists");
if (ds_sds_compose_add_component_dependencies(doc, datastream, component_source, cref_catalog, doc_type) != 0)
{
// oscap_seterr has already been called
oscap_source_free(component_source);
return -1;
}
}
else if (doc_type == OSCAP_DOCUMENT_CPE_DICTIONARY || doc_type == OSCAP_DOCUMENT_CPE_LANGUAGE)
{
cref_parent = node_get_child_element(datastream, "dictionaries");
if (cref_parent == NULL) {
cref_parent = xmlNewNode(ds_ns, BAD_CAST "dictionaries");
// The <ds:dictionaries element must as the first child of the datastream
xmlNodePtr first_child = datastream->xmlChildrenNode;
xmlNodePtr new_node = (first_child == NULL) ?
xmlAddChild(datastream, cref_parent) : xmlAddPrevSibling(first_child, cref_parent);
if (new_node == NULL) {
oscap_seterr(OSCAP_EFAMILY_XML, "Failed to add dictionaries element to the DataStream.");
xmlFreeNode(cref_parent);
cref_parent = NULL;
}
}
if (ds_sds_compose_add_component_dependencies(doc, datastream, component_source, cref_catalog, doc_type) != 0) {
oscap_source_free(component_source);
return -1;
}
}
else if (doc_type == OSCAP_DOCUMENT_OVAL_DEFINITIONS || doc_type == OSCAP_DOCUMENT_OCIL)
{
cref_parent = node_get_child_element(datastream, "checks");
}
else
{
// not an XCCDF file, not an OVAL file, not a dict/lang, assume it goes into extended components
extended_component = true;
cref_parent = node_get_child_element(datastream, "extended-components");
}
oscap_source_free(component_source);
char* mangled_filepath = ds_sds_mangle_filepath(filepath);
// extended components (sadly :-/) use a different ID scheme and have
// a different element name than "normal" components
char* comp_id = oscap_sprintf("scap_org.open-scap_%scomp_%s",
extended_component ? "e" : "", mangled_filepath);
int counter = 0;
while (_lookup_component_in_collection(doc, comp_id) != NULL) {
// While a component of the given ID already exists, generate a new one
oscap_free(comp_id);
comp_id = oscap_sprintf("scap_org.open-scap_%scomp_%s%03d",
extended_component ? "e" : "", mangled_filepath, counter++);
}
oscap_free(mangled_filepath);
result = ds_sds_compose_add_component_internal(doc, datastream, filepath, comp_id, extended_component);
if (result == 0) {
xmlNodePtr cref = xmlNewNode(ds_ns, BAD_CAST "component-ref");
xmlAddChild(cref, cref_catalog);
xmlSetProp(cref, BAD_CAST "id", BAD_CAST cref_id);
const char* xlink_href = oscap_sprintf("#%s", comp_id);
xmlSetNsProp(cref, xlink_ns, BAD_CAST "href", BAD_CAST xlink_href);
oscap_free(xlink_href);
if (xmlAddChild(cref_parent, cref) == NULL) {
oscap_seterr(OSCAP_EFAMILY_XML, "Failed to add component-ref/@id='%s' to the DataStream.", cref_id);
result = 1;
}
}
oscap_free(comp_id);
// the source data stream XSD requires either no catalog or a non-empty one
if (cref_catalog->children == NULL)
{
xmlUnlinkNode(cref_catalog);
xmlFreeNode(cref_catalog);
}
return result;
}
/**
* xsltAttributeInternal:
* @ctxt: a XSLT process context
* @node: the node in the source tree.
* @inst: the xsl:attribute element
* @comp: precomputed information
* @fromAttributeSet: the attribute comes from an attribute-set
*
* Process the xslt attribute node on the source node
*/
static void
xsltAttributeInternal(xsltTransformContextPtr ctxt, xmlNodePtr node,
xmlNodePtr inst,
xsltStylePreCompPtr castedComp,
int fromAttributeSet) {
#ifdef XSLT_REFACTORED
xsltStyleItemAttributePtr comp =
(xsltStyleItemAttributePtr) castedComp;
/*
* TODO: Change the fields of the compiled struct:
* 1) @name (char)
* 2) @nameType (String, AVT)
* 3) @nsName (char)
* 4) nsNameType (None, String, AVT)
*/
#else
xsltStylePreCompPtr comp = castedComp;
#endif
xmlNodePtr targetElem;
xmlChar *prop = NULL;
const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
xmlChar *value = NULL;
xmlNsPtr ns = NULL;
xmlAttrPtr attr;
if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
return;
/*
* BIG NOTE: This previously used xsltGetSpecialNamespace() and
* xsltGetNamespace(), but since both are not appropriate, we
* will process namespace lookup here to avoid adding yet another
* ns-lookup function to namespaces.c.
*/
/*
* SPEC XSLT 1.0: Error cases:
* - Creating nodes other than text nodes during the instantiation of
* the content of the xsl:attribute element; implementations may
* either signal the error or ignore the offending nodes."
*/
if (comp == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Internal error in xsltAttributeInternal(): "
"The instruction was no compiled.\n");
return;
}
/*
* TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
* So report an internal error?
*/
if (ctxt->insert == NULL)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to a node that is not an element;
* implementations may either signal the error or ignore the attribute."
*
* TODO: I think we should signal such errors in the future, and maybe
* provide an option to ignore such errors.
*/
targetElem = ctxt->insert;
if (targetElem->type != XML_ELEMENT_NODE)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to an element after children have been added
* to it; implementations may either signal the error or ignore the
* attribute."
*
* TODO: We should decide whether not to report such errors or
* to ignore them; note that we *ignore* if the parent is not an
* element, but here we report an error.
*/
if (targetElem->children != NULL) {
/*
* NOTE: Ah! This seems to be intended to support streamed
* result generation!.
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: Cannot add attributes to an "
"element if children have been already added "
"to the element.\n");
return;
}
/*
* Process the name
* ----------------
*/
if (!comp->has_name) /* TODO: raise error */
return;
#ifdef WITH_DEBUGGER
if (ctxt->debugStatus != XSLT_DEBUG_NONE)
xslHandleDebugger(inst, node, NULL, ctxt);
#endif
if (comp->name == NULL) {
/* TODO: fix attr acquisition wrt to the XSLT namespace */
prop = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "name", XSLT_NAMESPACE);
if (prop == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The attribute 'name' is missing.\n");
goto error;
}
if (xmlValidateQName(prop, 0)) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective name '%s' is not a "
"valid QName.\n", prop);
/* we fall through to catch any further errors, if possible */
}
name = xsltSplitQName(ctxt->dict, prop, &prefix);
xmlFree(prop);
} else {
name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
}
if (!xmlStrncasecmp(prefix, (xmlChar *) "xmlns", 5)) {
#ifdef WITH_XSLT_DEBUG_PARSING
xsltGenericDebug(xsltGenericDebugContext,
"xsltAttribute: xmlns prefix forbidden\n");
#endif
/*
* SPEC XSLT 1.0:
* "It is an error if the string that results from instantiating
* the attribute value template is not a QName or is the string
* xmlns. An XSLT processor may signal the error; if it does not
* signal the error, it must recover by not adding the attribute
* to the result tree."
* TODO: Decide which way to go here.
*/
goto error;
}
/*
* Process namespace semantics
* ---------------------------
*
* Evaluate the namespace name.
*/
if (comp->has_ns) {
if (comp->ns != NULL) {
if (comp->ns[0] != 0)
nsName = comp->ns;
} else {
xmlChar *tmpNsName;
/*
* Eval the AVT.
*/
/* TODO: check attr acquisition wrt to the XSLT namespace */
tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "namespace", XSLT_NAMESPACE);
/*
* This fixes bug #302020: The AVT might also evaluate to the
* empty string; this means that the empty string also indicates
* "no namespace".
* SPEC XSLT 1.0:
* "If the string is empty, then the expanded-name of the
* attribute has a null namespace URI."
*/
if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
xmlFree(tmpNsName);
};
} else if (prefix != NULL) {
/*
* SPEC XSLT 1.0:
* "If the namespace attribute is not present, then the QName is
* expanded into an expanded-name using the namespace declarations
* in effect for the xsl:attribute element, *not* including any
* default namespace declaration."
*/
ns = xmlSearchNs(inst->doc, inst, prefix);
if (ns == NULL) {
/*
* Note that this is treated as an error now (checked with
* Saxon, Xalan-J and MSXML).
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective prefix '%s', has no "
"namespace binding in scope in the stylesheet; "
"this is an error, since the namespace was not "
"specified by the instruction itself.\n", prefix);
} else
nsName = ns->href;
}
if (fromAttributeSet) {
/*
* I think this tries to ensure that xsl:attribute(s) coming
* from an xsl:attribute-set won't override attribute of
* literal result elements or of explicit xsl:attribute(s).
*/
attr = xmlHasNsProp(targetElem, name, nsName);
if (attr != NULL)
return;
}
/*
* Something about ns-prefixes:
* SPEC XSLT 1.0:
* "XSLT processors may make use of the prefix of the QName specified
* in the name attribute when selecting the prefix used for outputting
* the created attribute as XML; however, they are not required to do
* so and, if the prefix is xmlns, they must not do so"
*/
/*
* Find/create a matching ns-decl in the result tree.
*/
ns = NULL;
#if 0
if (0) {
/*
* OPTIMIZE TODO: How do we know if we are adding to a
* fragment or not?
*
* If we are adding to a result tree fragment (i.e., not to the
* actual result tree), we'll don't bother searching for the
* ns-decl, but just store it in the dummy-doc of the result
* tree fragment.
*/
if (nsName != NULL) {
ns = xsltTreeAcquireStoredNs(ctxt->document->doc, nsName,
prefix);
}
}
#endif
if (nsName != NULL) {
/*
* The owner-element might be in the same namespace.
*/
if ((targetElem->ns != NULL) &&
(targetElem->ns->prefix != NULL) &&
xmlStrEqual(targetElem->ns->href, nsName))
{
ns = targetElem->ns;
goto namespace_finished;
}
if (prefix != NULL) {
/*
* Search by ns-prefix.
*/
ns = xmlSearchNs(targetElem->doc, targetElem, prefix);
if ((ns != NULL) && (xmlStrEqual(ns->href, nsName))) {
goto namespace_finished;
}
}
/*
* Fallback to a search by ns-name.
*/
ns = xmlSearchNsByHref(targetElem->doc, targetElem, nsName);
if ((ns != NULL) && (ns->prefix != NULL)) {
goto namespace_finished;
}
/*
* OK, we need to declare the namespace on the target element.
*/
if (prefix) {
if (targetElem->nsDef != NULL) {
ns = targetElem->nsDef;
do {
if ((ns->prefix) && xmlStrEqual(ns->prefix, prefix)) {
/*
* The prefix is aready occupied.
*/
break;
}
ns = ns->next;
} while (ns != NULL);
if (ns == NULL) {
ns = xmlNewNs(targetElem, nsName, prefix);
goto namespace_finished;
}
}
}
/*
* Generate a new prefix.
*/
{
const xmlChar *basepref = prefix;
xmlChar pref[30];
int counter = 1;
if (prefix != NULL)
basepref = prefix;
else
basepref = xmlStrdup(BAD_CAST "ns");
do {
snprintf((char *) pref, 30, "%s%d",
basepref, counter++);
ns = xmlSearchNs(targetElem->doc, targetElem, BAD_CAST pref);
if (counter > 1000) {
xsltTransformError(ctxt, NULL, inst,
"Namespace fixup error: Failed to compute a "
"new unique ns-prefix for the generated attribute "
"{%s}%s'.\n", nsName, name);
ns = NULL;
break;
}
} while (ns != NULL);
if (basepref != prefix)
xmlFree((xmlChar *)basepref);
ns = xmlNewNs(targetElem, nsName, BAD_CAST pref);
}
namespace_finished:
if (ns == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Namespace fixup error: Failed to acquire an in-scope "
"namespace binding of the generated attribute '{%s}%s'.\n",
nsName, name);
/*
* TODO: Should we just stop here?
*/
}
}
/*
* Construction of the value
* -------------------------
*/
if (inst->children == NULL) {
/*
* No content.
* TODO: Do we need to put the empty string in ?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
} else if ((inst->children->next == NULL) &&
((inst->children->type == XML_TEXT_NODE) ||
(inst->children->type == XML_CDATA_SECTION_NODE)))
{
xmlNodePtr origTxt = inst->children, copyTxt;
/*
* Optimization: if the content is just 1 text node, then
* just need to copy it over, or just assign it to the result
* if the string is shared.
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
if (attr == NULL) /* TODO: report error ? */
goto error;
/*
* This was taken over from xsltCopyText() (transform.c).
*/
if (ctxt->internalized &&
(ctxt->insert->doc != NULL) &&
(ctxt->insert->doc->dict == ctxt->dict))
{
copyTxt = xmlNewText(NULL);
if (copyTxt == NULL) /* TODO: report error */
goto error;
/*
* This is a safe scenario where we don't need to lookup
* the dict.
*/
copyTxt->content = origTxt->content;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (origTxt->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
} else {
/*
* Copy the value.
*/
copyTxt = xmlNewText(origTxt->content);
if (copyTxt == NULL) /* TODO: report error */
goto error;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (origTxt->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
}
if (copyTxt != NULL) {
copyTxt->doc = attr->doc;
xmlAddChild((xmlNodePtr) attr, copyTxt);
}
} else {
/*
* The sequence constructor might be complex, so instantiate it.
*/
value = xsltEvalTemplateString(ctxt, node, inst);
if (value != NULL) {
attr = xmlSetNsProp(ctxt->insert, ns, name, value);
xmlFree(value);
} else {
/*
* TODO: Do we have to add the empty string to the attr?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name,
(const xmlChar *) "");
}
}
error:
return;
}