PyObject *xmlSecDSigCtx_setattr(PyObject *self, PyObject *args) {
PyObject *dsigCtx_obj, *value_obj;
xmlSecDSigCtxPtr dsigCtx;
const char *name;
if (CheckArgs(args, "OS?:dsigCtxSetAttr")) {
if (!PyArg_ParseTuple(args, "OsO:dsigCtxSetAttr",
&dsigCtx_obj, &name, &value_obj))
return NULL;
}
else return NULL;
dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj);
if (!strcmp(name, "flags"))
dsigCtx->flags = PyInt_AsLong(value_obj);
else if (!strcmp(name, "flags2"))
dsigCtx->flags2 = PyInt_AsLong(value_obj);
else if (!strcmp(name, "keyInfoReadCtx"))
dsigCtx->keyInfoReadCtx = *(xmlSecKeyInfoCtxPtr_get(value_obj));
else if (!strcmp(name, "keyInfoWriteCtx"))
dsigCtx->keyInfoWriteCtx = *(xmlSecKeyInfoCtxPtr_get(value_obj));
else if (!strcmp(name, "transformCtx"))
dsigCtx->transformCtx = *(xmlSecTransformCtxPtr_get(value_obj));
else if (!strcmp(name, "enabledReferenceUris"))
dsigCtx->enabledReferenceUris = PyInt_AsLong(value_obj);
else if (!strcmp(name, "enabledReferenceTransforms"))
dsigCtx->enabledReferenceTransforms = xmlSecPtrListPtr_get(value_obj);
else if (!strcmp(name, "defSignMethodId"))
dsigCtx->defSignMethodId = xmlSecTransformId_get(value_obj);
else if (!strcmp(name, "defC14NMethodId"))
dsigCtx->defC14NMethodId = xmlSecTransformId_get(value_obj);
else if (!strcmp(name, "defDigestMethodId"))
dsigCtx->defDigestMethodId = xmlSecTransformId_get(value_obj);
else if (!strcmp(name, "signKey"))
dsigCtx->signKey = xmlSecKeyPtr_get(value_obj);
else if (!strcmp(name, "operation"))
dsigCtx->operation = PyInt_AsLong(value_obj);
else if (!strcmp(name, "result"))
dsigCtx->result = xmlSecBufferPtr_get(value_obj);
else if (!strcmp(name, "status"))
dsigCtx->status = PyInt_AsLong(value_obj);
else if (!strcmp(name, "signMethod"))
dsigCtx->signMethod = xmlSecTransformPtr_get(value_obj);
else if (!strcmp(name, "c14nMethod"))
dsigCtx->c14nMethod = xmlSecTransformPtr_get(value_obj);
else if (!strcmp(name, "preSignMemBufMethod"))
dsigCtx->preSignMemBufMethod = xmlSecTransformPtr_get(value_obj);
else if (!strcmp(name, "signValueNode"))
dsigCtx->signValueNode = xmlNodePtr_get(value_obj);
else if (!strcmp(name, "id"))
dsigCtx->id = (xmlChar *)PyString_AsString(value_obj);
else if (!strcmp(name, "signedInfoReferences"))
dsigCtx->signedInfoReferences = *(xmlSecPtrListPtr_get(value_obj));
else if (!strcmp(name, "manifestReferences"))
dsigCtx->manifestReferences = *(xmlSecPtrListPtr_get(value_obj));
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_EncCtxXmlEncrypt(PyObject *self, PyObject *args) {
PyObject *encCtx_obj, *tmpl_obj, *node_obj;
xmlSecEncCtxPtr encCtx;
xmlNodePtr tmpl, node;
if (CheckArgs(args, "OOO:encCtxXmlEncrypt")) {
if (!PyArg_ParseTuple(args, "OOO:encCtxXmlEncrypt", &encCtx_obj, &tmpl_obj,
&node_obj))
return NULL;
}
else return NULL;
encCtx = xmlSecEncCtxPtr_get(encCtx_obj);
tmpl = xmlNodePtr_get(tmpl_obj);
node = xmlNodePtr_get(node_obj);
return (wrap_int(xmlSecEncCtxXmlEncrypt(encCtx, tmpl, node)));
}
PyObject *xmlsec_NodeSetContains(PyObject *self, PyObject *args) {
PyObject *nset_obj, *node_obj, *parent_obj;
xmlSecNodeSetPtr nset;
xmlNodePtr node;
xmlNodePtr parent;
if (CheckArgs(args, "OOO:nodeSetContains")) {
if (!PyArg_ParseTuple(args, "OOO:nodeSetContains", &nset_obj, &node_obj,
&parent_obj))
return NULL;
}
else return NULL;
nset = xmlSecNodeSetPtr_get(nset_obj);
node = xmlNodePtr_get(node_obj);
parent = xmlNodePtr_get(parent_obj);
return (wrap_int(xmlSecNodeSetContains(nset, node, parent)));
}
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_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_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_DSigCtxSign(PyObject *self, PyObject *args) {
PyObject *dsigCtx_obj, *tmpl_obj;
xmlSecDSigCtxPtr dsigCtx;
xmlNodePtr tmpl;
if (CheckArgs(args, "OO:dsigCtxSign")) {
if (!PyArg_ParseTuple(args, "OO:dsigCtxSign", &dsigCtx_obj, &tmpl_obj))
return NULL;
}
else return NULL;
dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj);
tmpl = xmlNodePtr_get(tmpl_obj);
return (wrap_int(xmlSecDSigCtxSign(dsigCtx, tmpl)));
}
PyObject *xmlsec_DSigCtxVerify(PyObject *self, PyObject *args) {
PyObject *dsigCtx_obj, *node_obj;
xmlSecDSigCtxPtr dsigCtx;
xmlNodePtr node;
if (CheckArgs(args, "OO:dsigCtxVerify")) {
if (!PyArg_ParseTuple(args, "OO:dsigCtxVerify", &dsigCtx_obj, &node_obj))
return NULL;
}
else return NULL;
dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj);
node = xmlNodePtr_get(node_obj);
return (wrap_int(xmlSecDSigCtxVerify(dsigCtx, node)));
}
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_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_DSigReferenceCtxProcessNode(PyObject *self, PyObject *args) {
PyObject *dsigRefCtx_obj, *node_obj;
xmlSecDSigReferenceCtxPtr dsigRefCtx;
xmlNodePtr node;
if (CheckArgs(args, "OO:dsigReferenceCtxProcessNode")) {
if(!PyArg_ParseTuple(args, (char *) "OO:dsigReferenceCtxProcessNode",
&dsigRefCtx_obj, &node_obj))
return NULL;
}
else return NULL;
dsigRefCtx = xmlSecDSigReferenceCtxPtr_get(dsigRefCtx_obj);
node = xmlNodePtr_get(node_obj);
return (wrap_int(xmlSecDSigReferenceCtxProcessNode(dsigRefCtx, node)));
}
PyObject *xmlsec_BufferBase64NodeContentRead(PyObject *self, PyObject *args) {
PyObject *buf_obj, *node_obj;
xmlSecBufferPtr buf;
xmlNodePtr node;
if (CheckArgs(args, "OO:bufferBase64NodeContentRead")) {
if (!PyArg_ParseTuple(args, "OO:bufferBase64NodeContentRead",
&buf_obj, &node_obj))
return NULL;
}
else return NULL;
buf = xmlSecBufferPtr_get(buf_obj);
node = xmlNodePtr_get(node_obj);
return (wrap_int(xmlSecBufferBase64NodeContentRead(buf, node)));
}
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_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));
}
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_EncCtxUriEncrypt(PyObject *self, PyObject *args) {
PyObject *encCtx_obj, *tmpl_obj;
xmlSecEncCtxPtr encCtx;
xmlNodePtr tmpl;
const xmlChar *uri;
if (CheckArgs(args, "OOS:encCtxUriEncrypt")) {
if (!PyArg_ParseTuple(args, "OOs:encCtxUriEncrypt", &encCtx_obj, &tmpl_obj,
&uri))
return NULL;
}
else return NULL;
encCtx = xmlSecEncCtxPtr_get(encCtx_obj);
tmpl = xmlNodePtr_get(tmpl_obj);
return (wrap_int(xmlSecEncCtxUriEncrypt(encCtx, tmpl, uri)));
}
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_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_X509DataGetNodeContent(PyObject *self, PyObject *args) {
PyObject *node_obj, *keyInfoCtx_obj;
xmlNodePtr node;
xmlSecKeyInfoCtxPtr keyInfoCtx;
int ret;
if (CheckArgs(args, "OIO:x509DataGetNodeContent")) {
if (!PyArg_ParseTuple(args, "OiO:x509DataGetNodeContent", &node_obj,
&keyInfoCtx_obj))
return NULL;
}
else return NULL;
node = xmlNodePtr_get(node_obj);
keyInfoCtx = xmlSecKeyInfoCtxPtr_get(keyInfoCtx_obj);
ret = xmlSecX509DataGetNodeContent(node, keyInfoCtx);
return wrap_int(ret);
}
PyObject *xmlsec_EncCtxDecryptToBuffer(PyObject *self, PyObject *args) {
PyObject *encCtx_obj, *node_obj;
xmlSecEncCtxPtr encCtx;
xmlNodePtr node;
xmlSecBufferPtr buf;
if (CheckArgs(args, "OO:encCtxDecryptToBuffer")) {
if (!PyArg_ParseTuple(args, "OO:encCtxDecryptToBuffer", &encCtx_obj, &node_obj))
return NULL;
}
else return NULL;
encCtx = xmlSecEncCtxPtr_get(encCtx_obj);
node = xmlNodePtr_get(node_obj);
buf = xmlSecEncCtxDecryptToBuffer(encCtx, node);
return (wrap_xmlSecBufferPtr(buf));
}
PyObject *xmlsec_KeyInfoNodeWrite(PyObject *self, PyObject *args) {
PyObject *keyInfoNode_obj, *key_obj, *keyInfoCtx_obj;
xmlNodePtr keyInfoNode;
xmlSecKeyPtr key;
xmlSecKeyInfoCtxPtr keyInfoCtx;
if (CheckArgs(args, "OOO:keyInfoNodeWrite")) {
if (!PyArg_ParseTuple(args, "OOO:keyInfoNodeWrite",
&keyInfoNode_obj, &key_obj, &keyInfoCtx_obj))
return NULL;
}
else return NULL;
keyInfoNode = xmlNodePtr_get(keyInfoNode_obj);
key = xmlSecKeyPtr_get(key_obj);
keyInfoCtx = xmlSecKeyInfoCtxPtr_get(keyInfoCtx_obj);
return (wrap_int(xmlSecKeyInfoNodeWrite(keyInfoNode, key, keyInfoCtx)));
}
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));
}
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_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_TmplTransformAddC14NInclNamespaces(PyObject *self, PyObject *args) {
PyObject *transformNode_obj;
xmlNodePtr transformNode;
const xmlChar *prefixList = NULL;
int ret;
if (CheckArgs(args, "Os:tmplTransformAddC14NInclNamespaces")) {
if (!PyArg_ParseTuple(args, "Oz:tmplTransformAddC14NInclNamespaces",
&transformNode_obj, &prefixList))
return NULL;
}
else return NULL;
transformNode = xmlNodePtr_get(transformNode_obj);
ret = xmlSecTmplTransformAddC14NInclNamespaces(transformNode, prefixList);
return (wrap_int(ret));
}
PyObject *xmlsec_TmplTransformAddXsltStylesheet(PyObject *self, PyObject *args) {
PyObject *transformNode_obj;
xmlNodePtr transformNode;
const xmlChar *xslt;
int ret;
if (CheckArgs(args, "OS:tmplTransformAddXsltStylesheet")) {
if (!PyArg_ParseTuple(args, "Os:tmplTransformAddXsltStylesheet",
&transformNode_obj, &xslt))
return NULL;
}
else return NULL;
transformNode = xmlNodePtr_get(transformNode_obj);
ret = xmlSecTmplTransformAddXsltStylesheet(transformNode, xslt);
return (wrap_int(ret));
}
PyObject *xmlsec_TmplTransformAddHmacOutputLength(PyObject *self, PyObject *args) {
PyObject *transformNode_obj;
xmlNodePtr transformNode;
xmlSecSize bitsLen;
int ret;
if (CheckArgs(args, "OI:tmplTransformAddHmacOutputLength")) {
if (!PyArg_ParseTuple(args, "Oi:tmplTransformAddHmacOutputLength",
&transformNode_obj, &bitsLen))
return NULL;
}
else return NULL;
transformNode = xmlNodePtr_get(transformNode_obj);
ret = xmlSecTmplTransformAddHmacOutputLength(transformNode, bitsLen);
return (wrap_int(ret));
}
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_EncCtxBinaryEncrypt(PyObject *self, PyObject *args) {
PyObject *encCtx_obj, *tmpl_obj;
xmlSecEncCtxPtr encCtx;
xmlNodePtr tmpl;
const xmlSecByte *data;
xmlSecSize dataSize;
if (CheckArgs(args, "OOSI:encCtxBinaryEncrypt")) {
if (!PyArg_ParseTuple(args, "OOsi:encCtxBinaryEncrypt",
&encCtx_obj, &tmpl_obj, &data, &dataSize))
return NULL;
}
else return NULL;
encCtx = xmlSecEncCtxPtr_get(encCtx_obj);
tmpl = xmlNodePtr_get(tmpl_obj);
return (wrap_int(xmlSecEncCtxBinaryEncrypt(encCtx, tmpl, data, dataSize)));
}
PyObject *xmlsec_NodeSetGetChildren(PyObject *self, PyObject *args) {
PyObject *doc_obj, *parent_obj;
xmlDocPtr doc;
xmlNodePtr parent = NULL;
int withComments, invert;
xmlSecNodeSetPtr cnset;
if (CheckArgs(args, "OoII:nodeSetGetChildren")) {
if (!PyArg_ParseTuple(args, "OOii:nodeSetGetChildren", &doc_obj,
&parent_obj, &withComments, &invert))
return NULL;
}
else return NULL;
doc = xmlDocPtr_get(doc_obj);
parent = xmlNodePtr_get(parent_obj);
cnset = xmlSecNodeSetGetChildren(doc, parent, withComments, invert);
return (wrap_xmlSecNodeSetPtr(cnset));
}
