PyObject *xmlsec_EncCtxReset(PyObject *self, PyObject *args) {
PyObject *encCtx_obj;
xmlSecEncCtxPtr encCtx;
if (CheckArgs(args, "O:encCtxReset")) {
if (!PyArg_ParseTuple(args, "O:encCtxReset", &encCtx_obj))
return NULL;
}
else return NULL;
encCtx = xmlSecEncCtxPtr_get(encCtx_obj);
xmlSecEncCtxReset(encCtx);
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_EncCtxInitialize(PyObject *self, PyObject *args) {
PyObject *encCtx_obj, *keysMngr_obj;
xmlSecEncCtxPtr encCtx;
xmlSecKeysMngrPtr keysMngr = NULL;
if (CheckArgs(args, "Oo:encCtxInitialize")) {
if (!PyArg_ParseTuple(args, "OO:encCtxInitialize",
&encCtx_obj, &keysMngr_obj))
return NULL;
}
else return NULL;
encCtx = xmlSecEncCtxPtr_get(encCtx_obj);
keysMngr = xmlSecKeysMngrPtr_get(keysMngr_obj);
return (wrap_int(xmlSecEncCtxInitialize(encCtx, keysMngr)));
}
PyObject *xmlsec_KeyInfoCtxCreate(PyObject *self, PyObject *args) {
PyObject *mngr_obj;
xmlSecKeysMngrPtr mngr = NULL;
xmlSecKeyInfoCtxPtr keyInfoCtx;
if (CheckArgs(args, "o:keyInfoCtxCreate")) {
if (!PyArg_ParseTuple(args, "O:keyInfoCtxCreate", &mngr_obj))
return NULL;
}
else return NULL;
mngr = xmlSecKeysMngrPtr_get(mngr_obj);
/* mngr may be NULL */
keyInfoCtx = xmlSecKeyInfoCtxCreate(mngr);
return (wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx));
}
PyObject *xmlsec_KeyDataGenerate(PyObject *self, PyObject *args) {
PyObject *data_obj;
xmlSecKeyDataPtr data;
xmlSecSize sizeBits;
xmlSecKeyDataType type;
if (CheckArgs(args, "OII:keyDataGenerate")) {
if (!PyArg_ParseTuple(args, "Oii:keyDataGenerate",
&data_obj, &sizeBits, &type))
return NULL;
}
else return NULL;
data = xmlSecKeyDataPtr_get(data_obj);
return (wrap_int(xmlSecKeyDataGenerate(data, sizeBits, type)));
}
PyObject *xmlsec_DSigReferenceCtxGetPreDigestBuffer(PyObject *self, PyObject *args) {
PyObject *dsigRefCtx_obj;
xmlSecDSigReferenceCtxPtr dsigRefCtx;
xmlSecBufferPtr buf;
if (CheckArgs(args, "O:dsigReferenceCtxGetPreDigestBuffer")) {
if(!PyArg_ParseTuple(args, (char *) "O:dsigReferenceCtxGetPreDigestBuffer",
&dsigRefCtx_obj))
return NULL;
}
else return NULL;
dsigRefCtx = xmlSecDSigReferenceCtxPtr_get(dsigRefCtx_obj);
buf = xmlSecDSigReferenceCtxGetPreDigestBuffer(dsigRefCtx);
return (wrap_xmlSecBufferPtr(buf));
}
PyObject *xmlsec_PtrListInitialize(PyObject *self, PyObject *args) {
PyObject *list_obj, *id_obj;
xmlSecPtrListPtr list;
xmlSecPtrListId id;
if (CheckArgs(args, "OO:ptrListInitialize")) {
if(!PyArg_ParseTuple(args, (char *) "OO:ptrListInitialize",
&list_obj, &id_obj))
return NULL;
}
else return NULL;
list = xmlSecPtrListPtr_get(list_obj);
id = xmlSecPtrListId_get(id_obj);
return (wrap_int(xmlSecPtrListInitialize(list, id)));
}
int RunTest2(void* pTestProject, int nParams, const char* params[])
{
if (pTestProject == NULL)
{
ASSERT(false);
return 2;
}
bool fOk = CheckArgs(nParams, params);
if (!fOk)
return 1;
Runner runner;
runner.SetProject((ITestProject*)pTestProject);
return DoRun(runner);
}
PyObject *xmlsec_PtrListRemove(PyObject *self, PyObject *args) {
PyObject *list_obj;
xmlSecPtrListPtr list;
xmlSecSize pos;
int ret;
if (CheckArgs(args, "OI:ptrListRemove")) {
if (!PyArg_ParseTuple(args, "Oi:ptrListRemove", &list_obj, &pos))
return NULL;
}
else return NULL;
list = xmlSecPtrListPtr_get(list_obj);
ret = xmlSecPtrListRemove(list, pos);
return (wrap_int(ret));
}
PyObject *xmlsec_DSigCtxFinalize(PyObject *self, PyObject *args) {
PyObject *dsigCtx_obj;
xmlSecDSigCtxPtr dsigCtx;
if (CheckArgs(args, "O:dsigCtxFinalize")) {
if (!PyArg_ParseTuple(args, "O:dsigCtxFinalize", &dsigCtx_obj))
return NULL;
}
else return NULL;
dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj);
xmlSecDSigCtxFinalize(dsigCtx);
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_DSigCtxInitialize(PyObject *self, PyObject *args) {
PyObject *dsigCtx_obj, *mngr_obj;
xmlSecDSigCtxPtr dsigCtx;
xmlSecKeysMngrPtr mngr = NULL;
if (CheckArgs(args, "Oo:dsigCtxInitialize")) {
if (!PyArg_ParseTuple(args, "OO:dsigCtxInitialize", &dsigCtx_obj,
&mngr_obj))
return NULL;
}
else return NULL;
dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj);
mngr = xmlSecKeysMngrPtr_get(mngr_obj);
return (wrap_int(xmlSecDSigCtxInitialize(dsigCtx, mngr)));
}
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_KeyInfoCtxCopyUserPref(PyObject *self, PyObject *args) {
PyObject *dst_obj, *src_obj;
xmlSecKeyInfoCtxPtr dst;
xmlSecKeyInfoCtxPtr src;
if (CheckArgs(args, "OO:keyInfoCtxCopyUserPref")) {
if (!PyArg_ParseTuple(args, "OO:keyInfoCtxCopyUserPref",
&dst_obj, &src_obj))
return NULL;
}
else return NULL;
dst = xmlSecKeyInfoCtxPtr_get(dst_obj);
src = xmlSecKeyInfoCtxPtr_get(src_obj);
return (wrap_int(xmlSecKeyInfoCtxCopyUserPref(dst, src)));
}
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_DSigReferenceCtxDestroy(PyObject *self, PyObject *args) {
PyObject *dsigRefCtx_obj;
xmlSecDSigReferenceCtxPtr dsigRefCtx;
if (CheckArgs(args, "O:dsigReferenceCtxDestroy")) {
if(!PyArg_ParseTuple(args, (char *) "O:dsigReferenceCtxDestroy",
&dsigRefCtx_obj))
return NULL;
}
else return NULL;
dsigRefCtx = xmlSecDSigReferenceCtxPtr_get(dsigRefCtx_obj);
xmlSecDSigReferenceCtxDestroy(dsigRefCtx);
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlSecTransformCtx_getattr(PyObject *self, PyObject *args) {
PyObject *transformCtx_obj;
xmlSecTransformCtxPtr transformCtx;
const char *attr;
if (CheckArgs(args, "OS:transformCtxGetAttr")) {
if (!PyArg_ParseTuple(args, "Os:transformCtxGetAttr",
&transformCtx_obj, &attr))
return NULL;
}
else return NULL;
transformCtx = xmlSecTransformCtxPtr_get(transformCtx_obj);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[sssssssssss]", "flags",
"flags2", "enabledUris", "enabledTransforms",
"preExecCallback", "result", "status", "uri",
"xptrExpr", "first", "last");
if (!strcmp(attr, "flags"))
return (wrap_int(transformCtx->flags));
if (!strcmp(attr, "flags2"))
return (wrap_int(transformCtx->flags2));
if (!strcmp(attr, "enabledUris"))
return (wrap_int(transformCtx->enabledUris));
if (!strcmp(attr, "enabledTransforms"))
return (wrap_xmlSecPtrListPtr(&(transformCtx->enabledTransforms)));
if (!strcmp(attr, "preExecCallback"))
return PyCObject_FromVoidPtr((void *) transformCtx->preExecCallback, NULL);
if (!strcmp(attr, "result"))
return (wrap_xmlSecBufferPtr(transformCtx->result));
if (!strcmp(attr, "status"))
return (wrap_int(transformCtx->status));
if (!strcmp(attr, "uri"))
return (wrap_xmlCharPtr(transformCtx->uri));
if (!strcmp(attr, "xptrExpr"))
return (wrap_xmlCharPtr(transformCtx->xptrExpr));
if (!strcmp(attr, "first"))
return (wrap_xmlSecTransformPtr(transformCtx->first));
if (!strcmp(attr, "last"))
return (wrap_xmlSecTransformPtr(transformCtx->last));
Py_INCREF(Py_None);
return (Py_None);
}
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_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_NodeSetDebugDump(PyObject *self, PyObject *args) {
PyObject *nset_obj, *output_obj;
xmlSecNodeSetPtr nset;
FILE *output;
if (CheckArgs(args, "OO:nodeSetDebugDump")) {
if (!PyArg_ParseTuple(args, "OO:nodeSetDebugDump", &nset_obj, &output_obj))
return NULL;
}
else return NULL;
nset = xmlSecNodeSetPtr_get(nset_obj);
output = PythonFile_get(output_obj);
xmlSecNodeSetDebugDump(nset, output);
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_NodeSetAddList(PyObject *self, PyObject *args) {
PyObject *nset_obj, *newNSet_obj;
xmlSecNodeSetPtr nset;
xmlSecNodeSetPtr newNSet;
xmlSecNodeSetOp op;
if (CheckArgs(args, "OOI:nodeSetAddList")) {
if (!PyArg_ParseTuple(args, "OOi:nodeSetAddList", &nset_obj, &newNSet_obj,
&op))
return NULL;
}
else return NULL;
nset = xmlSecNodeSetPtr_get(nset_obj);
newNSet = xmlSecNodeSetPtr_get(newNSet_obj);
return (wrap_xmlSecNodeSetPtr(xmlSecNodeSetAddList(nset, newNSet, op)));
}
PyObject *xmlsec_DSigReferenceCtxCreate(PyObject *self, PyObject *args) {
PyObject *dsigCtx_obj;
xmlSecDSigReferenceOrigin origin;
xmlSecDSigCtxPtr dsigCtx;
xmlSecDSigReferenceCtxPtr dsigRefCtx;
if (CheckArgs(args, "OI:dsigReferenceCtxCreate")) {
if(!PyArg_ParseTuple(args, (char *) "Oi:dsigReferenceCtxCreate",
&dsigCtx_obj, &origin))
return NULL;
}
else return NULL;
dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj);
dsigRefCtx = xmlSecDSigReferenceCtxCreate(dsigCtx, origin);
return (wrap_xmlSecDSigReferenceCtxPtr(dsigRefCtx));
}
PyObject *xmlsec_ErrorsSetCallback(PyObject *self, PyObject *args) {
PyObject *callback_obj;
if (CheckArgs(args, "C:errorsSetCallback")) {
if (!PyArg_ParseTuple(args, "O:errorsSetCallback", &callback_obj))
return NULL;
}
else return NULL;
Py_XINCREF(callback_obj);
Py_XDECREF(ErrorsCallback);
ErrorsCallback = callback_obj;
xmlSecErrorsSetCallback(xmlsec_ErrorsCallback);
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_TransformVisa3DHackSetID(PyObject *self, PyObject *args) {
PyObject *transform_obj;
xmlSecTransformPtr transform;
const xmlChar *id;
int ret;
if (CheckArgs(args, "OS:transformVisa3DHackSetID")) {
if(!PyArg_ParseTuple(args, (char *) "Os:transformVisa3DHackSetID",
&transform_obj, &id))
return NULL;
}
else return NULL;
transform = xmlSecTransformPtr_get(transform_obj);
ret = xmlSecTransformVisa3DHackSetID(transform, id);
return (wrap_int(ret));
}
PyObject *xmlsec_TransformBase64SetLineSize(PyObject *self, PyObject *args) {
PyObject *transform_obj;
xmlSecTransformPtr transform;
xmlSecSize lineSize;
if (CheckArgs(args, "OI:transformBase64SetLineSize")) {
if(!PyArg_ParseTuple(args, (char *) "Oi:transformBase64SetLineSize",
&transform_obj, &lineSize))
return NULL;
}
else return NULL;
transform = xmlSecTransformPtr_get(transform_obj);
xmlSecTransformBase64SetLineSize(transform, lineSize);
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_NodeSetCreate(PyObject *self, PyObject *args) {
PyObject *doc_obj, *nodes_obj;
xmlDocPtr doc;
xmlNodeSetPtr nodes;
xmlSecNodeSetType type;
if (CheckArgs(args, "OOI:nodeSetCreate")) {
if (!PyArg_ParseTuple(args, "OOi:nodeSetCreate", &doc_obj, &nodes_obj,
&type))
return NULL;
}
else return NULL;
doc = xmlDocPtr_get(doc_obj);
nodes = xmlNodeSetPtr_get(nodes_obj);
return (wrap_xmlSecNodeSetPtr(xmlSecNodeSetCreate(doc, nodes, type)));
}
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_NodeSetDumpTextNodes(PyObject *self, PyObject *args) {
PyObject *nset_obj, *out_obj;
xmlSecNodeSetPtr nset;
xmlOutputBufferPtr out;
int ret;
if (CheckArgs(args, "OO:nodeSetDumpTextNodes")) {
if (!PyArg_ParseTuple(args, "OO:nodeSetDumpTextNodes", &nset_obj, &out_obj))
return NULL;
}
else return NULL;
nset = xmlSecNodeSetPtr_get(nset_obj);
out = xmlOutputBufferPtr_get(out_obj);
ret = xmlSecNodeSetDumpTextNodes(nset, out);
return (wrap_int(ret));
}
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_BufferBase64NodeContentWrite(PyObject *self, PyObject *args) {
PyObject *buf_obj, *node_obj;
xmlSecBufferPtr buf;
xmlNodePtr node;
int columns;
if (CheckArgs(args, "OO:bufferBase64NodeContentWrite")) {
if (!PyArg_ParseTuple(args, "OO:bufferBase64NodeContentWrite", &buf_obj,
&node_obj, &columns))
return NULL;
}
else return NULL;
buf = xmlSecBufferPtr_get(buf_obj);
node = xmlNodePtr_get(node_obj);
return (wrap_int(xmlSecBufferBase64NodeContentWrite(buf, node, columns)));
}
PyObject *xmlsec_KeyInfoCtxInitialize(PyObject *self, PyObject *args) {
PyObject *keyInfoCtx_obj, *mngr_obj;
xmlSecKeyInfoCtxPtr keyInfoCtx;
xmlSecKeysMngrPtr mngr = NULL;
if (CheckArgs(args, "Oo:keyInfoCtxInitialize")) {
if (!PyArg_ParseTuple(args, "OO:keyInfoCtxInitialize", &keyInfoCtx_obj,
&mngr_obj))
return NULL;
}
else return NULL;
keyInfoCtx = xmlSecKeyInfoCtxPtr_get(keyInfoCtx_obj);
/* mngr may be NULL */
mngr = xmlSecKeysMngrPtr_get(mngr_obj);
return (wrap_int(xmlSecKeyInfoCtxInitialize(keyInfoCtx, mngr)));
}
