PyObject *xmlSecKeysMngr_getattr(PyObject *self, PyObject *args) {
PyObject *mngr_obj;
xmlSecKeysMngrPtr mngr;
const char *attr;
if (CheckArgs(args, "OS:keysMngrGetAttr")) {
if (!PyArg_ParseTuple(args, "Os:keysMngrGetAttr", &mngr_obj, &attr))
return NULL;
}
else return NULL;
mngr = xmlSecKeysMngrPtr_get(mngr_obj);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[sss]", "keysStore", "storesList", "getKey");
if (!strcmp(attr, "keysStore"))
return (wrap_xmlSecKeyStorePtr(mngr->keysStore));
if (!strcmp(attr, "storesList"))
return (wrap_xmlSecPtrListPtr(&(mngr->storesList)));
if (!strcmp(attr, "getKey"))
return PyCObject_FromVoidPtr((void *) mngr->getKey, NULL);
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlSecKeyInfoCtx_getattr(PyObject *self, PyObject *args) {
PyObject *keyInfoCtx_obj;
xmlSecKeyInfoCtxPtr keyInfoCtx;
const char *attr;
if (CheckArgs(args, "OS:keyInfoCtxGetAttr")) {
if (!PyArg_ParseTuple(args, "Os:keyInfoCtxGetAttr", &keyInfoCtx_obj,
&attr))
return NULL;
}
else return NULL;
keyInfoCtx = xmlSecKeyInfoCtxPtr_get(keyInfoCtx_obj);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[ssssssssssssss]", "flags",
"flags2", "keysMngr", "mode", "enabledKeyData",
"base64LineSize", "retrievalMethodCtx",
"maxRetrievalMethodLevel", "encCtx",
"maxEncryptedKeyLevel", "certsVerificationTime",
"certsVerificationDepth", "curRetrievalMethodLevel",
"keyReq");
if (!strcmp(attr, "flags"))
return (wrap_int(keyInfoCtx->flags));
if (!strcmp(attr, "flags2"))
return (wrap_int(keyInfoCtx->flags2));
if (!strcmp(attr, "keysMngr"))
return (wrap_xmlSecKeysMngrPtr(keyInfoCtx->keysMngr));
if (!strcmp(attr, "mode"))
return (wrap_int(keyInfoCtx->mode));
if (!strcmp(attr, "enabledKeyData"))
return (wrap_xmlSecPtrListPtr(&(keyInfoCtx->enabledKeyData)));
if (!strcmp(attr, "base64LineSize"))
return (wrap_int(keyInfoCtx->base64LineSize));
if (!strcmp(attr, "retrievalMethodCtx"))
return (wrap_xmlSecTransformCtxPtr(&(keyInfoCtx->retrievalMethodCtx)));
if (!strcmp(attr, "maxRetrievalMethodLevel"))
return (wrap_int(keyInfoCtx->maxRetrievalMethodLevel));
if (!strcmp(attr, "encCtx"))
return (wrap_xmlSecEncCtxPtr(keyInfoCtx->encCtx));
if (!strcmp(attr, "maxEncryptedKeyLevel"))
return (wrap_int(keyInfoCtx->maxEncryptedKeyLevel));
if (!strcmp(attr, "certsVerificationTime"))
return (wrap_int(keyInfoCtx->certsVerificationTime));
if (!strcmp(attr, "certsVerificationDepth"))
return (wrap_int(keyInfoCtx->certsVerificationDepth));
if (!strcmp(attr, "curRetrievalMethodLevel"))
return (wrap_int(keyInfoCtx->curRetrievalMethodLevel));
if (!strcmp(attr, "curEncryptedKeyLevel"))
return (wrap_int(keyInfoCtx->curEncryptedKeyLevel));
if (!strcmp(attr, "keyReq"))
return wrap_xmlSecKeyReqPtr(&(keyInfoCtx->keyReq));
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_PtrListDuplicate(PyObject *self, PyObject *args) {
PyObject *list_obj;
xmlSecPtrListPtr list;
if (CheckArgs(args, "O:ptrListDuplicate")) {
if (!PyArg_ParseTuple(args, "O:ptrListDuplicate", &list_obj))
return NULL;
}
else return NULL;
list = xmlSecPtrListPtr_get(list_obj);
return (wrap_xmlSecPtrListPtr(xmlSecPtrListDuplicate(list)));
}
PyObject *xmlsec_PtrListCreate(PyObject *self, PyObject *args) {
PyObject *id_obj;
xmlSecPtrListPtr list;
xmlSecPtrListId id = NULL;
if (CheckArgs(args, "O:ptrListCreate")) {
if(!PyArg_ParseTuple(args, (char *) "O:ptrListCreate", &id_obj))
return NULL;
}
else return NULL;
id = xmlSecPtrListId_get(id_obj);
list = xmlSecPtrListCreate(id);
return (wrap_xmlSecPtrListPtr(list));
}
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 *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 *xmlsec_KeyDataIdsGet(PyObject *self, PyObject *args) {
return (wrap_xmlSecPtrListPtr(xmlSecKeyDataIdsGet()));
}