helpers.c
No OneTemporary
Actions

Size

31 KB

Subscribers

None

helpers.c
View Options

	/*
	# Copyright (C) 2016 g10 Code GmbH
	# Copyright (C) 2004 Igor Belyi <belyi@users.sourceforge.net>
	# Copyright (C) 2002 John Goerzen <jgoerzen@complete.org>
	#
	# This library is free software; you can redistribute it and/or
	# modify it under the terms of the GNU Lesser General Public
	# License as published by the Free Software Foundation; either
	# version 2.1 of the License, or (at your option) any later version.
	#
	# This library is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	# Lesser General Public License for more details.
	#
	# You should have received a copy of the GNU Lesser General Public
	# License along with this library; if not, write to the Free Software
	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include <assert.h>
	#include <stdio.h>
	#include <gpgme.h>
	#include <stdlib.h>
	#include <string.h>
	#include "Python.h"

	#include "helpers.h"
	#include "private.h"

	/* Flag specifying whether this is an in-tree build. */
	int gpg_in_tree_build =
	#if IN_TREE_BUILD
	1
	#else
	0
	#endif
	;

	static PyObject *GPGMEError = NULL;

	void _gpg_exception_init(void) {
	if (GPGMEError == NULL) {
	PyObject *errors;
	PyObject *from_list = PyList_New(0);
	errors = PyImport_ImportModuleLevel("errors", PyEval_GetGlobals(),
	PyEval_GetLocals(), from_list, 1);
	Py_XDECREF(from_list);
	if (errors) {
	GPGMEError=PyDict_GetItemString(PyModule_GetDict(errors), "GPGMEError");
	Py_XINCREF(GPGMEError);
	}
	}
	}

	static PyObject *
	_gpg_raise_exception(gpgme_error_t err)
	{
	PyObject *e;

	_gpg_exception_init();
	if (GPGMEError == NULL)
	return PyErr_Format(PyExc_RuntimeError, "Got gpgme_error_t %d", err);

	e = PyObject_CallFunction(GPGMEError, "l", (long) err);
	if (e == NULL)
	return NULL;

	PyErr_SetObject(GPGMEError, e);
	Py_DECREF(e);

	return NULL; /* raise */
	}

	gpgme_error_t _gpg_exception2code(void) {
	gpgme_error_t err_status = gpg_error(GPG_ERR_GENERAL);
	if (GPGMEError && PyErr_ExceptionMatches(GPGMEError)) {
	PyObject type = 0, value = 0, *traceback = 0;
	PyObject *error = 0;
	PyErr_Fetch(&type, &value, &traceback);
	PyErr_NormalizeException(&type, &value, &traceback);
	error = PyObject_GetAttrString(value, "error");
	err_status = PyLong_AsLong(error);
	Py_DECREF(error);
	PyErr_Restore(type, value, traceback);
	}
	return err_status;
	}

	/* Exception support for callbacks. */
	#define EXCINFO "_callback_excinfo"

	static void _gpg_stash_callback_exception(PyObject *weak_self)
	{
	PyObject self, ptype, pvalue, ptraceback, *excinfo;

	PyErr_Fetch(&ptype, &pvalue, &ptraceback);
	excinfo = PyTuple_New(3);
	PyTuple_SetItem(excinfo, 0, ptype);

	if (pvalue)
	PyTuple_SetItem(excinfo, 1, pvalue);
	else {
	Py_INCREF(Py_None);
	PyTuple_SetItem(excinfo, 1, Py_None);
	}

	if (ptraceback)
	PyTuple_SetItem(excinfo, 2, ptraceback);
	else {
	Py_INCREF(Py_None);
	PyTuple_SetItem(excinfo, 2, Py_None);
	}

	self = PyWeakref_GetObject(weak_self);
	/* self only has a borrowed reference. */
	if (self == Py_None) {
	/* This should not happen, as even if we're called from the data
	release callback triggered from the wrappers destructor, the
	object is still alive and hence the weak reference still refers
	to the object. However, in case this ever changes, not seeing
	any exceptions is worse than having a little extra code, so
	here we go. */
	fprintf(stderr,
	"Error occurred in callback, but the wrapper object "
	"has been deallocated.\n");
	PyErr_Restore(ptype, pvalue, ptraceback);
	PyErr_Print();
	}
	else
	PyObject_SetAttrString(self, EXCINFO, excinfo);
	Py_DECREF(excinfo);
	}

	PyObject gpg_raise_callback_exception(PyObject self)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject ptype, pvalue, ptraceback, excinfo;

	if (! PyObject_HasAttrString(self, EXCINFO))
	goto leave;

	excinfo = PyObject_GetAttrString(self, EXCINFO);
	if (! PyTuple_Check(excinfo))
	{
	Py_DECREF(excinfo);
	goto leave;
	}

	ptype = PyTuple_GetItem(excinfo, 0);
	Py_INCREF(excinfo);

	pvalue = PyTuple_GetItem(excinfo, 1);
	if (pvalue == Py_None)
	pvalue = NULL;
	else
	Py_INCREF(pvalue);

	ptraceback = PyTuple_GetItem(excinfo, 2);
	if (ptraceback == Py_None)
	ptraceback = NULL;
	else
	Py_INCREF(ptraceback);

	/* We now have references for the extracted items. */
	Py_DECREF(excinfo);

	/* Clear the exception information. It is important to do this
	before setting the error, because setting the attribute may
	execute python code, and the runtime system raises a SystemError
	if an exception is set but values are returned. */
	Py_INCREF(Py_None);
	PyObject_SetAttrString(self, EXCINFO, Py_None);

	/* Restore exception. */
	PyErr_Restore(ptype, pvalue, ptraceback);
	PyGILState_Release(state);
	return NULL; /* Raise exception. */

	leave:
	Py_INCREF(Py_None);
	PyGILState_Release(state);
	return Py_None;
	}
	#undef EXCINFO

	/* Argument conversion. */

	/* Convert object to a pointer to gpgme type, generic version. */
	PyObject *
	_gpg_obj2gpgme_t(PyObject input, const char objtype, int argnum)
	{
	PyObject pyname = NULL, pypointer = NULL;
	pyname = PyObject_GetAttrString(input, "_ctype");
	if (pyname && PyUnicode_Check(pyname))
	{
	PyObject *encoded = PyUnicode_AsUTF8String(pyname);
	if (strcmp(PyBytes_AsString(encoded), objtype) != 0)
	{
	PyErr_Format(PyExc_TypeError,
	"arg %d: Expected value of type %s, but got %s",
	argnum, objtype, PyBytes_AsString(encoded));
	Py_DECREF(encoded);
	Py_DECREF(pyname);
	return NULL;
	}
	Py_DECREF(encoded);
	}
	else
	return NULL;

	Py_DECREF(pyname);
	pypointer = PyObject_GetAttrString(input, "wrapped");
	if (pypointer == NULL) {
	PyErr_Format(PyExc_TypeError,
	"arg %d: Use of uninitialized Python object %s",
	argnum, objtype);
	return NULL;
	}
	return pypointer;
	}

	/* Convert object to a pointer to gpgme type, version for data
	objects. Constructs a wrapper Python on the fly e.g. for file-like
	objects with a fileno method, returning it in WRAPPER. This object
	must be de-referenced when no longer needed. */
	PyObject *
	_gpg_obj2gpgme_data_t(PyObject input, int argnum, gpgme_data_t wrapper,
	PyObject *bytesio, Py_buffer view)
	{
	gpgme_error_t err;
	PyObject *data;
	PyObject *fd;

	/* See if it is a file-like object with file number. */
	fd = PyObject_CallMethod(input, "fileno", NULL);
	if (fd) {
	err = gpgme_data_new_from_fd(wrapper, (int) PyLong_AsLong(fd));
	Py_DECREF(fd);
	if (err)
	return _gpg_raise_exception (err);

	return _gpg_wrap_gpgme_data_t(*wrapper);
	}
	else
	PyErr_Clear();

	/* No? Maybe it implements the buffer protocol. */
	data = PyObject_CallMethod(input, "getbuffer", NULL);
	if (data)
	{
	/* Save a reference to input, which seems to be a BytesIO
	object. */
	Py_INCREF(input);
	*bytesio = input;
	}
	else
	{
	PyErr_Clear();

	/* No, but maybe the user supplied a buffer object? */
	data = input;
	}

	/* Do we have a buffer object? */
	if (PyObject_CheckBuffer(data))
	{
	if (PyObject_GetBuffer(data, view, PyBUF_SIMPLE) < 0)
	return NULL;

	if (data != input)
	Py_DECREF(data);

	assert (view->obj);
	assert (view->ndim == 1);
	assert (view->shape == NULL);
	assert (view->strides == NULL);
	assert (view->suboffsets == NULL);

	err = gpgme_data_new_from_mem(wrapper, view->buf, (size_t) view->len, 0);
	if (err)
	return _gpg_raise_exception (err);

	return _gpg_wrap_gpgme_data_t(*wrapper);
	}

	/* As last resort we assume it is a wrapped data object. */
	if (PyObject_HasAttrString(data, "_ctype"))
	return _gpg_obj2gpgme_t(data, "gpgme_data_t", argnum);

	return PyErr_Format(PyExc_TypeError,
	"arg %d: expected gpg.Data, file, "
	"bytes (not string!), or an object "
	"implementing the buffer protocol. Got: %s. "
	"If you provided a string, try to encode() it.",
	argnum, data->ob_type->tp_name);
	}



	PyObject *
	_gpg_wrap_result(PyObject fragile, const char classname)
	{
	static PyObject *results;
	PyObject *class;
	PyObject *replacement;

	if (results == NULL)
	{
	PyObject *from_list = PyList_New(0);
	if (from_list == NULL)
	return NULL;

	results = PyImport_ImportModuleLevel("results", PyEval_GetGlobals(),
	PyEval_GetLocals(), from_list, 1);
	Py_DECREF(from_list);

	if (results == NULL)
	return NULL;
	}

	class = PyMapping_GetItemString(PyModule_GetDict(results), classname);
	if (class == NULL)
	return NULL;

	replacement = PyObject_CallFunctionObjArgs(class, fragile, NULL);
	Py_DECREF(class);
	return replacement;
	}



	/* Callback support. */
	static gpgme_error_t pyPassphraseCb(void *hook,
	const char *uid_hint,
	const char *passphrase_info,
	int prev_was_bad,
	int fd) {
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *args = NULL;
	PyObject *retval = NULL;
	PyObject *dataarg = NULL;
	PyObject *encoded = NULL;
	gpgme_error_t err_status = 0;

	_gpg_exception_init();

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 2 \|\| PyTuple_Size(pyhook) == 3);
	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 1);
	if (PyTuple_Size(pyhook) == 3) {
	dataarg = PyTuple_GetItem(pyhook, 2);
	args = PyTuple_New(4);
	} else {
	args = PyTuple_New(3);
	}

	if (uid_hint == NULL)
	{
	Py_INCREF(Py_None);
	PyTuple_SetItem(args, 0, Py_None);
	}
	else
	PyTuple_SetItem(args, 0, PyUnicode_DecodeUTF8(uid_hint, strlen (uid_hint),
	"strict"));
	if (PyErr_Occurred()) {
	Py_DECREF(args);
	err_status = gpg_error(GPG_ERR_GENERAL);
	goto leave;
	}

	if (passphrase_info == NULL)
	{
	Py_INCREF(Py_None);
	PyTuple_SetItem(args, 1, Py_None);
	}
	else
	PyTuple_SetItem(args, 1, PyUnicode_DecodeUTF8(passphrase_info,
	strlen (passphrase_info),
	"strict"));
	if (PyErr_Occurred()) {
	Py_DECREF(args);
	err_status = gpg_error(GPG_ERR_GENERAL);
	goto leave;
	}

	PyTuple_SetItem(args, 2, PyBool_FromLong((long)prev_was_bad));
	if (dataarg) {
	Py_INCREF(dataarg); /* Because GetItem doesn't give a ref but SetItem taketh away */
	PyTuple_SetItem(args, 3, dataarg);
	}

	retval = PyObject_CallObject(func, args);
	Py_DECREF(args);
	if (PyErr_Occurred()) {
	err_status = _gpg_exception2code();
	} else {
	if (!retval) {
	if (write(fd, "\n", 1) < 0) {
	err_status = gpgme_error_from_syserror ();
	_gpg_raise_exception (err_status);
	}
	} else {
	char *buf;
	size_t len;
	if (PyBytes_Check(retval))
	buf = PyBytes_AsString(retval), len = PyBytes_Size(retval);
	else if (PyUnicode_Check(retval))
	{
	Py_ssize_t ssize;
	encoded = PyUnicode_AsUTF8String(retval);
	if (encoded == NULL)
	{
	err_status = gpg_error(GPG_ERR_GENERAL);
	goto leave;
	}
	if (PyBytes_AsStringAndSize(encoded, &buf, &ssize) == -1)
	{
	err_status = gpg_error(GPG_ERR_GENERAL);
	goto leave;
	}
	assert (! buf \|\| ssize >= 0);
	len = (size_t) ssize;
	}
	else
	{
	PyErr_Format(PyExc_TypeError,
	"expected str or bytes from passphrase callback, got %s",
	retval->ob_type->tp_name);
	err_status = gpg_error(GPG_ERR_GENERAL);
	goto leave;
	}

	if (write(fd, buf, len) < 0) {
	err_status = gpgme_error_from_syserror ();
	_gpg_raise_exception (err_status);
	}
	if (! err_status && write(fd, "\n", 1) < 0) {
	err_status = gpgme_error_from_syserror ();
	_gpg_raise_exception (err_status);
	}

	Py_DECREF(retval);
	}
	}

	leave:
	if (err_status)
	_gpg_stash_callback_exception(self);

	Py_XDECREF(encoded);
	PyGILState_Release(state);
	return err_status;
	}

	PyObject *
	gpg_set_passphrase_cb(PyObject self, PyObject cb) {
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject *wrapped;
	gpgme_ctx_t ctx;

	wrapped = PyObject_GetAttrString(self, "wrapped");
	if (wrapped == NULL)
	{
	assert (PyErr_Occurred ());
	PyGILState_Release(state);
	return NULL;
	}

	ctx = _gpg_unwrap_gpgme_ctx_t(wrapped);
	Py_DECREF(wrapped);
	if (ctx == NULL)
	{
	if (cb == Py_None)
	goto out;
	else
	return PyErr_Format(PyExc_RuntimeError, "wrapped is NULL");
	}

	if (cb == Py_None) {
	gpgme_set_passphrase_cb(ctx, NULL, NULL);
	PyObject_SetAttrString(self, "_passphrase_cb", Py_None);
	goto out;
	}

	if (! PyTuple_Check(cb))
	return PyErr_Format(PyExc_TypeError, "cb must be a tuple");
	if (PyTuple_Size(cb) != 2 && PyTuple_Size(cb) != 3)
	return PyErr_Format(PyExc_TypeError,
	"cb must be a tuple of size 2 or 3");

	gpgme_set_passphrase_cb(ctx, (gpgme_passphrase_cb_t) pyPassphraseCb,
	(void *) cb);
	PyObject_SetAttrString(self, "_passphrase_cb", cb);

	out:
	Py_INCREF(Py_None);
	PyGILState_Release(state);
	return Py_None;
	}

	static void pyProgressCb(void hook, const char what, int type, int current,
	int total) {
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject func = NULL, dataarg = NULL, args = NULL, retval = NULL;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 2 \|\| PyTuple_Size(pyhook) == 3);
	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 1);
	if (PyTuple_Size(pyhook) == 3) {
	dataarg = PyTuple_GetItem(pyhook, 2);
	args = PyTuple_New(5);
	} else {
	args = PyTuple_New(4);
	}

	PyTuple_SetItem(args, 0, PyUnicode_DecodeUTF8(what, strlen (what),
	"strict"));
	if (PyErr_Occurred()) {
	_gpg_stash_callback_exception(self);
	Py_DECREF(args);
	PyGILState_Release(state);
	return;
	}
	PyTuple_SetItem(args, 1, PyLong_FromLong((long) type));
	PyTuple_SetItem(args, 2, PyLong_FromLong((long) current));
	PyTuple_SetItem(args, 3, PyLong_FromLong((long) total));
	if (dataarg) {
	Py_INCREF(dataarg); /* Because GetItem doesn't give a ref but SetItem taketh away */
	PyTuple_SetItem(args, 4, dataarg);
	}

	retval = PyObject_CallObject(func, args);
	if (PyErr_Occurred())
	_gpg_stash_callback_exception(self);
	Py_DECREF(args);
	Py_XDECREF(retval);
	PyGILState_Release(state);
	}

	PyObject *
	gpg_set_progress_cb(PyObject self, PyObject cb) {
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject *wrapped;
	gpgme_ctx_t ctx;

	wrapped = PyObject_GetAttrString(self, "wrapped");
	if (wrapped == NULL)
	{
	assert (PyErr_Occurred ());
	PyGILState_Release(state);
	return NULL;
	}

	ctx = _gpg_unwrap_gpgme_ctx_t(wrapped);
	Py_DECREF(wrapped);
	if (ctx == NULL)
	{
	if (cb == Py_None)
	goto out;
	else
	return PyErr_Format(PyExc_RuntimeError, "wrapped is NULL");
	}

	if (cb == Py_None) {
	gpgme_set_progress_cb(ctx, NULL, NULL);
	PyObject_SetAttrString(self, "_progress_cb", Py_None);
	goto out;
	}

	if (! PyTuple_Check(cb))
	return PyErr_Format(PyExc_TypeError, "cb must be a tuple");
	if (PyTuple_Size(cb) != 2 && PyTuple_Size(cb) != 3)
	return PyErr_Format(PyExc_TypeError,
	"cb must be a tuple of size 2 or 3");

	gpgme_set_progress_cb(ctx, (gpgme_progress_cb_t) pyProgressCb, (void *) cb);
	PyObject_SetAttrString(self, "_progress_cb", cb);

	out:
	Py_INCREF(Py_None);
	PyGILState_Release(state);
	return Py_None;
	}

	/* Status callbacks. */
	static gpgme_error_t pyStatusCb(void hook, const char keyword,
	const char *args) {
	PyGILState_STATE state = PyGILState_Ensure();
	gpgme_error_t err = 0;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *dataarg = NULL;
	PyObject *pyargs = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 2 \|\| PyTuple_Size(pyhook) == 3);
	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 1);
	if (PyTuple_Size(pyhook) == 3) {
	dataarg = PyTuple_GetItem(pyhook, 2);
	pyargs = PyTuple_New(3);
	} else {
	pyargs = PyTuple_New(2);
	}

	if (keyword)
	PyTuple_SetItem(pyargs, 0, PyUnicode_DecodeUTF8(keyword, strlen (keyword),
	"strict"));
	else
	{
	Py_INCREF(Py_None);
	PyTuple_SetItem(pyargs, 0, Py_None);
	}
	PyTuple_SetItem(pyargs, 1, PyUnicode_DecodeUTF8(args, strlen (args),
	"strict"));
	if (PyErr_Occurred()) {
	err = gpg_error(GPG_ERR_GENERAL);
	Py_DECREF(pyargs);
	goto leave;
	}

	if (dataarg) {
	Py_INCREF(dataarg);
	PyTuple_SetItem(pyargs, 2, dataarg);
	}

	retval = PyObject_CallObject(func, pyargs);
	if (PyErr_Occurred())
	err = _gpg_exception2code();
	Py_DECREF(pyargs);
	Py_XDECREF(retval);

	leave:
	if (err)
	_gpg_stash_callback_exception(self);
	PyGILState_Release(state);
	return err;
	}

	PyObject *
	gpg_set_status_cb(PyObject self, PyObject cb) {
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject *wrapped;
	gpgme_ctx_t ctx;

	wrapped = PyObject_GetAttrString(self, "wrapped");
	if (wrapped == NULL)
	{
	assert (PyErr_Occurred ());
	PyGILState_Release(state);
	return NULL;
	}

	ctx = _gpg_unwrap_gpgme_ctx_t(wrapped);
	Py_DECREF(wrapped);
	if (ctx == NULL)
	{
	if (cb == Py_None)
	goto out;
	else
	return PyErr_Format(PyExc_RuntimeError, "wrapped is NULL");
	}

	if (cb == Py_None) {
	gpgme_set_status_cb(ctx, NULL, NULL);
	PyObject_SetAttrString(self, "_status_cb", Py_None);
	goto out;
	}

	if (! PyTuple_Check(cb))
	return PyErr_Format(PyExc_TypeError, "cb must be a tuple");
	if (PyTuple_Size(cb) != 2 && PyTuple_Size(cb) != 3)
	return PyErr_Format(PyExc_TypeError,
	"cb must be a tuple of size 2 or 3");

	gpgme_set_status_cb(ctx, (gpgme_status_cb_t) pyStatusCb, (void *) cb);
	PyObject_SetAttrString(self, "_status_cb", cb);

	out:
	Py_INCREF(Py_None);
	PyGILState_Release(state);
	return Py_None;
	}



	/* Interact callbacks. */
	gpgme_error_t
	_gpg_interact_cb(void opaque, const char keyword,
	const char *args, int fd)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject func = NULL, dataarg = NULL, pyargs = NULL, retval = NULL;
	PyObject *py_keyword;
	PyObject pyopaque = (PyObject ) opaque;
	gpgme_error_t err_status = 0;
	PyObject *self = NULL;

	_gpg_exception_init();

	assert (PyTuple_Check(pyopaque));
	assert (PyTuple_Size(pyopaque) == 2 \|\| PyTuple_Size(pyopaque) == 3);
	self = PyTuple_GetItem(pyopaque, 0);
	func = PyTuple_GetItem(pyopaque, 1);
	if (PyTuple_Size(pyopaque) == 3) {
	dataarg = PyTuple_GetItem(pyopaque, 2);
	pyargs = PyTuple_New(3);
	} else {
	pyargs = PyTuple_New(2);
	}

	if (keyword)
	py_keyword = PyUnicode_FromString(keyword);
	else
	{
	Py_INCREF(Py_None);
	py_keyword = Py_None;
	}

	PyTuple_SetItem(pyargs, 0, py_keyword);
	PyTuple_SetItem(pyargs, 1, PyUnicode_FromString(args));
	if (dataarg) {
	Py_INCREF(dataarg); /* Because GetItem doesn't give a ref but SetItem taketh away */
	PyTuple_SetItem(pyargs, 2, dataarg);
	}

	retval = PyObject_CallObject(func, pyargs);
	Py_DECREF(pyargs);
	if (PyErr_Occurred()) {
	err_status = _gpg_exception2code();
	} else {
	if (fd>=0 && retval && PyUnicode_Check(retval)) {
	PyObject *encoded = NULL;
	char *buffer;
	Py_ssize_t size;

	encoded = PyUnicode_AsUTF8String(retval);
	if (encoded == NULL)
	{
	err_status = gpg_error(GPG_ERR_GENERAL);
	goto leave;
	}
	if (PyBytes_AsStringAndSize(encoded, &buffer, &size) == -1)
	{
	Py_DECREF(encoded);
	err_status = gpg_error(GPG_ERR_GENERAL);
	goto leave;
	}

	if (write(fd, buffer, size) < 0) {
	err_status = gpgme_error_from_syserror ();
	_gpg_raise_exception (err_status);
	}
	if (! err_status && write(fd, "\n", 1) < 0) {
	err_status = gpgme_error_from_syserror ();
	_gpg_raise_exception (err_status);
	}
	Py_DECREF(encoded);
	}
	}
	leave:
	if (err_status)
	_gpg_stash_callback_exception(self);

	Py_XDECREF(retval);
	PyGILState_Release(state);
	return err_status;
	}



	/* Data callbacks. */

	/* Read up to SIZE bytes into buffer BUFFER from the data object with
	the handle HOOK. Return the number of characters read, 0 on EOF
	and -1 on error. If an error occurs, errno is set. */
	static ssize_t pyDataReadCb(void hook, void buffer, size_t size)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	ssize_t result;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *dataarg = NULL;
	PyObject *pyargs = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 5 \|\| PyTuple_Size(pyhook) == 6);

	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 1);
	if (PyTuple_Size(pyhook) == 6) {
	dataarg = PyTuple_GetItem(pyhook, 5);
	pyargs = PyTuple_New(2);
	} else {
	pyargs = PyTuple_New(1);
	}

	PyTuple_SetItem(pyargs, 0, PyLong_FromSize_t(size));
	if (dataarg) {
	Py_INCREF(dataarg);
	PyTuple_SetItem(pyargs, 1, dataarg);
	}

	retval = PyObject_CallObject(func, pyargs);
	Py_DECREF(pyargs);
	if (PyErr_Occurred()) {
	_gpg_stash_callback_exception(self);
	result = -1;
	goto leave;
	}

	if (! PyBytes_Check(retval)) {
	PyErr_Format(PyExc_TypeError,
	"expected bytes from read callback, got %s",
	retval->ob_type->tp_name);
	_gpg_stash_callback_exception(self);
	result = -1;
	goto leave;
	}

	if (PyBytes_Size(retval) > size) {
	PyErr_Format(PyExc_TypeError,
	"expected %zu bytes from read callback, got %zu",
	size, PyBytes_Size(retval));
	_gpg_stash_callback_exception(self);
	result = -1;
	goto leave;
	}

	memcpy(buffer, PyBytes_AsString(retval), PyBytes_Size(retval));
	result = PyBytes_Size(retval);

	leave:
	Py_XDECREF(retval);
	PyGILState_Release(state);
	return result;
	}

	/* Write up to SIZE bytes from buffer BUFFER to the data object with
	the handle HOOK. Return the number of characters written, or -1
	on error. If an error occurs, errno is set. */
	static ssize_t pyDataWriteCb(void hook, const void buffer, size_t size)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	ssize_t result;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *dataarg = NULL;
	PyObject *pyargs = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 5 \|\| PyTuple_Size(pyhook) == 6);

	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 2);
	if (PyTuple_Size(pyhook) == 6) {
	dataarg = PyTuple_GetItem(pyhook, 5);
	pyargs = PyTuple_New(2);
	} else {
	pyargs = PyTuple_New(1);
	}

	PyTuple_SetItem(pyargs, 0, PyBytes_FromStringAndSize(buffer, size));
	if (dataarg) {
	Py_INCREF(dataarg);
	PyTuple_SetItem(pyargs, 1, dataarg);
	}

	retval = PyObject_CallObject(func, pyargs);
	Py_DECREF(pyargs);
	if (PyErr_Occurred()) {
	_gpg_stash_callback_exception(self);
	result = -1;
	goto leave;
	}

	#if PY_MAJOR_VERSION < 3
	if (PyInt_Check(retval))
	result = PyInt_AsSsize_t(retval);
	else
	#endif
	if (PyLong_Check(retval))
	result = PyLong_AsSsize_t(retval);
	else {
	PyErr_Format(PyExc_TypeError,
	"expected int from write callback, got %s",
	retval->ob_type->tp_name);
	_gpg_stash_callback_exception(self);
	result = -1;
	}

	leave:
	Py_XDECREF(retval);
	PyGILState_Release(state);
	return result;
	}

	/* Set the current position from where the next read or write starts
	in the data object with the handle HOOK to OFFSET, relativ to
	WHENCE. Returns the new offset in bytes from the beginning of the
	data object. */
	static off_t pyDataSeekCb(void *hook, off_t offset, int whence)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	off_t result;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *dataarg = NULL;
	PyObject *pyargs = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 5 \|\| PyTuple_Size(pyhook) == 6);

	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 3);
	if (PyTuple_Size(pyhook) == 6) {
	dataarg = PyTuple_GetItem(pyhook, 5);
	pyargs = PyTuple_New(3);
	} else {
	pyargs = PyTuple_New(2);
	}

	#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
	PyTuple_SetItem(pyargs, 0, PyLong_FromLongLong((long long) offset));
	#else
	PyTuple_SetItem(pyargs, 0, PyLong_FromLong((long) offset));
	#endif
	PyTuple_SetItem(pyargs, 1, PyLong_FromLong((long) whence));
	if (dataarg) {
	Py_INCREF(dataarg);
	PyTuple_SetItem(pyargs, 2, dataarg);
	}

	retval = PyObject_CallObject(func, pyargs);
	Py_DECREF(pyargs);
	if (PyErr_Occurred()) {
	_gpg_stash_callback_exception(self);
	result = -1;
	goto leave;
	}

	#if PY_MAJOR_VERSION < 3
	if (PyInt_Check(retval))
	result = PyInt_AsLong(retval);
	else
	#endif
	if (PyLong_Check(retval))
	#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
	result = PyLong_AsLongLong(retval);
	#else
	result = PyLong_AsLong(retval);
	#endif
	else {
	PyErr_Format(PyExc_TypeError,
	"expected int from seek callback, got %s",
	retval->ob_type->tp_name);
	_gpg_stash_callback_exception(self);
	result = -1;
	}

	leave:
	Py_XDECREF(retval);
	PyGILState_Release(state);
	return result;
	}

	/* Close the data object with the handle HOOK. */
	static void pyDataReleaseCb(void *hook)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *dataarg = NULL;
	PyObject *pyargs = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 5 \|\| PyTuple_Size(pyhook) == 6);

	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 4);
	if (PyTuple_Size(pyhook) == 6) {
	dataarg = PyTuple_GetItem(pyhook, 5);
	pyargs = PyTuple_New(1);
	} else {
	pyargs = PyTuple_New(0);
	}

	if (dataarg) {
	Py_INCREF(dataarg);
	PyTuple_SetItem(pyargs, 0, dataarg);
	}

	retval = PyObject_CallObject(func, pyargs);
	Py_XDECREF(retval);
	Py_DECREF(pyargs);
	if (PyErr_Occurred())
	_gpg_stash_callback_exception(self);
	PyGILState_Release(state);
	}

	PyObject *
	gpg_data_new_from_cbs(PyObject *self,
	PyObject *pycbs,
	gpgme_data_t *r_data)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	static struct gpgme_data_cbs cbs = {
	pyDataReadCb,
	pyDataWriteCb,
	pyDataSeekCb,
	pyDataReleaseCb,
	};
	gpgme_error_t err;

	if (! PyTuple_Check(pycbs))
	return PyErr_Format(PyExc_TypeError, "pycbs must be a tuple");
	if (PyTuple_Size(pycbs) != 5 && PyTuple_Size(pycbs) != 6)
	return PyErr_Format(PyExc_TypeError,
	"pycbs must be a tuple of size 5 or 6");

	err = gpgme_data_new_from_cbs(r_data, &cbs, (void *) pycbs);
	if (err)
	return _gpg_raise_exception(err);

	PyObject_SetAttrString(self, "_data_cbs", pycbs);

	Py_INCREF(Py_None);
	PyGILState_Release(state);
	return Py_None;
	}



	/* The assuan callbacks. */

	gpgme_error_t
	_gpg_assuan_data_cb (void hook, const void data, size_t datalen)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	gpgme_error_t err = 0;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *py_data = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 2);
	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 1);
	assert (PyCallable_Check(func));

	py_data = PyBytes_FromStringAndSize(data, datalen);
	if (py_data == NULL)
	{
	err = _gpg_exception2code();
	goto leave;
	}

	retval = PyObject_CallFunctionObjArgs(func, py_data, NULL);
	if (PyErr_Occurred())
	err = _gpg_exception2code();
	Py_DECREF(py_data);
	Py_XDECREF(retval);

	leave:
	if (err)
	_gpg_stash_callback_exception(self);
	PyGILState_Release(state);
	return err;
	}

	gpgme_error_t
	_gpg_assuan_inquire_cb (void hook, const char name, const char *args,
	gpgme_data_t *r_data)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	gpgme_error_t err = 0;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *py_name = NULL;
	PyObject *py_args = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 2);
	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 1);
	assert (PyCallable_Check(func));

	py_name = PyUnicode_FromString(name);
	if (py_name == NULL)
	{
	err = _gpg_exception2code();
	goto leave;
	}

	py_args = PyUnicode_FromString(args);
	if (py_args == NULL)
	{
	err = _gpg_exception2code();
	goto leave;
	}

	retval = PyObject_CallFunctionObjArgs(func, py_name, py_args, NULL);
	if (PyErr_Occurred())
	err = _gpg_exception2code();
	Py_XDECREF(retval);

	/* FIXME: Returning data is not yet implemented. */
	*r_data = NULL;

	leave:
	Py_XDECREF(py_name);
	Py_XDECREF(py_args);
	if (err)
	_gpg_stash_callback_exception(self);
	PyGILState_Release(state);
	return err;
	}

	gpgme_error_t
	_gpg_assuan_status_cb (void hook, const char status, const char *args)
	{
	PyGILState_STATE state = PyGILState_Ensure();
	gpgme_error_t err = 0;
	PyObject pyhook = (PyObject ) hook;
	PyObject *self = NULL;
	PyObject *func = NULL;
	PyObject *py_status = NULL;
	PyObject *py_args = NULL;
	PyObject *retval = NULL;

	assert (PyTuple_Check(pyhook));
	assert (PyTuple_Size(pyhook) == 2);
	self = PyTuple_GetItem(pyhook, 0);
	func = PyTuple_GetItem(pyhook, 1);
	assert (PyCallable_Check(func));

	py_status = PyUnicode_FromString(status);
	if (py_status == NULL)
	{
	err = _gpg_exception2code();
	goto leave;
	}

	py_args = PyUnicode_FromString(args);
	if (py_args == NULL)
	{
	err = _gpg_exception2code();
	goto leave;
	}

	retval = PyObject_CallFunctionObjArgs(func, py_status, py_args, NULL);
	if (PyErr_Occurred())
	err = _gpg_exception2code();
	Py_XDECREF(retval);

	leave:
	Py_XDECREF(py_status);
	Py_XDECREF(py_args);
	if (err)
	_gpg_stash_callback_exception(self);
	PyGILState_Release(state);
	return err;
	}

File Metadata

Mime Type: text/x-c
Expires: Mon, Dec 23, 4:41 PM (9 h, 45 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 85/e8/f0b5071bb2adcbece5c3b50b94ae

helpers.cNo OneTemporaryActions

helpers.cView Options

File Metadata

Event Timeline

helpers.c
No OneTemporary
Actions

helpers.c
View Options