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_BufferCreate(PyObject *self, PyObject *args) {
xmlSecSize size;
xmlSecBufferPtr buf;
if (CheckArgs(args, "I:bufferCreate")) {
if(!PyArg_ParseTuple(args, (char *) "i:bufferCreate", &size))
return NULL;
}
else return NULL;
buf = xmlSecBufferCreate(size);
return (wrap_xmlSecBufferPtr(buf));
}
PyObject *xmlsec_TransformMemBufGetBuffer(PyObject *self, PyObject *args) {
PyObject *transform_obj;
xmlSecTransformPtr transform;
xmlSecBufferPtr buf;
if (CheckArgs(args, "O:transformMemBufGetBuffer")) {
if (!PyArg_ParseTuple(args, "O:transformMemBufGetBuffer", &transform_obj))
return NULL;
}
else return NULL;
transform = xmlSecTransformPtr_get(transform_obj);
buf = xmlSecTransformMemBufGetBuffer(transform);
return (wrap_xmlSecBufferPtr(buf));
}
PyObject *xmlsec_DSigCtxGetPreSignBuffer(PyObject *self, PyObject *args) {
PyObject *dsigCtx_obj;
xmlSecDSigCtxPtr dsigCtx;
xmlSecBufferPtr buf;
if (CheckArgs(args, "O:dsigCtxGetPreSignBuffer")) {
if (!PyArg_ParseTuple(args, "O:dsigCtxGetPreSignBuffer", &dsigCtx_obj))
return NULL;
}
else return NULL;
dsigCtx = xmlSecDSigCtxPtr_get(dsigCtx_obj);
buf = xmlSecDSigCtxGetPreSignBuffer(dsigCtx);
return (wrap_xmlSecBufferPtr(buf));
}
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_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 *xmlSecDSigReferenceCtx_getattr(PyObject *self, PyObject *args) {
PyObject *dsigRefCtx_obj;
xmlSecDSigReferenceCtxPtr dsigRefCtx;
const char *attr;
if (CheckArgs(args, "OS:dsigReferenceCtxGetAttr")) {
if (!PyArg_ParseTuple(args, "Os:dsigReferenceCtxGetAttr",
&dsigRefCtx_obj, &attr))
return NULL;
}
else return NULL;
dsigRefCtx = xmlSecDSigReferenceCtxPtr_get(dsigRefCtx_obj);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[ssssssssss]", "dsigCtx",
"origin", "transformCtx", "digestMethod",
"result", "status", "preDigestMemBufMethod",
"id", "uri", "type");
if (!strcmp(attr, "dsigCtx"))
return (wrap_xmlSecDSigCtxPtr(dsigRefCtx->dsigCtx));
if (!strcmp(attr, "origin")) return (wrap_int(dsigRefCtx->origin));
if (!strcmp(attr, "transformCtx"))
return (wrap_xmlSecTransformCtxPtr(&(dsigRefCtx->transformCtx)));
if (!strcmp(attr, "digestMethod"))
return (wrap_xmlSecTransformPtr(dsigRefCtx->digestMethod));
if (!strcmp(attr, "result")) return (wrap_xmlSecBufferPtr(dsigRefCtx->result));
if (!strcmp(attr, "status")) return (wrap_int((dsigRefCtx->status)));
if (!strcmp(attr, "preDigestMemBufMethod"))
return (wrap_xmlSecTransformPtr((dsigRefCtx->preDigestMemBufMethod)));
if (!strcmp(attr, "id")) return (wrap_xmlCharPtr((dsigRefCtx->id)));
if (!strcmp(attr, "uri")) return (wrap_xmlCharPtr((dsigRefCtx->uri)));
if (!strcmp(attr, "type")) return (wrap_xmlCharPtr((dsigRefCtx->type)));
Py_INCREF(Py_None);
return (Py_None);
}
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);
}