PyObject *xmlSecPtrList_getattr(PyObject *self, PyObject *args) {
PyObject *list_obj;
xmlSecPtrListPtr list;
const char *attr;
if (CheckArgs(args, "OS:ptrListGetAttr")) {
if (!PyArg_ParseTuple(args, "Os:ptrListGetAttr", &list_obj, &attr))
return NULL;
}
else return NULL;
list = xmlSecPtrListPtr_get(list_obj);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[sssss]", "id", "data", "use", "max", "allocMode");
if (!strcmp(attr, "id"))
return wrap_xmlSecPtrListId(list->id);
if (!strcmp(attr, "data"))
return (wrap_xmlSecPtr(list->data));
if (!strcmp(attr, "use"))
return (wrap_int(list->use));
if (!strcmp(attr, "max"))
return (wrap_int(list->max));
if (!strcmp(attr, "allocMode"))
return (wrap_int(list->allocMode));
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlSecBuffer_getattr(PyObject *self, PyObject *args) {
PyObject *buf_obj;
xmlSecBufferPtr buf;
const char *attr;
if (CheckArgs(args, "OS:bufferGetAttr")) {
if (!PyArg_ParseTuple(args, "Os:bufferGetAttr", &buf_obj, &attr))
return NULL;
}
else return NULL;
buf = xmlSecBufferPtr_get(buf_obj);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[ssss]", "data", "size", "maxSize", "allocMode");
if (!strcmp(attr, "data"))
return (wrap_xmlSecBytePtr(buf->data));
if (!strcmp(attr, "size"))
return (wrap_int(buf->size));
if (!strcmp(attr, "maxSize"))
return (wrap_int(buf->maxSize));
if (!strcmp(attr, "allocMode"))
return (wrap_int(buf->allocMode));
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_NodeSetWalk(PyObject *self, PyObject *args) {
PyObject *nset_obj, *walkFunc_obj, *data_obj;
xmlSecNodeSetPtr nset;
int ret;
if (CheckArgs(args, "OC?:nodeSetWalk")) {
if (!PyArg_ParseTuple(args, "OOO:nodeSetWalk", &nset_obj, &walkFunc_obj,
&data_obj))
return NULL;
}
else return NULL;
nset = xmlSecNodeSetPtr_get(nset_obj);
if (NodeSetWalkCallbacks == NULL && walkFunc_obj != Py_None)
NodeSetWalkCallbacks = xmlHashCreate(HASH_TABLE_SIZE);
if (walkFunc_obj != Py_None)
xmlHashAddEntry2(NodeSetWalkCallbacks, (const xmlChar *)nset->doc->name,
nset->doc->URL, walkFunc_obj);
Py_XINCREF(walkFunc_obj);
ret = xmlSecNodeSetWalk(nset, xmlsec_NodeSetWalkCallback,
PyCObject_AsVoidPtr(data_obj));
return (wrap_int(ret));
}
PyObject *xmlsec_KeyDataBinWrite(PyObject *self, PyObject *args) {
PyObject *id_obj, *key_obj, *keyInfoCtx_obj;
xmlSecKeyDataId id;
xmlSecKeyPtr key;
// FIXME
//xmlSecByte **buf;
//xmlSecSize *bufSize;
xmlSecByte *buf;
xmlSecSize bufSize;
xmlSecKeyInfoCtxPtr keyInfoCtx;
if (CheckArgs(args, "OOSIO:keyDataBinWrite")) {
if (!PyArg_ParseTuple(args, "OOsiO:keyDataBinWrite",
&id_obj, &key_obj, &buf, &bufSize, &keyInfoCtx_obj))
return NULL;
}
else return NULL;
id = xmlSecKeyDataId_get(id_obj);
key = xmlSecKeyPtr_get(key_obj);
keyInfoCtx = xmlSecKeyInfoCtxPtr_get(keyInfoCtx_obj);
//return (wrap_int(xmlSecKeyDataBinWrite(id, key, buf, bufSize, keyInfoCtx)));
return (wrap_int(xmlSecKeyDataBinWrite(id, key, &buf, &bufSize, keyInfoCtx)));
}
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 *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_KeyDataIdsRegister(PyObject *self, PyObject *args) {
PyObject *id_obj;
xmlSecKeyDataId id;
if (CheckArgs(args, "O:keyDataIdsRegister")) {
if (!PyArg_ParseTuple(args, "O:keyDataIdsRegister", &id_obj))
return NULL;
}
else return NULL;
id = xmlSecKeyDataId_get(id_obj);
return (wrap_int(xmlSecKeyDataIdsRegister(id)));
}
PyObject *xmlsec_KeyDataIsValid(PyObject *self, PyObject *args) {
PyObject *data_obj;
xmlSecKeyDataPtr data;
if (CheckArgs(args, "O:keyDataIsValid")) {
if (!PyArg_ParseTuple(args, "O:keyDataIsValid", &data_obj))
return NULL;
}
else return NULL;
data = xmlSecKeyDataPtr_get(data_obj);
return (wrap_int(xmlSecKeyDataIsValid(data)));
}
PyObject *xmlsec_PtrListIsValid(PyObject *self, PyObject *args) {
PyObject *list_obj;
xmlSecPtrListPtr list;
if (CheckArgs(args, "O:ptrListIsValid")) {
if (!PyArg_ParseTuple(args, "O:ptrListIsValid", &list_obj))
return NULL;
}
else return NULL;
list = xmlSecPtrListPtr_get(list_obj);
return (wrap_int(xmlSecPtrListIsValid(list)));
}
PyObject *xmlsec_KeyInfoCtxCreateEncCtx(PyObject *self, PyObject *args) {
PyObject *keyInfoCtx_obj;
xmlSecKeyInfoCtxPtr keyInfoCtx;
if (CheckArgs(args, "O:keyInfoCtxCreateEncCtx")) {
if (!PyArg_ParseTuple(args, "O:keyInfoCtxCreateEncCtx", &keyInfoCtx_obj))
return NULL;
}
else return NULL;
keyInfoCtx = xmlSecKeyInfoCtxPtr_get(keyInfoCtx_obj);
return (wrap_int(xmlSecKeyInfoCtxCreateEncCtx(keyInfoCtx)));
}
PyObject *xmlsec_TransformUriTypeCheck(PyObject *self, PyObject *args) {
xmlSecTransformUriType type;
const xmlChar *uri;
int ret;
if (CheckArgs(args, "IS:transformUriTypeCheck")) {
if(!PyArg_ParseTuple(args, (char *) "is:transformUriTypeCheck", &type, &uri))
return NULL;
}
else return NULL;
ret = xmlSecTransformUriTypeCheck(type, uri);
return (wrap_int(ret));
}
PyObject *xmlSecNodeSet_getattr(PyObject *self, PyObject *args) {
PyObject *nset_obj;
xmlSecNodeSetPtr nset;
const char *attr;
if (CheckArgs(args, "OS:nodeSetGetAttr")) {
if (!PyArg_ParseTuple(args, "Os:nodeSetGetAttr",
&nset_obj, &attr))
return NULL;
}
else return NULL;
nset = xmlSecNodeSetPtr_get(nset_obj);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[ssssssss]", "nodes", "doc", "destroyDoc", "type",
"op", "next", "prev", "children");
if (!strcmp(attr, "nodes"))
return (wrap_xmlNodeSetPtr(nset->nodes));
if (!strcmp(attr, "doc"))
return (wrap_xmlDocPtr(nset->doc));
if (!strcmp(attr, "destroyDoc"))
return (wrap_int(nset->destroyDoc));
if (!strcmp(attr, "type"))
return (wrap_int(nset->type));
if (!strcmp(attr, "op"))
return (wrap_int(nset->op));
if (!strcmp(attr, "next"))
return (wrap_xmlSecNodeSetPtr(nset->next));
if (!strcmp(attr, "prev"))
return (wrap_xmlSecNodeSetPtr(nset->prev));
if (!strcmp(attr, "children"))
return (wrap_xmlSecNodeSetPtr(nset->children));
Py_INCREF(Py_None);
return (Py_None);
}
PyObject *xmlsec_EncCtxCopyUserPref(PyObject *self, PyObject *args) {
PyObject *dst_obj, *src_obj;
xmlSecEncCtxPtr dst, src;
if (CheckArgs(args, "OO:encCtxCopyUserPref")) {
if (!PyArg_ParseTuple(args, "OO:encCtxCopyUserPref", &dst_obj, &src_obj))
return NULL;
}
else return NULL;
dst = xmlSecEncCtxPtr_get(dst_obj);
src = xmlSecEncCtxPtr_get(src_obj);
return (wrap_int(xmlSecEncCtxCopyUserPref(dst, src)));
}
PyObject *xmlsec_BufferReadFile(PyObject *self, PyObject *args) {
PyObject *buf_obj;
xmlSecBufferPtr buf;
const char *filename;
if (CheckArgs(args, "OS:bufferReadFile")) {
if (!PyArg_ParseTuple(args, "Os:bufferReadFile", &buf_obj, &filename))
return NULL;
}
else return NULL;
buf = xmlSecBufferPtr_get(buf_obj);
return (wrap_int(xmlSecBufferReadFile(buf, filename)));
}
PyObject *xmlsec_BufferRemoveTail(PyObject *self, PyObject *args) {
PyObject *buf_obj;
xmlSecBufferPtr buf;
xmlSecSize size;
if (CheckArgs(args, "OI:bufferRemoveTail")) {
if (!PyArg_ParseTuple(args, "Oi:bufferRemoveTail", &buf_obj, &size))
return NULL;
}
else return NULL;
buf = xmlSecBufferPtr_get(buf_obj);
return (wrap_int(xmlSecBufferRemoveTail(buf, size)));
}
PyObject *xmlsec_KeyDataCheckSize(PyObject *self, PyObject *args) {
PyObject *data_obj;
xmlSecKeyDataPtr data;
xmlSecSize size;
if (CheckArgs(args, "OI:keyDataCheckSize")) {
if (!PyArg_ParseTuple(args, "Oi:keyDataCheckSize", &data_obj, &size))
return NULL;
}
else return NULL;
data = xmlSecKeyDataPtr_get(data_obj);
return (wrap_int(xmlSecKeyDataCheckSize(data, size)));
}
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 *xmlsec_CheckVersionExt(PyObject *self, PyObject *args) {
int major;
int minor;
int subminor;
xmlSecCheckVersionMode mode;
if (CheckArgs(args, "IIII:checkVersionExt")) {
if(!PyArg_ParseTuple(args, (char *) "iiii:checkVersionExt",
&major, &minor, &subminor, &mode))
return NULL;
}
else return NULL;
return (wrap_int(xmlSecCheckVersionExt(major, minor, subminor, mode)));
}
PyObject *xmlsec_BufferGetMaxSize(PyObject *self, PyObject *args) {
PyObject *buf_obj;
xmlSecBufferPtr buf;
xmlSecSize size;
if (CheckArgs(args, "O:bufferGetMaxSize")) {
if (!PyArg_ParseTuple(args, "O:bufferGetMaxSize", &buf_obj))
return NULL;
}
else return NULL;
buf = xmlSecBufferPtr_get(buf_obj);
size = xmlSecBufferGetMaxSize(buf);
return (wrap_int(size));
}
PyObject *xmlsec_KeyDataCheckId(PyObject *self, PyObject *args) {
PyObject *data_obj, *dataId_obj;
xmlSecKeyDataPtr data;
xmlSecKeyDataId dataId;
if (CheckArgs(args, "OO:keyDataCheckId")) {
if (!PyArg_ParseTuple(args, "OO:keyDataCheckId", &data_obj, &dataId_obj))
return NULL;
}
else return NULL;
data = xmlSecKeyDataPtr_get(data_obj);
dataId = xmlSecKeyDataId_get(dataId_obj);
return (wrap_int(xmlSecKeyDataCheckId(data, dataId)));
}
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_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_PtrListAdd(PyObject *self, PyObject *args) {
PyObject *list_obj, *item_obj;
xmlSecPtrListPtr list;
int ret;
if (CheckArgs(args, "OO:ptrListAdd")) {
if (!PyArg_ParseTuple(args, "OO:ptrListAdd", &list_obj, &item_obj))
return NULL;
}
else return NULL;
list = xmlSecPtrListPtr_get(list_obj);
ret = xmlSecPtrListAdd(list, xmlSecPtr_get(item_obj));
return (wrap_int(ret));
}
PyObject *xmlsec_BufferPrepend(PyObject *self, PyObject *args) {
PyObject *buf_obj;
xmlSecBufferPtr buf;
const xmlSecByte *data;
xmlSecSize size;
if (CheckArgs(args, "OSI:bufferPrepend")) {
if (!PyArg_ParseTuple(args, "Osi:bufferPrepend", &buf_obj, &data, &size))
return NULL;
}
else return NULL;
buf = xmlSecBufferPtr_get(buf_obj);
return (wrap_int(xmlSecBufferPrepend(buf, data, size)));
}
PyObject *xmlsec_PtrListCopy(PyObject *self, PyObject *args) {
PyObject *dst_obj, *src_obj;
xmlSecPtrListPtr dst;
xmlSecPtrListPtr src;
if (CheckArgs(args, "OO:ptrListCopy")) {
if (!PyArg_ParseTuple(args, "OO:ptrListCopy", &dst_obj, &src_obj))
return NULL;
}
else return NULL;
dst = xmlSecPtrListPtr_get(dst_obj);
src = xmlSecPtrListPtr_get(src_obj);
return (wrap_int(xmlSecPtrListCopy(dst, src)));
}
PyObject *xmlsec_EncCtxDecrypt(PyObject *self, PyObject *args) {
PyObject *encCtx_obj, *node_obj;
xmlSecEncCtxPtr encCtx;
xmlNodePtr node;
if (CheckArgs(args, "OO:encCtxDecrypt")) {
if (!PyArg_ParseTuple(args, "OO:encCtxDecrypt", &encCtx_obj, &node_obj))
return NULL;
}
else return NULL;
encCtx = xmlSecEncCtxPtr_get(encCtx_obj);
node = xmlNodePtr_get(node_obj);
return (wrap_int(xmlSecEncCtxDecrypt(encCtx, node)));
}
PyObject *xmlsec_Base64CtxInitialize(PyObject *self, PyObject *args) {
PyObject *ctx_obj;
int encode;
int columns;
xmlSecBase64CtxPtr ctx;
if (CheckArgs(args, "OII:base64CtxInitialize")) {
if (!PyArg_ParseTuple(args, "Oii:base64CtxInitialize",
&ctx_obj, &encode, &columns))
return NULL;
}
else return NULL;
ctx = xmlSecBase64CtxPtr_get(ctx_obj);
return (wrap_int(xmlSecBase64CtxInitialize(ctx, encode, columns)));
}
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_KeysMngrAdoptDataStore(PyObject *self, PyObject *args) {
PyObject *mngr_obj, *store_obj;
xmlSecKeysMngrPtr mngr;
xmlSecKeyDataStorePtr store;
if (CheckArgs(args, "OO:keysMngrAdoptDataStore")) {
if (!PyArg_ParseTuple(args, "OO:keysMngrAdoptDataStore", &mngr_obj,
&store_obj))
return NULL;
}
else return NULL;
mngr = xmlSecKeysMngrPtr_get(mngr_obj);
store = xmlSecKeyDataStorePtr_get(store_obj);
return (wrap_int(xmlSecKeysMngrAdoptDataStore(mngr, store)));
}
