static int xmlsec_NodeSetWalkCallback(xmlSecNodeSetPtr nset, xmlNodePtr cur, xmlNodePtr parent, void *data) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup2(NodeSetWalkCallbacks, (const xmlChar *)nset->doc->name, nset->doc->URL); args = Py_BuildValue((char *) "OOOO", wrap_xmlSecNodeSetPtr(nset), wrap_xmlNodePtr(cur), wrap_xmlNodePtr(parent), PyCObject_FromVoidPtr((void *) data, NULL)); /* 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)); }
PyObject *xmlsec_TmplEncDataGetEncMethodNode(PyObject *self, PyObject *args) { PyObject *encNode_obj; xmlNodePtr encNode; xmlNodePtr encMethNode; if (CheckArgs(args, "O:tmplEncDataGetEncMethodNode")) { if (!PyArg_ParseTuple(args, "O:tmplEncDataGetEncMethodNode", &encNode_obj)) return NULL; } else return NULL; encNode = xmlNodePtr_get(encNode_obj); encMethNode = xmlSecTmplEncDataGetEncMethodNode(encNode); return (wrap_xmlNodePtr(encMethNode)); }
PyObject *xmlsec_TmplKeyInfoAddKeyValue(PyObject *self, PyObject *args) { PyObject *keyInfoNode_obj; xmlNodePtr keyInfoNode; xmlNodePtr keyValue; if (CheckArgs(args, "O:tmplKeyInfoAddKeyValue")) { if (!PyArg_ParseTuple(args, "O:tmplKeyInfoAddKeyValue", &keyInfoNode_obj)) return NULL; } else return NULL; keyInfoNode = xmlNodePtr_get(keyInfoNode_obj); keyValue = xmlSecTmplKeyInfoAddKeyValue(keyInfoNode); return (wrap_xmlNodePtr(keyValue)); }
PyObject *xmlsec_TmplKeyInfoAddX509Data(PyObject *self, PyObject *args) { PyObject *keyInfoNode_obj; xmlNodePtr keyInfoNode; xmlNodePtr X509Data; if (CheckArgs(args, "O:tmplKeyInfoAddX509Data")) { if (!PyArg_ParseTuple(args, "O:tmplKeyInfoAddX509Data", &keyInfoNode_obj)) return NULL; } else return NULL; keyInfoNode = xmlNodePtr_get(keyInfoNode_obj); X509Data = xmlSecTmplKeyInfoAddX509Data(keyInfoNode); return (wrap_xmlNodePtr(X509Data)); }
PyObject *xmlsec_TmplEncDataEnsureCipherValue(PyObject *self, PyObject *args) { PyObject *encNode_obj; xmlNodePtr encNode; xmlNodePtr cipherValNode; if (CheckArgs(args, "O:tmplEncDataEnsureCipherValue")) { if (!PyArg_ParseTuple(args, "O:tmplEncDataEnsureCipherValue", &encNode_obj)) return NULL; } else return NULL; encNode = xmlNodePtr_get(encNode_obj); cipherValNode = xmlSecTmplEncDataEnsureCipherValue(encNode); return (wrap_xmlNodePtr(cipherValNode)); }
PyObject *xmlsec_TmplSignatureGetC14NMethodNode(PyObject *self, PyObject *args) { PyObject * signNode_obj; xmlNodePtr signNode; xmlNodePtr node; if (CheckArgs(args, "O:tmplSignatureGetC14NMethodNode")) { if (!PyArg_ParseTuple(args, "O:tmplSignatureGetC14NMethodNode", &signNode_obj)) return NULL; } else return NULL; signNode = xmlNodePtr_get(signNode_obj); node = xmlSecTmplSignatureGetC14NMethodNode(signNode); return (wrap_xmlNodePtr(node)); }
PyObject *xmlsec_TmplKeyInfoAddKeyName(PyObject *self, PyObject *args) { PyObject *keyInfoNode_obj; xmlNodePtr keyInfoNode; const xmlChar *name; xmlNodePtr keyName; if (CheckArgs(args, "Os:tmplKeyInfoAddKeyName")) { if (!PyArg_ParseTuple(args, "Oz:tmplKeyInfoAddKeyName", &keyInfoNode_obj, &name)) return NULL; } else return NULL; keyInfoNode = xmlNodePtr_get(keyInfoNode_obj); keyName = xmlSecTmplKeyInfoAddKeyName(keyInfoNode, name); return (wrap_xmlNodePtr(keyName)); }
PyObject *xmlsec_TmplReferenceListAddKeyReference(PyObject *self, PyObject *args) { PyObject *encNode_obj; xmlNodePtr encNode; const xmlChar *uri = NULL; xmlNodePtr keyRefNode; if (CheckArgs(args, "Os:tmplReferenceListAddKeyReference")) { if (!PyArg_ParseTuple(args, "Oz:tmplReferenceListAddKeyReference", &encNode_obj, &uri)) return NULL; } else return NULL; encNode = xmlNodePtr_get(encNode_obj); keyRefNode = xmlSecTmplReferenceListAddKeyReference(encNode, uri); return (wrap_xmlNodePtr(keyRefNode)); }
PyObject *xmlsec_TmplSignatureEnsureKeyInfo(PyObject *self, PyObject *args) { PyObject *signNode_obj; xmlNodePtr signNode; const xmlChar *id = NULL; xmlNodePtr eki; if (CheckArgs(args, "Os:tmplSignatureEnsureKeyInfo")) { if (!PyArg_ParseTuple(args, "Oz:tmplSignatureEnsureKeyInfo", &signNode_obj, &id)) return NULL; } else return NULL; signNode = xmlNodePtr_get(signNode_obj); eki = xmlSecTmplSignatureEnsureKeyInfo(signNode, id); return (wrap_xmlNodePtr(eki)); }
PyObject *xmlsec_TmplEncDataEnsureEncProperties(PyObject *self, PyObject *args) { PyObject *encNode_obj; xmlNodePtr encNode; const xmlChar *id = NULL; xmlNodePtr encPropNode; if (CheckArgs(args, "Os:tmplEncDataEnsureEncProperties")) { if (!PyArg_ParseTuple(args, "Oz:tmplEncDataEnsureEncProperties", &encNode_obj, &id)) return NULL; } else return NULL; encNode = xmlNodePtr_get(encNode_obj); encPropNode = xmlSecTmplEncDataEnsureEncProperties(encNode, id); return (wrap_xmlNodePtr(encPropNode)); }
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)); }
PyObject *xmlsec_TmplObjectAddManifest(PyObject *self, PyObject *args) { PyObject *objectNode_obj; xmlNodePtr objectNode; const xmlChar *id = NULL; xmlNodePtr manifest; if (CheckArgs(args, "Os:tmplObjectAddManifest")) { if (!PyArg_ParseTuple(args, "Oz:tmplObjectAddManifest", &objectNode_obj, &id)) return NULL; } else return NULL; objectNode = xmlNodePtr_get(objectNode_obj); manifest = xmlSecTmplObjectAddManifest(objectNode, id); return (wrap_xmlNodePtr(manifest)); }
PyObject *xmlsec_TmplKeyInfoAddRetrievalMethod(PyObject *self, PyObject *args) { PyObject *keyInfoNode_obj; xmlNodePtr keyInfoNode; const xmlChar *uri = NULL; const xmlChar *type = NULL; xmlNodePtr node; if (CheckArgs(args, "Oss:tmplKeyInfoAddRetrievalMethod")) { if (!PyArg_ParseTuple(args, "Ozz:tmplKeyInfoAddRetrievalMethod", &keyInfoNode_obj, &uri, &type)) return NULL; } else return NULL; keyInfoNode = xmlNodePtr_get(keyInfoNode_obj); node = xmlSecTmplKeyInfoAddRetrievalMethod(keyInfoNode, uri, type); return (wrap_xmlNodePtr(node)); }
PyObject *xmlsec_TmplEncDataAddEncProperty(PyObject *self, PyObject *args) { PyObject *encNode_obj; xmlNodePtr encNode; const xmlChar *id = NULL; const xmlChar *target = NULL; xmlNodePtr encPropNode; if (CheckArgs(args, "Oss:tmplEncDataAddEncProperty")) { if (!PyArg_ParseTuple(args, "Ozz:tmplEncDataAddEncProperty", &encNode_obj, &id, &target)) return NULL; } else return NULL; encNode = xmlNodePtr_get(encNode_obj); encPropNode = xmlSecTmplEncDataAddEncProperty(encNode, id, target); return (wrap_xmlNodePtr(encPropNode)); }
PyObject *xmlsec_TmplObjectAddSignProperties(PyObject *self, PyObject *args) { PyObject *objectNode_obj; xmlNodePtr objectNode; const xmlChar *id = NULL; const xmlChar *target = NULL; xmlNodePtr signProperties; if (CheckArgs(args, "Oss:tmplObjectAddSignProperties")) { if (!PyArg_ParseTuple(args, "Ozz:tmplObjectAddSignProperties", &objectNode_obj, &id, &target)) return NULL; } else return NULL; objectNode = xmlNodePtr_get(objectNode_obj); signProperties = xmlSecTmplObjectAddSignProperties(objectNode, id, target); return (wrap_xmlNodePtr(signProperties)); }
PyObject *xmlsec_TmplReferenceAddTransform(PyObject *self, PyObject *args) { PyObject *referenceNode_obj, *transformId_obj; xmlNodePtr referenceNode; xmlSecTransformId transformId; xmlNodePtr transform; if (CheckArgs(args, "OO:tmplReferenceAddTransform")) { if (!PyArg_ParseTuple(args, "OO:tmplReferenceAddTransform", &referenceNode_obj, &transformId_obj)) return NULL; } else return NULL; referenceNode = xmlNodePtr_get(referenceNode_obj); transformId = xmlSecTransformId_get(transformId_obj); transform = xmlSecTmplReferenceAddTransform(referenceNode, transformId); return (wrap_xmlNodePtr(transform)); }
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)); }
PyObject *xmlSecTransform_getattr(PyObject *self, PyObject *args) { PyObject *transform_obj; xmlSecTransformPtr transform; const char *attr; if (CheckArgs(args, "OS:transformGetAttr")) { if (!PyArg_ParseTuple(args, "Os:transformGetAttr", &transform_obj, &attr)) return NULL; } else return NULL; transform = xmlSecTransformPtr_get(transform_obj); if (!strcmp(attr, "__members__")) return Py_BuildValue("[ssssssssss]", "id", "operation", "status", "hereNode", "next", "prev", "inBuf", "outBuf", "inNodes", "outNodes"); if (!strcmp(attr, "id")) return (wrap_xmlSecTransformId(transform->id)); if (!strcmp(attr, "operation")) return (wrap_int(transform->operation)); if (!strcmp(attr, "status")) return (wrap_int(transform->status)); if (!strcmp(attr, "hereNode")) return (wrap_xmlNodePtr(transform->hereNode)); if (!strcmp(attr, "next")) return (wrap_xmlSecTransformPtr(transform->next)); if (!strcmp(attr, "prev")) return (wrap_xmlSecTransformPtr(transform->prev)); if (!strcmp(attr, "inBuf")) return (wrap_xmlSecBufferPtr(&(transform->inBuf))); if (!strcmp(attr, "outBuf")) return (wrap_xmlSecBufferPtr(&(transform->outBuf))); if (!strcmp(attr, "inNodes")) return (wrap_xmlSecNodeSetPtr(transform->inNodes)); if (!strcmp(attr, "outNodes")) return (wrap_xmlSecNodeSetPtr(transform->outNodes)); Py_INCREF(Py_None); return (Py_None); }
PyObject *xmlsec_TmplSignatureAddObject(PyObject *self, PyObject *args) { PyObject * signNode_obj; xmlNodePtr signNode; const xmlChar *id = NULL; const xmlChar *mimeType = NULL; const xmlChar *encoding = NULL; xmlNodePtr obj; if (CheckArgs(args, "Osss:tmplSignatureAddObject")) { if (!PyArg_ParseTuple(args, "Ozzz:tmplSignatureAddObject", &signNode_obj, &id, &mimeType, &encoding)) return NULL; } else return NULL; signNode = xmlNodePtr_get(signNode_obj); obj = xmlSecTmplSignatureAddObject(signNode, id, mimeType, encoding); return (wrap_xmlNodePtr(obj)); }
PyObject *xmlsec_TmplCipherReferenceAddTransform(PyObject *self, PyObject *args) { PyObject *cipherReferenceNode_obj, *transformId_obj; xmlNodePtr cipherReferenceNode; xmlSecTransformId transformId; xmlNodePtr dsigTransNode; if (CheckArgs(args, "OO:tmplCipherReferenceAddTransform")) { if (!PyArg_ParseTuple(args, "OO:tmplCipherReferenceAddTransform", &cipherReferenceNode_obj, &transformId_obj)) return NULL; } else return NULL; cipherReferenceNode = xmlNodePtr_get(cipherReferenceNode_obj); transformId = xmlSecTransformId_get(transformId_obj); dsigTransNode = xmlSecTmplCipherReferenceAddTransform(cipherReferenceNode, transformId); return (wrap_xmlNodePtr(dsigTransNode)); }
static int xmlsec_TransformNodeWriteMethod(xmlSecTransformPtr transform, xmlNodePtr node, xmlSecTransformCtxPtr transformCtx) { PyObject *args, *result; PyObject *func = NULL; func = xmlHashLookup2(TransformNodeWriteMethods, transform->id->name, transform->id->href); args = Py_BuildValue((char *) "OOO", wrap_xmlSecTransformPtr(transform), wrap_xmlNodePtr(node), wrap_xmlSecTransformCtxPtr(transformCtx)); Py_INCREF(func); result = PyEval_CallObject(func, args); Py_DECREF(func); Py_DECREF(args); return (PyInt_AsLong(result)); }
PyObject *xmlsec_TmplSignatureCreate(PyObject *self, PyObject *args) { PyObject *doc_obj, *c14nMethodId_obj, *signMethodId_obj; xmlDocPtr doc = NULL; xmlSecTransformId c14nMethodId; xmlSecTransformId signMethodId; const xmlChar *id = NULL; xmlNodePtr node; if (CheckArgs(args, "oOOs:tmplSignatureCreate")) { if (!PyArg_ParseTuple(args, "OOOz:tmplSignatureCreate", &doc_obj, &c14nMethodId_obj, &signMethodId_obj, &id)) return NULL; } else return NULL; doc = xmlDocPtr_get(doc_obj); c14nMethodId = xmlSecTransformId_get(c14nMethodId_obj); signMethodId = xmlSecTransformId_get(signMethodId_obj); node = xmlSecTmplSignatureCreate(doc, c14nMethodId, signMethodId, id); return (wrap_xmlNodePtr(node)); }
PyObject *xmlsec_TmplEncDataCreate(PyObject *self, PyObject *args) { PyObject *doc_obj, *encMethodId_obj; xmlDocPtr doc = NULL; xmlSecTransformId encMethodId = NULL; const xmlChar *id = NULL; const xmlChar *type = NULL; const xmlChar *mimeType = NULL; const xmlChar *encoding = NULL; xmlNodePtr encDataNode; if (CheckArgs(args, "oossss:tmplEncDataCreate")) { if (!PyArg_ParseTuple(args, "OOzzzz:tmplEncDataCreate", &doc_obj, &encMethodId_obj, &id, &type, &mimeType, &encoding)) return NULL; } else return NULL; doc = xmlDocPtr_get(doc_obj); encMethodId = xmlSecTransformId_get(encMethodId_obj); encDataNode = xmlSecTmplEncDataCreate(doc, encMethodId, id, type, mimeType, encoding); return (wrap_xmlNodePtr(encDataNode)); }
PyObject *xmlsec_TmplSignatureAddReference(PyObject *self, PyObject *args) { PyObject *signNode_obj, *digestMethodId_obj; xmlNodePtr signNode; xmlSecTransformId digestMethodId; const xmlChar *id = NULL; const xmlChar *uri = NULL; const xmlChar *type = NULL; xmlNodePtr ref; if (CheckArgs(args, "OOsss:tmplSignatureAddReference")) { if (!PyArg_ParseTuple(args, "OOzzz:tmplSignatureAddReference", &signNode_obj, &digestMethodId_obj, &id, &uri, &type)) return NULL; } else return NULL; signNode = xmlNodePtr_get(signNode_obj); digestMethodId = xmlSecTransformId_get(digestMethodId_obj); ref = xmlSecTmplSignatureAddReference(signNode, digestMethodId, id, uri, type); return (wrap_xmlNodePtr(ref)); }
PyObject *xmlsec_TmplKeyInfoAddEncryptedKey(PyObject *self, PyObject *args) { PyObject *keyInfoNode_obj, *encMethodId_obj; xmlNodePtr keyInfoNode; xmlSecTransformId encMethodId = NULL; const xmlChar *id = NULL; const xmlChar *type = NULL; const xmlChar *recipient = NULL; xmlNodePtr encKeyNode; if (CheckArgs(args, "Oosss:tmplKeyInfoAddEncryptedKey")) { if (!PyArg_ParseTuple(args, "OOzzz:tmplKeyInfoAddEncryptedKey", &keyInfoNode_obj, &encMethodId_obj, &id, &type, &recipient)) return NULL; } else return NULL; encMethodId = xmlSecTransformId_get(encMethodId_obj); keyInfoNode = xmlNodePtr_get(keyInfoNode_obj); encKeyNode = xmlSecTmplKeyInfoAddEncryptedKey(keyInfoNode, encMethodId, id, type, recipient); return (wrap_xmlNodePtr(encKeyNode)); }
PyObject *xmlSecDSigCtx_getattr(PyObject *self, PyObject *args) { PyObject *dsigCtx_obj; xmlSecDSigCtxPtr dsigCtx; const char *attr; if (CheckArgs(args, "OS:dsigCtxGetAttr")) { if (!PyArg_ParseTuple(args, "Os:dsigCtxGetAttr", &dsigCtx_obj, &attr)) return NULL; } else return NULL; dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj); if (!strcmp(attr, "__members__")) return Py_BuildValue("[sssssssssssssssssssss]", "flags", "flags2", "keyInfoReadCtx", "keyInfoWriteCtx", "transformCtx", "enabledReferenceUris", "enabledReferenceTransforms", "defSignMethodId", "defC14NMethodId", "defDigestMethodId", "signKey", "operation", "result", "status", "signMethod", "c14nMethod", "preSignMemBufMethod", "signValueNode", "id", "signedInfoReferences", "manifestReferences"); if (!strcmp(attr, "flags")) return (wrap_int(dsigCtx->flags)); if (!strcmp(attr, "flags2")) return (wrap_int(dsigCtx->flags2)); if (!strcmp(attr, "keyInfoReadCtx")) return (wrap_xmlSecKeyInfoCtxPtr(&(dsigCtx->keyInfoReadCtx))); if (!strcmp(attr, "keyInfoWriteCtx")) return (wrap_xmlSecKeyInfoCtxPtr(&(dsigCtx->keyInfoWriteCtx))); if (!strcmp(attr, "transformCtx")) return (wrap_xmlSecTransformCtxPtr(&(dsigCtx->transformCtx))); if (!strcmp(attr, "enabledReferenceUris")) return (wrap_int(dsigCtx->enabledReferenceUris)); if (!strcmp(attr, "enabledReferenceTransforms")) return (wrap_xmlSecPtrListPtr(dsigCtx->enabledReferenceTransforms)); if (!strcmp(attr, "defSignMethodId")) return (wrap_xmlSecTransformId(dsigCtx->defSignMethodId)); if (!strcmp(attr, "defC14NMethodId")) return (wrap_xmlSecTransformId(dsigCtx->defC14NMethodId)); if (!strcmp(attr, "defDigestMethodId")) return (wrap_xmlSecTransformId(dsigCtx->defDigestMethodId)); if (!strcmp(attr, "signKey")) return (wrap_xmlSecKeyPtr(dsigCtx->signKey)); if (!strcmp(attr, "operation")) return (wrap_int(dsigCtx->operation)); if (!strcmp(attr, "result")) return (wrap_xmlSecBufferPtr(dsigCtx->result)); if (!strcmp(attr, "status")) return (wrap_int(dsigCtx->status)); if (!strcmp(attr, "signMethod")) return (wrap_xmlSecTransformPtr(dsigCtx->signMethod)); if (!strcmp(attr, "c14nMethod")) return (wrap_xmlSecTransformPtr(dsigCtx->c14nMethod)); if (!strcmp(attr, "preSignMemBufMethod")) return (wrap_xmlSecTransformPtr(dsigCtx->preSignMemBufMethod)); if (!strcmp(attr, "signValueNode")) return (wrap_xmlNodePtr(dsigCtx->signValueNode)); if (!strcmp(attr, "id")) return (wrap_xmlCharPtr(dsigCtx->id)); if (!strcmp(attr, "signedInfoReferences")) return (wrap_xmlSecPtrListPtr(&(dsigCtx->signedInfoReferences))); if (!strcmp(attr, "manifestReferences")) return (wrap_xmlSecPtrListPtr(&(dsigCtx->manifestReferences))); Py_INCREF(Py_None); return (Py_None); }
PyObject *xmlSecEncCtx_getattr(PyObject *self, PyObject *args) { PyObject *encCtx_obj; xmlSecEncCtxPtr encCtx; const char *attr; if (CheckArgs(args, "OS:encCtxGetAttr")) { if (!PyArg_ParseTuple(args, "Os:encCtxGetAttr", &encCtx_obj, &attr)) return NULL; } else return NULL; encCtx = xmlSecEncCtxPtr_get(encCtx_obj); if (!strcmp(attr, "__members__")) return Py_BuildValue("[sssssssssssssssssssssss]", "flags", "flags2", "mode", "keyInfoReadCtx", "keyInfoWriteCtx", "transformCtx", "defEncMethodId", "encKey", "operation", "result", "resultBase64Encoded", "resultReplaced", "encMethod", "id", "type", "mimeType", "encoding", "recipient", "carriedKeyName", "encDataNode", "encMethodNode", "keyInfoNode", "cipherValueNode"); if (!strcmp(attr, "flags")) return (wrap_int(encCtx->flags)); if (!strcmp(attr, "flags2")) return (wrap_int(encCtx->flags2)); if (!strcmp(attr, "mode")) return (wrap_int(encCtx->mode)); if (!strcmp(attr, "keyInfoReadCtx")) return (wrap_xmlSecKeyInfoCtxPtr(&(encCtx->keyInfoReadCtx))); if (!strcmp(attr, "keyInfoWriteCtx")) return (wrap_xmlSecKeyInfoCtxPtr(&(encCtx->keyInfoWriteCtx))); if (!strcmp(attr, "transformCtx")) return (wrap_xmlSecTransformCtxPtr(&(encCtx->transformCtx))); if (!strcmp(attr, "defEncMethodId")) return (wrap_xmlSecTransformId(encCtx->defEncMethodId)); if (!strcmp(attr, "encKey")) return (wrap_xmlSecKeyPtr(encCtx->encKey)); if (!strcmp(attr, "operation")) return (wrap_int(encCtx->operation)); if (!strcmp(attr, "result")) return (wrap_xmlSecBufferPtr(encCtx->result)); if (!strcmp(attr, "resultBase64Encoded")) return (wrap_int(encCtx->resultBase64Encoded)); if (!strcmp(attr, "resultReplaced")) return (wrap_int(encCtx->resultReplaced)); if (!strcmp(attr, "encMethod")) return (wrap_xmlSecTransformPtr(encCtx->encMethod)); if (!strcmp(attr, "id")) return (wrap_xmlCharPtr(encCtx->id)); if (!strcmp(attr, "type")) return (wrap_xmlCharPtr(encCtx->type)); if (!strcmp(attr, "mimeType")) return (wrap_xmlCharPtr(encCtx->mimeType)); if (!strcmp(attr, "encoding")) return (wrap_xmlCharPtr(encCtx->encoding)); if (!strcmp(attr, "recipient")) return (wrap_xmlCharPtr(encCtx->recipient)); if (!strcmp(attr, "carriedKeyName")) return (wrap_xmlCharPtr(encCtx->carriedKeyName)); if (!strcmp(attr, "encDataNode")) return (wrap_xmlNodePtr(encCtx->encDataNode)); if (!strcmp(attr, "encMethodNode")) return (wrap_xmlNodePtr(encCtx->encMethodNode)); if (!strcmp(attr, "keyInfoNode")) return (wrap_xmlNodePtr(encCtx->keyInfoNode)); if (!strcmp(attr, "cipherValueNode")) return (wrap_xmlNodePtr(encCtx->cipherValueNode)); Py_INCREF(Py_None); return (Py_None); }