boxpath * boxpath_from_string(const char * path) { char * dir = dirname(strdup(path)); char * file = basename(strdup(path)); boxpath * bpath = (boxpath*) malloc(sizeof(boxpath)); bpath->dir = xmlHashLookup(allDirs, dir); bpath->base = strdup(file); bpath->file = (strcmp(path,"/") ? NULL : rootDir); bpath->is_dir = (xmlHashLookup(allDirs, path)!=NULL); free(dir); return bpath; }
/** * xsltCopyNamespace: * @ctxt: a transformation context * @node: the target node * @cur: the namespace node * * Do a copy of an namespace node. If @node is non-NULL the * new namespaces are added automatically. This handles namespaces * aliases * * Returns: a new xmlNsPtr, or NULL in case of error. */ xmlNsPtr xsltCopyNamespace(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNsPtr cur) { xmlNsPtr ret = NULL; const xmlChar *URI; if (cur == NULL) return(NULL); if (cur->type != XML_NAMESPACE_DECL) return(NULL); /* * One can add namespaces only on element nodes */ if ((node != NULL) && (node->type != XML_ELEMENT_NODE)) node = NULL; if (!xmlStrEqual(cur->href, XSLT_NAMESPACE)) { URI = (const xmlChar *) xmlHashLookup(ctxt->style->nsAliases, cur->href); if (URI != NULL) { ret = xmlNewNs(node, URI, cur->prefix); } else { ret = xmlNewNs(node, cur->href, cur->prefix); } } return(ret); }
static HRESULT WINAPI schema_cache_get(IXMLDOMSchemaCollection2* iface, BSTR uri, IXMLDOMNode** node) { schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface); cache_entry* entry; xmlChar* name; TRACE("(%p)->(%s %p)\n", This, debugstr_w(uri), node); if (This->version == MSXML6) { if (node) *node = NULL; return E_NOTIMPL; } if (!node) return E_POINTER; *node = NULL; name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW); entry = (cache_entry*) xmlHashLookup(This->cache, name); heap_free(name); /* TODO: this should be read-only */ if (entry && entry->doc) return get_domdoc_from_xmldoc(entry->doc, (IXMLDOMDocument3**)node); return S_OK; }
static xmlSchemaElementPtr lookup_schema_elemDecl(xmlSchemaPtr schema, xmlNodePtr node) { xmlSchemaElementPtr decl = NULL; xmlChar const* nsURI = get_node_nsURI(node); TRACE("(%p, %p)\n", schema, node); if (xmlStrEqual(nsURI, schema->targetNamespace)) decl = xmlHashLookup(schema->elemDecl, node->name); if (!decl && xmlHashSize(schema->schemasImports) > 1) { FIXME("declaration not found in main schema - need to check schema imports!\n"); /*xmlSchemaImportPtr import; if (nsURI == NULL) import = xmlHashLookup(schema->schemasImports, XML_SCHEMAS_NO_NAMESPACE); else import = xmlHashLookup(schema->schemasImports, node->ns->href); if (import != NULL) decl = xmlHashLookup(import->schema->elemDecl, node->name);*/ } return decl; }
/* * This is called by ??? when reading an annotation is encountered * while reading the instance data. */ xmlParserErrors instance_annotation_callback(void *handle, xmlNodePtr node) { int i; char key[20]; xmlChar* path; xmlDocPtr doc = node->doc; xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc); xmlXPathObjectPtr xpathObj; sprintf(key, "%p", handle); path = (xmlChar*)xmlHashLookup(Handle2Path, (xmlChar*)key); assert(path != NULL); printf("\noooooooooooo %s: %p\n", __FUNCTION__, handle); dump_doc(node->doc, node); /* walk_doc_tree(node, 0); */ printf("\n"); xpathCtx->node = node; xpathObj = xmlXPathEvalExpression(path, xpathCtx); if (xpathObj->nodesetval != NULL) for (i = 0; i < xpathObj->nodesetval->nodeNr; ++i) printf("xpath(\"%s\") => %s\n", path, xmlNodeGetContent(xpathObj->nodesetval->nodeTab[i])); return XML_ERR_OK; }
/** * xsltGetNamespace: * @ctxt: a transformation context * @cur: the input node * @ns: the namespace * @out: the output node (or its parent) * * Find a matching (prefix and ns-name) ns-declaration * for the requested @ns->prefix and @ns->href in the result tree. * If none is found then a new ns-declaration will be * added to @resultElem. If, in this case, the given prefix is * already in use, then a ns-declaration with a modified ns-prefix * be we created. * * Called by: * - xsltCopyPropList() (*not* anymore) * - xsltShallowCopyElement() * - xsltCopyTreeInternal() (*not* anymore) * - xsltApplySequenceConstructor() (*not* in the refactored code), * - xsltElement() (*not* anymore) * * Returns a namespace declaration or NULL in case of * namespace fixup failures or API or internal errors. */ xmlNsPtr xsltGetNamespace(xsltTransformContextPtr ctxt, xmlNodePtr cur, xmlNsPtr ns, xmlNodePtr out) { if (ns == NULL) return(NULL); #ifdef XSLT_REFACTORED /* * Namespace exclusion and ns-aliasing is performed at * compilation-time in the refactored code. * Additionally, aliasing is not intended for non Literal * Result Elements. */ return(xsltGetSpecialNamespace(ctxt, cur, ns->href, ns->prefix, out)); #else { xsltStylesheetPtr style; const xmlChar *URI = NULL; /* the replacement URI */ if ((ctxt == NULL) || (cur == NULL) || (out == NULL)) return(NULL); style = ctxt->style; while (style != NULL) { if (style->nsAliases != NULL) URI = (const xmlChar *) xmlHashLookup(style->nsAliases, ns->href); if (URI != NULL) break; style = xsltNextImport(style); } if (URI == UNDEFINED_DEFAULT_NS) { return(xsltGetSpecialNamespace(ctxt, cur, NULL, NULL, out)); #if 0 /* * TODO: Removed, since wrong. If there was no default * namespace in the stylesheet then this must resolve to * the NULL namespace. */ xmlNsPtr dflt; dflt = xmlSearchNs(cur->doc, cur, NULL); if (dflt != NULL) URI = dflt->href; else return NULL; #endif } else if (URI == NULL) URI = ns->href; return(xsltGetSpecialNamespace(ctxt, cur, URI, ns->prefix, out)); } #endif }
HRESULT SchemaCache_validate_tree(IXMLDOMSchemaCollection2* iface, xmlNodePtr tree) { schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface); cache_entry* entry; xmlChar const* ns = NULL; TRACE("(%p, %p)\n", This, tree); if (!tree) return E_POINTER; if ((xmlNodePtr)tree->doc == tree) { xmlNodePtr root = xmlDocGetRootElement(tree->doc); if (root && root->ns) ns = root->ns->href; } else if (tree->ns) { ns = tree->ns->href; } entry = xmlHashLookup(This->cache, ns); /* TODO: if the ns is not in the cache, and it's a URL, * do we try to load from that? */ if (entry) { if (entry->type == SCHEMA_TYPE_XDR) { FIXME("partial stub: XDR schema support not implemented\n"); return S_OK; } else if (entry->type == SCHEMA_TYPE_XSD) { xmlSchemaValidCtxtPtr svctx; int err; /* TODO: if validateOnLoad property is false, * we probably need to validate the schema here. */ svctx = xmlSchemaNewValidCtxt(entry->schema); xmlSchemaSetValidErrors(svctx, validate_error, validate_warning, NULL); #ifdef HAVE_XMLSCHEMASSETVALIDSTRUCTUREDERRORS xmlSchemaSetValidStructuredErrors(svctx, validate_serror, NULL); #endif if ((xmlNodePtr)tree->doc == tree) err = xmlSchemaValidateDoc(svctx, (xmlDocPtr)tree); else err = xmlSchemaValidateOneElement(svctx, tree); xmlSchemaFreeValidCtxt(svctx); return err? S_FALSE : S_OK; } } return E_FAIL; }
static void cache_copy(void* data, void* dest, xmlChar* name) { schema_cache* This = (schema_cache*) dest; cache_entry* entry = (cache_entry*) data; if (xmlHashLookup(This->cache, name) == NULL) { cache_entry_add_ref(entry); xmlHashAddEntry(This->cache, name, entry); } }
/** * xsltGetKey: * @ctxt: an XSLT transformation context * @name: the key name or NULL * @nameURI: the name URI or NULL * @value: the key value to look for * * Looks up a key of the in current source doc (the document info * on @ctxt->document). Computes the key if not already done * for the current source doc. * * Returns the nodeset resulting from the query or NULL */ xmlNodeSetPtr xsltGetKey(xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *nameURI, const xmlChar *value) { xmlNodeSetPtr ret; xsltKeyTablePtr table; int init_table = 0; if ((ctxt == NULL) || (name == NULL) || (value == NULL) || (ctxt->document == NULL)) return(NULL); #ifdef WITH_XSLT_DEBUG_KEYS xsltGenericDebug(xsltGenericDebugContext, "Get key %s, value %s\n", name, value); #endif /* * keys are computed only on-demand on first key access for a document */ if ((ctxt->document->nbKeysComputed < ctxt->nbKeys) && (ctxt->keyInitLevel == 0)) { /* * If non-recursive behaviour, just try to initialize all keys */ if (xsltInitAllDocKeys(ctxt)) return(NULL); } retry: table = (xsltKeyTablePtr) ctxt->document->keys; while (table != NULL) { if (((nameURI != NULL) == (table->nameURI != NULL)) && xmlStrEqual(table->name, name) && xmlStrEqual(table->nameURI, nameURI)) { ret = (xmlNodeSetPtr)xmlHashLookup(table->keys, value); return(ret); } table = table->next; } if ((ctxt->keyInitLevel != 0) && (init_table == 0)) { /* * Apparently one key is recursive and this one is needed, * initialize just it, that time and retry */ xsltInitDocKeyTable(ctxt, name, nameURI); init_table = 1; goto retry; } return(NULL); }
/*********************************************************************** * Function Name : CNTRLXMLGETReqHandler * Description : This function calls the registered callback functions against the XML file URL * Input : regUrl - XML file URL * pOutXMLStr - Response XML buffer * Output : none * Return value : CNTRLXML_SUCCESS, CNTRLXML_FAILURE, CNTRLXML_BADPARAM ***********************************************************************/ t_char8 CNTRLXMLGETReqHandler (t_char8 * pInXMLFile, t_void * pAppData, t_char8 ** pOutXMLStr) { XMLTEMPLATE_CALLBACK_HANDLER pCbfun; t_int32 retStatus = CNTRLXML_SUCCESS; if (!pInXMLFile) { XML_Error ("pInXMLFile is NULL"); return CNTRLXML_BADPARAM; } XML_DebugArg ("Look up for tag = ", pInXMLFile); pCbfun = xmlHashLookup (hTable, pInXMLFile); if (pCbfun != NULL) { XML_DebugArg ("Found function for tag =", pInXMLFile); retStatus = (*pCbfun) (pInXMLFile, pAppData); if (retStatus != CNTRLXML_SUCCESS) { XML_Error ("GET Request CbkFunction Failed"); if(pXMLErrorStr) { *pOutXMLStr = xmlStrdup ((const xmlChar *) pXMLErrorStr); XML_DebugArg ("*pOutXMLStr=", *pOutXMLStr); XMLBUFFERFREE (pXMLErrorStr); pXMLErrorStr = NULL; return CNTRLXML_SUCCESS; } *pOutXMLStr = NULL; return CNTRLXML_FAILURE; } /**pOutXMLStr = (t_char8*) T_malloc(T_strlen(pXMLResultStr)+1); of_strcpy(*pOutXMLStr, pXMLResultStr);*/ *pOutXMLStr = xmlStrdup ((const xmlChar *) pXMLResultStr); XML_DebugArg ("*pOutXMLStr=", *pOutXMLStr); XMLBUFFERFREE (pXMLResultStr); pXMLResultStr = NULL; return CNTRLXML_SUCCESS; } return CNTRLXML_FAILURE; }
/** * breakPointGet: * @url: Non-null, non-empty file name that has been loaded by * debugger * @lineNumber: lineNumber >= 0 and is available in @url * * Get a break point for the breakpoint collection * * Returns break point if break point exists at location specified, * NULL otherwise */ breakPointPtr breakPointGet(const xmlChar * url, long lineNumber) { xmlHashTablePtr breakHash = breakPointGetLineNoHash(lineNumber); breakPointPtr breakPtr = NULL; if (!breakHash || !url) return breakPtr; breakPtr = (breakPointPtr)xmlHashLookup(breakHash, url); return breakPtr; }
/* * session_from_hargs * * Return a session from a handler struct session key */ struct session* session_from_hargs(struct handler_args* hargs, xmlHashTablePtr sessions, struct qz_config* conf){ uint64_t etag_payload; unsigned char session_id[9]; struct session* this_session; etag_payload = validate_etag(hargs->conf->tagger_socket_path, hargs->session_key); if (etag_payload == 0){ fprintf(hargs->log, "%f %d %s:%d session key not validated\n", gettime(), hargs->request_id, __func__, __LINE__); return NULL; } memcpy(session_id, &etag_payload, 8); session_id[8] = '\0'; this_session = xmlHashLookup(sessions, session_id); if (this_session==NULL){ fprintf(hargs->log, "%f %d %s:%d null session from hash lookup\n", gettime(), hargs->request_id, __func__, __LINE__); return NULL; } if (this_session->integrity_token != conf->integrity_token){ // The last 64 bits of the session struct have been // altered. The session record is corrupted. // Clean up the session close_session(hargs, this_session); fprintf(hargs->log,"%f %d %s:%d session closed for bad integrity token", gettime(), hargs->request_id, __func__, __LINE__); return NULL; } fprintf(hargs->log, "%f %d %s:%d user=%s\n", gettime(), hargs->request_id, __func__, __LINE__, this_session->user); return this_session; }
static xar_file_t xar_link_lookup(xar_t x, dev_t dev, ino_t ino, xar_file_t f) { char key[32]; xar_file_t ret; memset(key, 0, sizeof(key)); snprintf(key, sizeof(key)-1, "%08" DEV_HEXSTRING "%08" INO_HEXSTRING, DEV_CAST dev, INO_CAST ino); ret = xmlHashLookup(XAR(x)->ino_hash, BAD_CAST(key)); if( ret == NULL ) { xmlHashAddEntry(XAR(x)->ino_hash, BAD_CAST(key), XAR_FILE(f)); return NULL; } return ret; }
USER_OBJECT_ R_libxmlTypeTable_lookup(USER_OBJECT_ table, USER_OBJECT_ name, USER_OBJECT_ s_elType) { xmlHashTablePtr t; USER_OBJECT_ ans; void *p; t = R_getExternalRef(table, NULL); /* R_libxmlTypeTableGetRef(table); */ p = xmlHashLookup(t, CHAR_DEREF(STRING_ELT(name, 0))); ans = R_makeRefObject(p, CHAR_DEREF(STRING_ELT(s_elType, 0))); return(ans); }
static void xmlsec_KeyStoreFinalizeMethod(xmlSecKeyStorePtr store) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyStoreFinalizeMethods, store->id->name); args = Py_BuildValue((char *) "O", wrap_xmlSecKeyStorePtr(store)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); Py_XDECREF(result); }
static xmlSecKeyDataType xmlsec_KeyDataGetSizeMethod(xmlSecKeyDataPtr data) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyDataGetSizeMethods, data->id->name); args = Py_BuildValue((char *) "O", wrap_xmlSecKeyDataPtr(data)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return (PyInt_AsLong(result)); }
static const xmlChar* xmlsec_KeyDataGetIdentifierMethod(xmlSecKeyDataPtr data) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyDataGetIdentifierMethods, data->id->name); args = Py_BuildValue((char *) "O", wrap_xmlSecKeyDataPtr(data)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return ((const xmlChar*)PyString_AsString(result)); }
static int xmlsec_KeyStoreInitializeMethod(xmlSecKeyStorePtr store) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyStoreInitializeMethods, store->id->name); args = Py_BuildValue((char *) "O", wrap_xmlSecKeyStorePtr(store)); /* Protect refcount against reentrant manipulation of callback hash */ Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return (PyInt_AsLong(result)); }
static void xmlsec_KeyDataDebugDumpMethod(xmlSecKeyDataPtr data, FILE *output) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyDataDebugDumpMethods, data->id->name); args = Py_BuildValue((char *) "OO", wrap_xmlSecKeyDataPtr(data), PyFile_FromFile(output, NULL, NULL, NULL)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); Py_XDECREF(result); }
static int xmlsec_KeyDataDuplicateMethod(xmlSecKeyDataPtr dst, xmlSecKeyDataPtr src) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyDataDuplicateMethods, src->id->name); args = Py_BuildValue((char *) "OO", wrap_xmlSecKeyDataPtr(dst), wrap_xmlSecKeyDataPtr(src)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return (PyInt_AsLong(result)); }
/*********************************************************************** * Function Name : CNTRLXMLGetRegHandler * Description : This function retrives registered callback functions for the given Module name. * Input : pInModule - Module name * Output : pOutFunLst - Registered function list * Return value : CNTRLXML_SUCCESS, CNTRLXML_FAILURE, CNTRLXML_BADPARAM ***********************************************************************/ t_char8 CNTRLXMLGetRegHandler (t_char8 * pInModule, t_void ** pOutFunLst) { XML_DebugArg ("Look up for tag = ", pInModule); *pOutFunLst = (t_void *) xmlHashLookup (pModSetTable, pInModule); if (*pOutFunLst == NULL) { XML_DebugArg ("Could not find function for tag", pInModule); return CNTRLXML_FAILURE; } XML_DebugArg ("Found function for tag = %s", pInModule); return CNTRLXML_SUCCESS; }
static xmlSecKeyPtr xmlsec_GetKeyCallback(xmlNodePtr keyInfoNode, xmlSecKeyInfoCtxPtr keyInfoCtx) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(GetKeyCallbacks, keyInfoCtx->keysMngr->keysStore->id->name); args = Py_BuildValue((char *) "OO", wrap_xmlNodePtr(keyInfoNode), wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return (xmlSecKeyPtr_get(result)); }
static void xmlsec_PtrDestroyItemMethod(xmlSecPtr ptr) { xmlSecPtrListPtr list; PyObject *args, *result; PyObject *func = NULL; list = (xmlSecPtrListPtr) ptr; func = xmlHashLookup(PtrDestroyItemMethods, list->id->name); args = Py_BuildValue((char *) "O", wrap_xmlSecPtr(ptr)); /* Protect refcount against reentrant manipulation of callback hash */ Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); Py_XDECREF(result); }
static int xmlsec_KeyDataXmlWriteMethod(xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyDataXmlWriteMethods, id->name); args = Py_BuildValue((char *) "OOOO", wrap_xmlSecKeyDataId(id), wrap_xmlSecKeyPtr(key), wrap_xmlNodePtr(node), wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return (PyInt_AsLong(result)); }
static void xmlsec_PtrDebugXmlDumpItemMethod(xmlSecPtr ptr, FILE *output) { xmlSecPtrListPtr list; PyObject *args, *result; PyObject *func = NULL; list = (xmlSecPtrListPtr) ptr; func = xmlHashLookup(PtrDebugXmlDumpItemMethods, list->id->name); /* FIXME */ args = Py_BuildValue((char *) "OO", wrap_xmlSecPtr(ptr), PyFile_FromFile(output, NULL, NULL, NULL)); /* Protect refcount against reentrant manipulation of callback hash */ Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); Py_XDECREF(result); }
/** * xsltCopyNamespaceList: * @ctxt: a transformation context * @node: the target node * @cur: the first namespace * * Do a copy of an namespace list. If @node is non-NULL the * new namespaces are added automatically. This handles namespaces * aliases * * Returns: a new xmlNsPtr, or NULL in case of error. */ xmlNsPtr xsltCopyNamespaceList(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNsPtr cur) { xmlNsPtr ret = NULL; xmlNsPtr p = NULL,q; const xmlChar *URI; if (cur == NULL) return(NULL); if (cur->type != XML_NAMESPACE_DECL) return(NULL); /* * One can add namespaces only on element nodes */ if ((node != NULL) && (node->type != XML_ELEMENT_NODE)) node = NULL; while (cur != NULL) { if (cur->type != XML_NAMESPACE_DECL) break; if (!xmlStrEqual(cur->href, XSLT_NAMESPACE)) { /* TODO apply cascading */ URI = (const xmlChar *) xmlHashLookup(ctxt->style->nsAliases, cur->href); if (URI != NULL) { q = xmlNewNs(node, URI, cur->prefix); } else { q = xmlNewNs(node, cur->href, cur->prefix); } if (p == NULL) { ret = p = q; } else { p->next = q; p = q; } } cur = cur->next; } return(ret); }
// Move a dir to another path in the tree, // recursively updating all the child entries in allDirs void boxtree_movedir(const char * from, const char * to) { boxdir * aDir = xmlHashLookup(allDirs, from); list_iter it; char * newfrom, * newto, *name; if(!aDir) { syslog(LOG_ERR, "no such directory %s", from); return; } for (it=list_get_iter(aDir->folders); it; it = list_iter_next(it)) { name = ((boxfile*)list_iter_getval(it))->name; newfrom = pathappend(from, name); newto = pathappend(to, name); boxtree_movedir(newfrom, newto); free(newfrom); free(newto); } //LOCKDIR(aDir); xmlHashRemoveEntry(allDirs, from, NULL); xmlHashAddEntry(allDirs, to, aDir); //UNLOCKDIR(aDir); }
static int xmlsec_KeyDataBinReadMethod(xmlSecKeyDataId id, xmlSecKeyPtr key, const xmlSecByte *buf, xmlSecSize bufSize, xmlSecKeyInfoCtxPtr keyInfoCtx) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyDataBinReadMethods, id->name); args = Py_BuildValue((char *) "OOsiO", wrap_xmlSecKeyDataId(id), wrap_xmlSecKeyPtr(key), buf, bufSize, wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return (PyInt_AsLong(result)); }
static xmlSecKeyPtr xmlsec_KeyStoreFindKeyMethod(xmlSecKeyStorePtr store, xmlChar *name, xmlSecKeyInfoCtxPtr keyInfoCtx) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup(KeyStoreFindKeyMethods, store->id->name); args = Py_BuildValue((char *) "OsO", wrap_xmlSecKeyStorePtr(store), name, wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx)); Py_INCREF(func); result = PyEval_CallObject(func, args); if (result == NULL) { return (NULL); } Py_DECREF(func); Py_DECREF(args); return (xmlSecKeyPtr_get(result)); }
static HRESULT WINAPI schema_cache_get(IXMLDOMSchemaCollection2* iface, BSTR uri, IXMLDOMNode** node) { schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface); xmlChar* name; cache_entry* entry; TRACE("(%p)->(%s, %p)\n", This, wine_dbgstr_w(uri), node); if (!node) return E_POINTER; name = xmlChar_from_wchar(uri); entry = (cache_entry*) xmlHashLookup(This->cache, name); heap_free(name); /* TODO: this should be read-only */ if (entry) return DOMDocument_create_from_xmldoc(entry->doc, (IXMLDOMDocument3**)node); *node = NULL; return S_OK; }