LCOV - code coverage report
Current view: top level - build/lang/python/python2.7-gpg - helpers.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 473 598 79.1 %
Date: 2018-11-15 08:49:49 Functions: 21 23 91.3 %

          Line data    Source code
       1             : /*
       2             : # Copyright (C) 2016 g10 Code GmbH
       3             : # Copyright (C) 2004 Igor Belyi <belyi@users.sourceforge.net>
       4             : # Copyright (C) 2002 John Goerzen <jgoerzen@complete.org>
       5             : #
       6             : #    This library is free software; you can redistribute it and/or
       7             : #    modify it under the terms of the GNU Lesser General Public
       8             : #    License as published by the Free Software Foundation; either
       9             : #    version 2.1 of the License, or (at your option) any later version.
      10             : #
      11             : #    This library is distributed in the hope that it will be useful,
      12             : #    but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             : #    Lesser General Public License for more details.
      15             : #
      16             : #    You should have received a copy of the GNU Lesser General Public
      17             : #    License along with this library; if not, write to the Free Software
      18             : #    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
      19             : */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include "config.h"
      23             : #endif
      24             : 
      25             : #include <assert.h>
      26             : #include <stdio.h>
      27             : #include <gpgme.h>
      28             : #include <stdlib.h>
      29             : #include <string.h>
      30             : #include "Python.h"
      31             : 
      32             : #include "helpers.h"
      33             : #include "private.h"
      34             : 
      35             : /* Flag specifying whether this is an in-tree build.  */
      36             : int gpg_in_tree_build =
      37             : #if IN_TREE_BUILD
      38             :   1
      39             : #else
      40             :   0
      41             : #endif
      42             :   ;
      43             : 
      44             : static PyObject *GPGMEError = NULL;
      45             : 
      46          60 : void _gpg_exception_init(void) {
      47          60 :   if (GPGMEError == NULL) {
      48             :     PyObject *errors;
      49           6 :     PyObject *from_list = PyList_New(0);
      50           6 :     errors = PyImport_ImportModuleLevel("errors", PyEval_GetGlobals(),
      51             :                                         PyEval_GetLocals(), from_list, 1);
      52           6 :     Py_XDECREF(from_list);
      53           6 :     if (errors) {
      54           6 :       GPGMEError=PyDict_GetItemString(PyModule_GetDict(errors), "GPGMEError");
      55           6 :       Py_XINCREF(GPGMEError);
      56             :     }
      57             :   }
      58          60 : }
      59             : 
      60             : static PyObject *
      61           0 : _gpg_raise_exception(gpgme_error_t err)
      62             : {
      63             :   PyObject *e;
      64             : 
      65           0 :   _gpg_exception_init();
      66           0 :   if (GPGMEError == NULL)
      67           0 :     return PyErr_Format(PyExc_RuntimeError, "Got gpgme_error_t %d", err);
      68             : 
      69           0 :   e = PyObject_CallFunction(GPGMEError, "l", (long) err);
      70           0 :   if (e == NULL)
      71             :     return NULL;
      72             : 
      73           0 :   PyErr_SetObject(GPGMEError, e);
      74           0 :   Py_DECREF(e);
      75             : 
      76             :   return NULL;  /* raise */
      77             : }
      78             : 
      79           4 : gpgme_error_t _gpg_exception2code(void) {
      80           4 :   gpgme_error_t err_status = gpg_error(GPG_ERR_GENERAL);
      81           4 :   if (GPGMEError && PyErr_ExceptionMatches(GPGMEError)) {
      82           0 :     PyObject *type = 0, *value = 0, *traceback = 0;
      83           0 :     PyObject *error = 0;
      84           0 :     PyErr_Fetch(&type, &value, &traceback);
      85           0 :     PyErr_NormalizeException(&type, &value, &traceback);
      86           0 :     error = PyObject_GetAttrString(value, "error");
      87           0 :     err_status = PyLong_AsLong(error);
      88           0 :     Py_DECREF(error);
      89           0 :     PyErr_Restore(type, value, traceback);
      90             :   }
      91           4 :   return err_status;
      92             : }
      93             : 
      94             : /* Exception support for callbacks.  */
      95             : #define EXCINFO "_callback_excinfo"
      96             : 
      97          38 : static void _gpg_stash_callback_exception(PyObject *weak_self)
      98             : {
      99             :   PyObject *self, *ptype, *pvalue, *ptraceback, *excinfo;
     100             : 
     101          38 :   PyErr_Fetch(&ptype, &pvalue, &ptraceback);
     102          38 :   excinfo = PyTuple_New(3);
     103          38 :   PyTuple_SetItem(excinfo, 0, ptype);
     104             : 
     105          38 :   if (pvalue)
     106          38 :     PyTuple_SetItem(excinfo, 1, pvalue);
     107             :   else {
     108           0 :     Py_INCREF(Py_None);
     109           0 :     PyTuple_SetItem(excinfo, 1, Py_None);
     110             :   }
     111             : 
     112          38 :   if (ptraceback)
     113          33 :     PyTuple_SetItem(excinfo, 2, ptraceback);
     114             :   else {
     115           5 :     Py_INCREF(Py_None);
     116           5 :     PyTuple_SetItem(excinfo, 2, Py_None);
     117             :   }
     118             : 
     119          38 :   self = PyWeakref_GetObject(weak_self);
     120             :   /* self only has a borrowed reference.  */
     121          38 :   if (self == Py_None) {
     122             :     /* This should not happen, as even if we're called from the data
     123             :        release callback triggered from the wrappers destructor, the
     124             :        object is still alive and hence the weak reference still refers
     125             :        to the object.  However, in case this ever changes, not seeing
     126             :        any exceptions is worse than having a little extra code, so
     127             :        here we go.  */
     128           0 :       fprintf(stderr,
     129             :               "Error occurred in callback, but the wrapper object "
     130             :               "has been deallocated.\n");
     131           0 :       PyErr_Restore(ptype, pvalue, ptraceback);
     132           0 :       PyErr_Print();
     133             :     }
     134             :   else
     135          38 :     PyObject_SetAttrString(self, EXCINFO, excinfo);
     136          38 :   Py_DECREF(excinfo);
     137          38 : }
     138             : 
     139          13 : PyObject *gpg_raise_callback_exception(PyObject *self)
     140             : {
     141          13 :   PyGILState_STATE state = PyGILState_Ensure();
     142             :   PyObject *ptype, *pvalue, *ptraceback, *excinfo;
     143             : 
     144          13 :   if (! PyObject_HasAttrString(self, EXCINFO))
     145             :     goto leave;
     146             : 
     147          13 :   excinfo = PyObject_GetAttrString(self, EXCINFO);
     148          13 :   if (! PyTuple_Check(excinfo))
     149             :     {
     150           0 :       Py_DECREF(excinfo);
     151             :       goto leave;
     152             :     }
     153             : 
     154          13 :   ptype = PyTuple_GetItem(excinfo, 0);
     155          13 :   Py_INCREF(excinfo);
     156             : 
     157          13 :   pvalue = PyTuple_GetItem(excinfo, 1);
     158          13 :   if (pvalue == Py_None)
     159             :     pvalue = NULL;
     160             :   else
     161          13 :     Py_INCREF(pvalue);
     162             : 
     163          13 :   ptraceback = PyTuple_GetItem(excinfo, 2);
     164          13 :   if (ptraceback == Py_None)
     165             :     ptraceback = NULL;
     166             :   else
     167           8 :     Py_INCREF(ptraceback);
     168             : 
     169             :   /* We now have references for the extracted items.  */
     170          13 :   Py_DECREF(excinfo);
     171             : 
     172             :   /* Clear the exception information.  It is important to do this
     173             :      before setting the error, because setting the attribute may
     174             :      execute python code, and the runtime system raises a SystemError
     175             :      if an exception is set but values are returned.  */
     176          13 :   Py_INCREF(Py_None);
     177          13 :   PyObject_SetAttrString(self, EXCINFO, Py_None);
     178             : 
     179             :   /* Restore exception.  */
     180          13 :   PyErr_Restore(ptype, pvalue, ptraceback);
     181          13 :   PyGILState_Release(state);
     182          13 :   return NULL; /* Raise exception.  */
     183             : 
     184             :  leave:
     185           0 :   Py_INCREF(Py_None);
     186           0 :   PyGILState_Release(state);
     187           0 :   return Py_None;
     188             : }
     189             : #undef EXCINFO
     190             : 
     191             : /* Argument conversion.  */
     192             : 
     193             : /* Convert object to a pointer to gpgme type, generic version.  */
     194             : PyObject *
     195         100 : _gpg_obj2gpgme_t(PyObject *input, const char *objtype, int argnum)
     196             : {
     197         100 :   PyObject *pyname = NULL, *pypointer = NULL;
     198         100 :   pyname = PyObject_GetAttrString(input, "_ctype");
     199         100 :   if (pyname && PyUnicode_Check(pyname))
     200             :     {
     201         100 :       PyObject *encoded = PyUnicode_AsUTF8String(pyname);
     202         100 :       if (strcmp(PyBytes_AsString(encoded), objtype) != 0)
     203             :         {
     204           0 :           PyErr_Format(PyExc_TypeError,
     205             :                        "arg %d: Expected value of type %s, but got %s",
     206             :                        argnum, objtype, PyBytes_AsString(encoded));
     207           0 :           Py_DECREF(encoded);
     208           0 :           Py_DECREF(pyname);
     209             :           return NULL;
     210             :         }
     211         100 :       Py_DECREF(encoded);
     212             :     }
     213             :   else
     214             :     return NULL;
     215             : 
     216         100 :   Py_DECREF(pyname);
     217         100 :   pypointer = PyObject_GetAttrString(input, "wrapped");
     218         100 :   if (pypointer == NULL) {
     219           0 :     PyErr_Format(PyExc_TypeError,
     220             :                  "arg %d: Use of uninitialized Python object %s",
     221             :                  argnum, objtype);
     222           0 :     return NULL;
     223             :   }
     224             :   return pypointer;
     225             : }
     226             : 
     227             : /* Convert object to a pointer to gpgme type, version for data
     228             :    objects.  Constructs a wrapper Python on the fly e.g. for file-like
     229             :    objects with a fileno method, returning it in WRAPPER.  This object
     230             :    must be de-referenced when no longer needed.  */
     231             : PyObject *
     232         145 : _gpg_obj2gpgme_data_t(PyObject *input, int argnum, gpgme_data_t *wrapper,
     233             :                        PyObject **bytesio, Py_buffer *view)
     234             : {
     235             :   gpgme_error_t err;
     236             :   PyObject *data;
     237             :   PyObject *fd;
     238             : 
     239             :   /* See if it is a file-like object with file number.  */
     240         145 :   fd = PyObject_CallMethod(input, "fileno", NULL);
     241         145 :   if (fd) {
     242           9 :     err = gpgme_data_new_from_fd(wrapper, (int) PyLong_AsLong(fd));
     243           9 :     Py_DECREF(fd);
     244           9 :     if (err)
     245           0 :       return _gpg_raise_exception (err);
     246             : 
     247           9 :     return _gpg_wrap_gpgme_data_t(*wrapper);
     248             :   }
     249             :   else
     250         136 :     PyErr_Clear();
     251             : 
     252             :   /* No?  Maybe it implements the buffer protocol.  */
     253         136 :   data = PyObject_CallMethod(input, "getbuffer", NULL);
     254         136 :   if (data)
     255             :     {
     256             :       /* Save a reference to input, which seems to be a BytesIO
     257             :          object.  */
     258           0 :       Py_INCREF(input);
     259           0 :       *bytesio = input;
     260             :     }
     261             :   else
     262             :     {
     263         136 :       PyErr_Clear();
     264             : 
     265             :       /* No, but maybe the user supplied a buffer object?  */
     266         136 :       data = input;
     267             :     }
     268             : 
     269             :   /* Do we have a buffer object?  */
     270         136 :   if (PyObject_CheckBuffer(data))
     271             :     {
     272          35 :       if (PyObject_GetBuffer(data, view, PyBUF_SIMPLE) < 0)
     273             :         return NULL;
     274             : 
     275          35 :       if (data != input)
     276           0 :         Py_DECREF(data);
     277             : 
     278             :       assert (view->obj);
     279             :       assert (view->ndim == 1);
     280             :       assert (view->shape == NULL);
     281             :       assert (view->strides == NULL);
     282             :       assert (view->suboffsets == NULL);
     283             : 
     284          35 :       err = gpgme_data_new_from_mem(wrapper, view->buf, (size_t) view->len, 0);
     285          35 :       if (err)
     286           0 :         return _gpg_raise_exception (err);
     287             : 
     288          35 :       return _gpg_wrap_gpgme_data_t(*wrapper);
     289             :     }
     290             : 
     291             :   /* As last resort we assume it is a wrapped data object.  */
     292         101 :   if (PyObject_HasAttrString(data, "_ctype"))
     293         100 :     return _gpg_obj2gpgme_t(data, "gpgme_data_t", argnum);
     294             : 
     295           1 :   return PyErr_Format(PyExc_TypeError,
     296             :                       "arg %d: expected gpg.Data, file, "
     297             :                       "bytes (not string!), or an object "
     298             :                       "implementing the buffer protocol. Got: %s. "
     299             :                       "If you provided a string, try to encode() it.",
     300           1 :                       argnum, data->ob_type->tp_name);
     301             : }
     302             : 
     303             : 
     304             : 
     305             : PyObject *
     306         321 : _gpg_wrap_result(PyObject *fragile, const char *classname)
     307             : {
     308             :   static PyObject *results;
     309             :   PyObject *class;
     310             :   PyObject *replacement;
     311             : 
     312         321 :   if (results == NULL)
     313             :     {
     314          29 :       PyObject *from_list = PyList_New(0);
     315          29 :       if (from_list == NULL)
     316             :         return NULL;
     317             : 
     318          29 :       results = PyImport_ImportModuleLevel("results", PyEval_GetGlobals(),
     319             :                                            PyEval_GetLocals(), from_list, 1);
     320          29 :       Py_DECREF(from_list);
     321             : 
     322          29 :       if (results == NULL)
     323             :         return NULL;
     324             :     }
     325             : 
     326         321 :   class = PyMapping_GetItemString(PyModule_GetDict(results), classname);
     327         321 :   if (class == NULL)
     328             :     return NULL;
     329             : 
     330         321 :   replacement = PyObject_CallFunctionObjArgs(class, fragile, NULL);
     331         321 :   Py_DECREF(class);
     332             :   return replacement;
     333             : }
     334             : 
     335             : 
     336             : 
     337             : /* Callback support.  */
     338          13 : static gpgme_error_t pyPassphraseCb(void *hook,
     339             :                                     const char *uid_hint,
     340             :                                     const char *passphrase_info,
     341             :                                     int prev_was_bad,
     342             :                                     int fd) {
     343          13 :   PyGILState_STATE state = PyGILState_Ensure();
     344          13 :   PyObject *pyhook = (PyObject *) hook;
     345          13 :   PyObject *self = NULL;
     346          13 :   PyObject *func = NULL;
     347          13 :   PyObject *args = NULL;
     348          13 :   PyObject *retval = NULL;
     349          13 :   PyObject *dataarg = NULL;
     350          13 :   PyObject *encoded = NULL;
     351          13 :   gpgme_error_t err_status = 0;
     352             : 
     353          13 :   _gpg_exception_init();
     354             : 
     355             :   assert (PyTuple_Check(pyhook));
     356             :   assert (PyTuple_Size(pyhook) == 2 || PyTuple_Size(pyhook) == 3);
     357          13 :   self = PyTuple_GetItem(pyhook, 0);
     358          13 :   func = PyTuple_GetItem(pyhook, 1);
     359          13 :   if (PyTuple_Size(pyhook) == 3) {
     360           2 :     dataarg = PyTuple_GetItem(pyhook, 2);
     361           2 :     args = PyTuple_New(4);
     362             :   } else {
     363          11 :     args = PyTuple_New(3);
     364             :   }
     365             : 
     366          13 :   if (uid_hint == NULL)
     367             :     {
     368          11 :       Py_INCREF(Py_None);
     369          11 :       PyTuple_SetItem(args, 0, Py_None);
     370             :     }
     371             :   else
     372           2 :     PyTuple_SetItem(args, 0, PyUnicode_DecodeUTF8(uid_hint, strlen (uid_hint),
     373             :                                                   "strict"));
     374          13 :   if (PyErr_Occurred()) {
     375           0 :     Py_DECREF(args);
     376             :     err_status = gpg_error(GPG_ERR_GENERAL);
     377             :     goto leave;
     378             :   }
     379             : 
     380          13 :   if (passphrase_info == NULL)
     381             :     {
     382           2 :       Py_INCREF(Py_None);
     383           2 :       PyTuple_SetItem(args, 1, Py_None);
     384             :     }
     385             :   else
     386          11 :     PyTuple_SetItem(args, 1, PyUnicode_DecodeUTF8(passphrase_info,
     387          11 :                                                   strlen (passphrase_info),
     388             :                                                   "strict"));
     389          13 :   if (PyErr_Occurred()) {
     390           0 :     Py_DECREF(args);
     391             :     err_status = gpg_error(GPG_ERR_GENERAL);
     392             :     goto leave;
     393             :   }
     394             : 
     395          13 :   PyTuple_SetItem(args, 2, PyBool_FromLong((long)prev_was_bad));
     396          13 :   if (dataarg) {
     397           2 :     Py_INCREF(dataarg);         /* Because GetItem doesn't give a ref but SetItem taketh away */
     398           2 :     PyTuple_SetItem(args, 3, dataarg);
     399             :   }
     400             : 
     401          13 :   retval = PyObject_CallObject(func, args);
     402          13 :   Py_DECREF(args);
     403          13 :   if (PyErr_Occurred()) {
     404           2 :     err_status = _gpg_exception2code();
     405             :   } else {
     406          11 :     if (!retval) {
     407           0 :       if (write(fd, "\n", 1) < 0) {
     408           0 :         err_status = gpgme_error_from_syserror ();
     409           0 :         _gpg_raise_exception (err_status);
     410             :       }
     411             :     } else {
     412             :       char *buf;
     413             :       size_t len;
     414          11 :       if (PyBytes_Check(retval))
     415           3 :         buf = PyBytes_AsString(retval), len = PyBytes_Size(retval);
     416           8 :       else if (PyUnicode_Check(retval))
     417             :         {
     418             :           Py_ssize_t ssize;
     419           7 :           encoded = PyUnicode_AsUTF8String(retval);
     420           7 :           if (encoded == NULL)
     421             :             {
     422             :               err_status = gpg_error(GPG_ERR_GENERAL);
     423           0 :               goto leave;
     424             :             }
     425           7 :           if (PyBytes_AsStringAndSize(encoded, &buf, &ssize) == -1)
     426             :             {
     427             :               err_status = gpg_error(GPG_ERR_GENERAL);
     428             :               goto leave;
     429             :             }
     430             :           assert (! buf || ssize >= 0);
     431           7 :           len = (size_t) ssize;
     432             :         }
     433             :       else
     434             :         {
     435           1 :           PyErr_Format(PyExc_TypeError,
     436             :                        "expected str or bytes from passphrase callback, got %s",
     437             :                        retval->ob_type->tp_name);
     438           1 :           err_status = gpg_error(GPG_ERR_GENERAL);
     439           1 :           goto leave;
     440             :         }
     441             : 
     442          10 :       if (write(fd, buf, len) < 0) {
     443           0 :         err_status = gpgme_error_from_syserror ();
     444           0 :         _gpg_raise_exception (err_status);
     445             :       }
     446          10 :       if (! err_status && write(fd, "\n", 1) < 0) {
     447           0 :         err_status = gpgme_error_from_syserror ();
     448           0 :         _gpg_raise_exception (err_status);
     449             :       }
     450             : 
     451          10 :       Py_DECREF(retval);
     452             :     }
     453             :   }
     454             : 
     455             :  leave:
     456          13 :   if (err_status)
     457           3 :     _gpg_stash_callback_exception(self);
     458             : 
     459          13 :   Py_XDECREF(encoded);
     460          13 :   PyGILState_Release(state);
     461          13 :   return err_status;
     462             : }
     463             : 
     464             : PyObject *
     465         161 : gpg_set_passphrase_cb(PyObject *self, PyObject *cb) {
     466         161 :   PyGILState_STATE state = PyGILState_Ensure();
     467             :   PyObject *wrapped;
     468             :   gpgme_ctx_t ctx;
     469             : 
     470         161 :   wrapped = PyObject_GetAttrString(self, "wrapped");
     471         161 :   if (wrapped == NULL)
     472             :     {
     473             :       assert (PyErr_Occurred ());
     474           0 :       PyGILState_Release(state);
     475           0 :       return NULL;
     476             :     }
     477             : 
     478         161 :   ctx = _gpg_unwrap_gpgme_ctx_t(wrapped);
     479         161 :   Py_DECREF(wrapped);
     480         161 :   if (ctx == NULL)
     481             :     {
     482          56 :       if (cb == Py_None)
     483             :         goto out;
     484             :       else
     485           0 :         return PyErr_Format(PyExc_RuntimeError, "wrapped is NULL");
     486             :     }
     487             : 
     488         105 :   if (cb == Py_None) {
     489          79 :     gpgme_set_passphrase_cb(ctx, NULL, NULL);
     490          79 :     PyObject_SetAttrString(self, "_passphrase_cb", Py_None);
     491          79 :     goto out;
     492             :   }
     493             : 
     494          26 :   if (! PyTuple_Check(cb))
     495           0 :     return PyErr_Format(PyExc_TypeError, "cb must be a tuple");
     496          26 :   if (PyTuple_Size(cb) != 2 && PyTuple_Size(cb) != 3)
     497           0 :     return PyErr_Format(PyExc_TypeError,
     498             :                         "cb must be a tuple of size 2 or 3");
     499             : 
     500          26 :   gpgme_set_passphrase_cb(ctx, (gpgme_passphrase_cb_t) pyPassphraseCb,
     501             :                           (void *) cb);
     502          26 :   PyObject_SetAttrString(self, "_passphrase_cb", cb);
     503             : 
     504             :  out:
     505         161 :   Py_INCREF(Py_None);
     506         161 :   PyGILState_Release(state);
     507         161 :   return Py_None;
     508             : }
     509             : 
     510          41 : static void pyProgressCb(void *hook, const char *what, int type, int current,
     511             :                          int total) {
     512          41 :   PyGILState_STATE state = PyGILState_Ensure();
     513          41 :   PyObject *func = NULL, *dataarg = NULL, *args = NULL, *retval = NULL;
     514          41 :   PyObject *pyhook = (PyObject *) hook;
     515          41 :   PyObject *self = NULL;
     516             : 
     517             :   assert (PyTuple_Check(pyhook));
     518             :   assert (PyTuple_Size(pyhook) == 2 || PyTuple_Size(pyhook) == 3);
     519          41 :   self = PyTuple_GetItem(pyhook, 0);
     520          41 :   func = PyTuple_GetItem(pyhook, 1);
     521          41 :   if (PyTuple_Size(pyhook) == 3) {
     522          14 :     dataarg = PyTuple_GetItem(pyhook, 2);
     523          14 :     args = PyTuple_New(5);
     524             :   } else {
     525          27 :     args = PyTuple_New(4);
     526             :   }
     527             : 
     528          41 :   PyTuple_SetItem(args, 0, PyUnicode_DecodeUTF8(what, strlen (what),
     529             :                                                 "strict"));
     530          41 :   if (PyErr_Occurred()) {
     531           0 :     _gpg_stash_callback_exception(self);
     532           0 :     Py_DECREF(args);
     533           0 :     PyGILState_Release(state);
     534           0 :     return;
     535             :   }
     536          41 :   PyTuple_SetItem(args, 1, PyLong_FromLong((long) type));
     537          41 :   PyTuple_SetItem(args, 2, PyLong_FromLong((long) current));
     538          41 :   PyTuple_SetItem(args, 3, PyLong_FromLong((long) total));
     539          41 :   if (dataarg) {
     540          14 :     Py_INCREF(dataarg);         /* Because GetItem doesn't give a ref but SetItem taketh away */
     541          14 :     PyTuple_SetItem(args, 4, dataarg);
     542             :   }
     543             : 
     544          41 :   retval = PyObject_CallObject(func, args);
     545          41 :   if (PyErr_Occurred())
     546          27 :     _gpg_stash_callback_exception(self);
     547          41 :   Py_DECREF(args);
     548          41 :   Py_XDECREF(retval);
     549          41 :   PyGILState_Release(state);
     550             : }
     551             : 
     552             : PyObject *
     553         137 : gpg_set_progress_cb(PyObject *self, PyObject *cb) {
     554         137 :   PyGILState_STATE state = PyGILState_Ensure();
     555             :   PyObject *wrapped;
     556             :   gpgme_ctx_t ctx;
     557             : 
     558         137 :   wrapped = PyObject_GetAttrString(self, "wrapped");
     559         137 :   if (wrapped == NULL)
     560             :     {
     561             :       assert (PyErr_Occurred ());
     562           0 :       PyGILState_Release(state);
     563           0 :       return NULL;
     564             :     }
     565             : 
     566         137 :   ctx = _gpg_unwrap_gpgme_ctx_t(wrapped);
     567         137 :   Py_DECREF(wrapped);
     568         137 :   if (ctx == NULL)
     569             :     {
     570          56 :       if (cb == Py_None)
     571             :         goto out;
     572             :       else
     573           0 :         return PyErr_Format(PyExc_RuntimeError, "wrapped is NULL");
     574             :     }
     575             : 
     576          81 :   if (cb == Py_None) {
     577          79 :     gpgme_set_progress_cb(ctx, NULL, NULL);
     578          79 :     PyObject_SetAttrString(self, "_progress_cb", Py_None);
     579          79 :     goto out;
     580             :   }
     581             : 
     582           2 :   if (! PyTuple_Check(cb))
     583           0 :     return PyErr_Format(PyExc_TypeError, "cb must be a tuple");
     584           2 :   if (PyTuple_Size(cb) != 2 && PyTuple_Size(cb) != 3)
     585           0 :     return PyErr_Format(PyExc_TypeError,
     586             :                         "cb must be a tuple of size 2 or 3");
     587             : 
     588           2 :   gpgme_set_progress_cb(ctx, (gpgme_progress_cb_t) pyProgressCb, (void *) cb);
     589           2 :   PyObject_SetAttrString(self, "_progress_cb", cb);
     590             : 
     591             :  out:
     592         137 :   Py_INCREF(Py_None);
     593         137 :   PyGILState_Release(state);
     594         137 :   return Py_None;
     595             : }
     596             : 
     597             : /* Status callbacks.  */
     598           5 : static gpgme_error_t pyStatusCb(void *hook, const char *keyword,
     599             :                                 const char *args) {
     600           5 :   PyGILState_STATE state = PyGILState_Ensure();
     601           5 :   gpgme_error_t err = 0;
     602           5 :   PyObject *pyhook = (PyObject *) hook;
     603           5 :   PyObject *self = NULL;
     604           5 :   PyObject *func = NULL;
     605           5 :   PyObject *dataarg = NULL;
     606           5 :   PyObject *pyargs = NULL;
     607           5 :   PyObject *retval = NULL;
     608             : 
     609             :   assert (PyTuple_Check(pyhook));
     610             :   assert (PyTuple_Size(pyhook) == 2 || PyTuple_Size(pyhook) == 3);
     611           5 :   self = PyTuple_GetItem(pyhook, 0);
     612           5 :   func = PyTuple_GetItem(pyhook, 1);
     613           5 :   if (PyTuple_Size(pyhook) == 3) {
     614           4 :     dataarg = PyTuple_GetItem(pyhook, 2);
     615           4 :     pyargs = PyTuple_New(3);
     616             :   } else {
     617           1 :     pyargs = PyTuple_New(2);
     618             :   }
     619             : 
     620           5 :   if (keyword)
     621           5 :     PyTuple_SetItem(pyargs, 0, PyUnicode_DecodeUTF8(keyword, strlen (keyword),
     622             :                                                     "strict"));
     623             :   else
     624             :     {
     625           0 :       Py_INCREF(Py_None);
     626           0 :       PyTuple_SetItem(pyargs, 0, Py_None);
     627             :     }
     628           5 :   PyTuple_SetItem(pyargs, 1, PyUnicode_DecodeUTF8(args, strlen (args),
     629             :                                                 "strict"));
     630           5 :   if (PyErr_Occurred()) {
     631           0 :     err = gpg_error(GPG_ERR_GENERAL);
     632           0 :     Py_DECREF(pyargs);
     633             :     goto leave;
     634             :   }
     635             : 
     636           5 :   if (dataarg) {
     637           4 :     Py_INCREF(dataarg);
     638           4 :     PyTuple_SetItem(pyargs, 2, dataarg);
     639             :   }
     640             : 
     641           5 :   retval = PyObject_CallObject(func, pyargs);
     642           5 :   if (PyErr_Occurred())
     643           1 :     err = _gpg_exception2code();
     644           5 :   Py_DECREF(pyargs);
     645           5 :   Py_XDECREF(retval);
     646             : 
     647             :  leave:
     648           5 :   if (err)
     649           1 :     _gpg_stash_callback_exception(self);
     650           5 :   PyGILState_Release(state);
     651           5 :   return err;
     652             : }
     653             : 
     654             : PyObject *
     655         137 : gpg_set_status_cb(PyObject *self, PyObject *cb) {
     656         137 :   PyGILState_STATE state = PyGILState_Ensure();
     657             :   PyObject *wrapped;
     658             :   gpgme_ctx_t ctx;
     659             : 
     660         137 :   wrapped = PyObject_GetAttrString(self, "wrapped");
     661         137 :   if (wrapped == NULL)
     662             :     {
     663             :       assert (PyErr_Occurred ());
     664           0 :       PyGILState_Release(state);
     665           0 :       return NULL;
     666             :     }
     667             : 
     668         137 :   ctx = _gpg_unwrap_gpgme_ctx_t(wrapped);
     669         137 :   Py_DECREF(wrapped);
     670         137 :   if (ctx == NULL)
     671             :     {
     672          56 :       if (cb == Py_None)
     673             :         goto out;
     674             :       else
     675           0 :         return PyErr_Format(PyExc_RuntimeError, "wrapped is NULL");
     676             :     }
     677             : 
     678          81 :   if (cb == Py_None) {
     679          79 :     gpgme_set_status_cb(ctx, NULL, NULL);
     680          79 :     PyObject_SetAttrString(self, "_status_cb", Py_None);
     681          79 :     goto out;
     682             :   }
     683             : 
     684           2 :   if (! PyTuple_Check(cb))
     685           0 :     return PyErr_Format(PyExc_TypeError, "cb must be a tuple");
     686           2 :   if (PyTuple_Size(cb) != 2 && PyTuple_Size(cb) != 3)
     687           0 :     return PyErr_Format(PyExc_TypeError,
     688             :                         "cb must be a tuple of size 2 or 3");
     689             : 
     690           2 :   gpgme_set_status_cb(ctx, (gpgme_status_cb_t) pyStatusCb, (void *) cb);
     691           2 :   PyObject_SetAttrString(self, "_status_cb", cb);
     692             : 
     693             :  out:
     694         137 :   Py_INCREF(Py_None);
     695         137 :   PyGILState_Release(state);
     696         137 :   return Py_None;
     697             : }
     698             : 
     699             : 
     700             : 
     701             : /* Interact callbacks.  */
     702             : gpgme_error_t
     703          47 : _gpg_interact_cb(void *opaque, const char *keyword,
     704             :                   const char *args, int fd)
     705             : {
     706          47 :   PyGILState_STATE state = PyGILState_Ensure();
     707          47 :   PyObject *func = NULL, *dataarg = NULL, *pyargs = NULL, *retval = NULL;
     708             :   PyObject *py_keyword;
     709          47 :   PyObject *pyopaque = (PyObject *) opaque;
     710          47 :   gpgme_error_t err_status = 0;
     711          47 :   PyObject *self = NULL;
     712             : 
     713          47 :   _gpg_exception_init();
     714             : 
     715             :   assert (PyTuple_Check(pyopaque));
     716             :   assert (PyTuple_Size(pyopaque) == 2 || PyTuple_Size(pyopaque) == 3);
     717          47 :   self = PyTuple_GetItem(pyopaque, 0);
     718          47 :   func = PyTuple_GetItem(pyopaque, 1);
     719          47 :   if (PyTuple_Size(pyopaque) == 3) {
     720          30 :     dataarg = PyTuple_GetItem(pyopaque, 2);
     721          30 :     pyargs = PyTuple_New(3);
     722             :   } else {
     723          17 :     pyargs = PyTuple_New(2);
     724             :   }
     725             : 
     726          47 :   if (keyword)
     727          47 :     py_keyword = PyUnicode_FromString(keyword);
     728             :   else
     729             :     {
     730           0 :       Py_INCREF(Py_None);
     731           0 :       py_keyword = Py_None;
     732             :     }
     733             : 
     734          47 :   PyTuple_SetItem(pyargs, 0, py_keyword);
     735          47 :   PyTuple_SetItem(pyargs, 1, PyUnicode_FromString(args));
     736          47 :   if (dataarg) {
     737          30 :     Py_INCREF(dataarg);         /* Because GetItem doesn't give a ref but SetItem taketh away */
     738          30 :     PyTuple_SetItem(pyargs, 2, dataarg);
     739             :   }
     740             : 
     741          47 :   retval = PyObject_CallObject(func, pyargs);
     742          47 :   Py_DECREF(pyargs);
     743          47 :   if (PyErr_Occurred()) {
     744           1 :     err_status = _gpg_exception2code();
     745             :   } else {
     746          46 :     if (fd>=0 && retval && PyUnicode_Check(retval)) {
     747          19 :       PyObject *encoded = NULL;
     748             :       char *buffer;
     749             :       Py_ssize_t size;
     750             : 
     751          19 :       encoded = PyUnicode_AsUTF8String(retval);
     752          19 :       if (encoded == NULL)
     753             :         {
     754             :           err_status = gpg_error(GPG_ERR_GENERAL);
     755           0 :           goto leave;
     756             :         }
     757          19 :       if (PyBytes_AsStringAndSize(encoded, &buffer, &size) == -1)
     758             :         {
     759           0 :           Py_DECREF(encoded);
     760             :           err_status = gpg_error(GPG_ERR_GENERAL);
     761             :           goto leave;
     762             :         }
     763             : 
     764          19 :       if (write(fd, buffer, size) < 0) {
     765           0 :         err_status = gpgme_error_from_syserror ();
     766           0 :         _gpg_raise_exception (err_status);
     767             :       }
     768          19 :       if (! err_status && write(fd, "\n", 1) < 0) {
     769           0 :         err_status = gpgme_error_from_syserror ();
     770           0 :         _gpg_raise_exception (err_status);
     771             :       }
     772          19 :       Py_DECREF(encoded);
     773             :     }
     774             :   }
     775             :  leave:
     776          47 :   if (err_status)
     777           1 :     _gpg_stash_callback_exception(self);
     778             : 
     779          47 :   Py_XDECREF(retval);
     780          47 :   PyGILState_Release(state);
     781          47 :   return err_status;
     782             : }
     783             : 
     784             : 
     785             : 
     786             : /* Data callbacks.  */
     787             : 
     788             : /* Read up to SIZE bytes into buffer BUFFER from the data object with
     789             :    the handle HOOK.  Return the number of characters read, 0 on EOF
     790             :    and -1 on error.  If an error occurs, errno is set.  */
     791          32 : static ssize_t pyDataReadCb(void *hook, void *buffer, size_t size)
     792             : {
     793          32 :   PyGILState_STATE state = PyGILState_Ensure();
     794             :   ssize_t result;
     795          32 :   PyObject *pyhook = (PyObject *) hook;
     796          32 :   PyObject *self = NULL;
     797          32 :   PyObject *func = NULL;
     798          32 :   PyObject *dataarg = NULL;
     799          32 :   PyObject *pyargs = NULL;
     800          32 :   PyObject *retval = NULL;
     801             : 
     802             :   assert (PyTuple_Check(pyhook));
     803             :   assert (PyTuple_Size(pyhook) == 5 || PyTuple_Size(pyhook) == 6);
     804             : 
     805          32 :   self = PyTuple_GetItem(pyhook, 0);
     806          32 :   func = PyTuple_GetItem(pyhook, 1);
     807          32 :   if (PyTuple_Size(pyhook) == 6) {
     808           3 :     dataarg = PyTuple_GetItem(pyhook, 5);
     809           3 :     pyargs = PyTuple_New(2);
     810             :   } else {
     811          29 :     pyargs = PyTuple_New(1);
     812             :   }
     813             : 
     814          32 :   PyTuple_SetItem(pyargs, 0, PyLong_FromSize_t(size));
     815          32 :   if (dataarg) {
     816           3 :     Py_INCREF(dataarg);
     817           3 :     PyTuple_SetItem(pyargs, 1, dataarg);
     818             :   }
     819             : 
     820          32 :   retval = PyObject_CallObject(func, pyargs);
     821          32 :   Py_DECREF(pyargs);
     822          32 :   if (PyErr_Occurred()) {
     823           1 :     _gpg_stash_callback_exception(self);
     824           1 :     result = -1;
     825           1 :     goto leave;
     826             :   }
     827             : 
     828          31 :   if (! PyBytes_Check(retval)) {
     829           1 :     PyErr_Format(PyExc_TypeError,
     830             :                  "expected bytes from read callback, got %s",
     831             :                  retval->ob_type->tp_name);
     832           1 :     _gpg_stash_callback_exception(self);
     833           1 :     result = -1;
     834           1 :     goto leave;
     835             :   }
     836             : 
     837          30 :   if (PyBytes_Size(retval) > size) {
     838           0 :     PyErr_Format(PyExc_TypeError,
     839             :                  "expected %zu bytes from read callback, got %zu",
     840             :                  size, PyBytes_Size(retval));
     841           0 :     _gpg_stash_callback_exception(self);
     842           0 :     result = -1;
     843           0 :     goto leave;
     844             :   }
     845             : 
     846          30 :   memcpy(buffer, PyBytes_AsString(retval), PyBytes_Size(retval));
     847          30 :   result = PyBytes_Size(retval);
     848             : 
     849             :  leave:
     850          32 :   Py_XDECREF(retval);
     851          32 :   PyGILState_Release(state);
     852          32 :   return result;
     853             : }
     854             : 
     855             : /* Write up to SIZE bytes from buffer BUFFER to the data object with
     856             :    the handle HOOK.  Return the number of characters written, or -1
     857             :    on error.  If an error occurs, errno is set.  */
     858          30 : static ssize_t pyDataWriteCb(void *hook, const void *buffer, size_t size)
     859             : {
     860          30 :   PyGILState_STATE state = PyGILState_Ensure();
     861             :   ssize_t result;
     862          30 :   PyObject *pyhook = (PyObject *) hook;
     863          30 :   PyObject *self = NULL;
     864          30 :   PyObject *func = NULL;
     865          30 :   PyObject *dataarg = NULL;
     866          30 :   PyObject *pyargs = NULL;
     867          30 :   PyObject *retval = NULL;
     868             : 
     869             :   assert (PyTuple_Check(pyhook));
     870             :   assert (PyTuple_Size(pyhook) == 5 || PyTuple_Size(pyhook) == 6);
     871             : 
     872          30 :   self = PyTuple_GetItem(pyhook, 0);
     873          30 :   func = PyTuple_GetItem(pyhook, 2);
     874          30 :   if (PyTuple_Size(pyhook) == 6) {
     875           2 :     dataarg = PyTuple_GetItem(pyhook, 5);
     876           2 :     pyargs = PyTuple_New(2);
     877             :   } else {
     878          28 :     pyargs = PyTuple_New(1);
     879             :   }
     880             : 
     881          30 :   PyTuple_SetItem(pyargs, 0, PyBytes_FromStringAndSize(buffer, size));
     882          30 :   if (dataarg) {
     883           2 :     Py_INCREF(dataarg);
     884           2 :     PyTuple_SetItem(pyargs, 1, dataarg);
     885             :   }
     886             : 
     887          30 :   retval = PyObject_CallObject(func, pyargs);
     888          30 :   Py_DECREF(pyargs);
     889          30 :   if (PyErr_Occurred()) {
     890           1 :     _gpg_stash_callback_exception(self);
     891           1 :     result = -1;
     892           1 :     goto leave;
     893             :   }
     894             : 
     895             : #if PY_MAJOR_VERSION < 3
     896          29 :   if (PyInt_Check(retval))
     897          26 :     result = PyInt_AsSsize_t(retval);
     898             :   else
     899             : #endif
     900           3 :   if (PyLong_Check(retval))
     901           2 :     result = PyLong_AsSsize_t(retval);
     902             :   else {
     903           1 :     PyErr_Format(PyExc_TypeError,
     904             :                  "expected int from write callback, got %s",
     905             :                  retval->ob_type->tp_name);
     906           1 :     _gpg_stash_callback_exception(self);
     907           1 :     result = -1;
     908             :   }
     909             : 
     910             :  leave:
     911          30 :   Py_XDECREF(retval);
     912          30 :   PyGILState_Release(state);
     913          30 :   return result;
     914             : }
     915             : 
     916             : /* Set the current position from where the next read or write starts
     917             :    in the data object with the handle HOOK to OFFSET, relative to
     918             :    WHENCE.  Returns the new offset in bytes from the beginning of the
     919             :    data object.  */
     920           4 : static off_t pyDataSeekCb(void *hook, off_t offset, int whence)
     921             : {
     922           4 :   PyGILState_STATE state = PyGILState_Ensure();
     923             :   off_t result;
     924           4 :   PyObject *pyhook = (PyObject *) hook;
     925           4 :   PyObject *self = NULL;
     926           4 :   PyObject *func = NULL;
     927           4 :   PyObject *dataarg = NULL;
     928           4 :   PyObject *pyargs = NULL;
     929           4 :   PyObject *retval = NULL;
     930             : 
     931             :   assert (PyTuple_Check(pyhook));
     932             :   assert (PyTuple_Size(pyhook) == 5 || PyTuple_Size(pyhook) == 6);
     933             : 
     934           4 :   self = PyTuple_GetItem(pyhook, 0);
     935           4 :   func = PyTuple_GetItem(pyhook, 3);
     936           4 :   if (PyTuple_Size(pyhook) == 6) {
     937           2 :     dataarg = PyTuple_GetItem(pyhook, 5);
     938           2 :     pyargs = PyTuple_New(3);
     939             :   } else {
     940           2 :     pyargs = PyTuple_New(2);
     941             :   }
     942             : 
     943             : #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
     944           4 :   PyTuple_SetItem(pyargs, 0, PyLong_FromLongLong((long long) offset));
     945             : #else
     946             :   PyTuple_SetItem(pyargs, 0, PyLong_FromLong((long) offset));
     947             : #endif
     948           4 :   PyTuple_SetItem(pyargs, 1, PyLong_FromLong((long) whence));
     949           4 :   if (dataarg) {
     950           2 :     Py_INCREF(dataarg);
     951           2 :     PyTuple_SetItem(pyargs, 2, dataarg);
     952             :   }
     953             : 
     954           4 :   retval = PyObject_CallObject(func, pyargs);
     955           4 :   Py_DECREF(pyargs);
     956           4 :   if (PyErr_Occurred()) {
     957           1 :     _gpg_stash_callback_exception(self);
     958           1 :     result = -1;
     959           1 :     goto leave;
     960             :   }
     961             : 
     962             : #if PY_MAJOR_VERSION < 3
     963           3 :   if (PyInt_Check(retval))
     964           0 :     result = PyInt_AsLong(retval);
     965             :   else
     966             : #endif
     967           3 :   if (PyLong_Check(retval))
     968             : #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
     969           2 :     result = PyLong_AsLongLong(retval);
     970             : #else
     971             :     result = PyLong_AsLong(retval);
     972             : #endif
     973             :   else {
     974           1 :     PyErr_Format(PyExc_TypeError,
     975             :                  "expected int from seek callback, got %s",
     976             :                  retval->ob_type->tp_name);
     977           1 :     _gpg_stash_callback_exception(self);
     978           1 :     result = -1;
     979             :   }
     980             : 
     981             :  leave:
     982           4 :   Py_XDECREF(retval);
     983           4 :   PyGILState_Release(state);
     984           4 :   return result;
     985             : }
     986             : 
     987             : /* Close the data object with the handle HOOK.  */
     988           7 : static void pyDataReleaseCb(void *hook)
     989             : {
     990           7 :   PyGILState_STATE state = PyGILState_Ensure();
     991           7 :   PyObject *pyhook = (PyObject *) hook;
     992           7 :   PyObject *self = NULL;
     993           7 :   PyObject *func = NULL;
     994           7 :   PyObject *dataarg = NULL;
     995           7 :   PyObject *pyargs = NULL;
     996           7 :   PyObject *retval = NULL;
     997             : 
     998             :   assert (PyTuple_Check(pyhook));
     999             :   assert (PyTuple_Size(pyhook) == 5 || PyTuple_Size(pyhook) == 6);
    1000             : 
    1001           7 :   self = PyTuple_GetItem(pyhook, 0);
    1002           7 :   func = PyTuple_GetItem(pyhook, 4);
    1003           7 :   if (PyTuple_Size(pyhook) == 6) {
    1004           4 :     dataarg = PyTuple_GetItem(pyhook, 5);
    1005           4 :     pyargs = PyTuple_New(1);
    1006             :   } else {
    1007           3 :     pyargs = PyTuple_New(0);
    1008             :   }
    1009             : 
    1010           7 :   if (dataarg) {
    1011           4 :     Py_INCREF(dataarg);
    1012           4 :     PyTuple_SetItem(pyargs, 0, dataarg);
    1013             :   }
    1014             : 
    1015           7 :   retval = PyObject_CallObject(func, pyargs);
    1016           7 :   Py_XDECREF(retval);
    1017           7 :   Py_DECREF(pyargs);
    1018           7 :   if (PyErr_Occurred())
    1019           0 :     _gpg_stash_callback_exception(self);
    1020           7 :   PyGILState_Release(state);
    1021           7 : }
    1022             : 
    1023             : PyObject *
    1024          10 : gpg_data_new_from_cbs(PyObject *self,
    1025             :                        PyObject *pycbs,
    1026             :                        gpgme_data_t *r_data)
    1027             : {
    1028          10 :   PyGILState_STATE state = PyGILState_Ensure();
    1029             :   static struct gpgme_data_cbs cbs = {
    1030             :     pyDataReadCb,
    1031             :     pyDataWriteCb,
    1032             :     pyDataSeekCb,
    1033             :     pyDataReleaseCb,
    1034             :   };
    1035             :   gpgme_error_t err;
    1036             : 
    1037          10 :   if (! PyTuple_Check(pycbs))
    1038           0 :     return PyErr_Format(PyExc_TypeError, "pycbs must be a tuple");
    1039          10 :   if (PyTuple_Size(pycbs) != 5 && PyTuple_Size(pycbs) != 6)
    1040           0 :     return PyErr_Format(PyExc_TypeError,
    1041             :                         "pycbs must be a tuple of size 5 or 6");
    1042             : 
    1043          10 :   err = gpgme_data_new_from_cbs(r_data, &cbs, (void *) pycbs);
    1044          10 :   if (err)
    1045           0 :     return _gpg_raise_exception(err);
    1046             : 
    1047          10 :   PyObject_SetAttrString(self, "_data_cbs", pycbs);
    1048             : 
    1049          10 :   Py_INCREF(Py_None);
    1050          10 :   PyGILState_Release(state);
    1051          10 :   return Py_None;
    1052             : }
    1053             : 
    1054             : 
    1055             : 
    1056             : /* The assuan callbacks.  */
    1057             : 
    1058             : gpgme_error_t
    1059           2 : _gpg_assuan_data_cb (void *hook, const void *data, size_t datalen)
    1060             : {
    1061           2 :   PyGILState_STATE state = PyGILState_Ensure();
    1062           2 :   gpgme_error_t err = 0;
    1063           2 :   PyObject *pyhook = (PyObject *) hook;
    1064           2 :   PyObject *self = NULL;
    1065           2 :   PyObject *func = NULL;
    1066           2 :   PyObject *py_data = NULL;
    1067           2 :   PyObject *retval = NULL;
    1068             : 
    1069             :   assert (PyTuple_Check(pyhook));
    1070             :   assert (PyTuple_Size(pyhook) == 2);
    1071           2 :   self = PyTuple_GetItem(pyhook, 0);
    1072           2 :   func = PyTuple_GetItem(pyhook, 1);
    1073             :   assert (PyCallable_Check(func));
    1074             : 
    1075           2 :   py_data = PyBytes_FromStringAndSize(data, datalen);
    1076           2 :   if (py_data == NULL)
    1077             :     {
    1078           0 :       err = _gpg_exception2code();
    1079           0 :       goto leave;
    1080             :     }
    1081             : 
    1082           2 :   retval = PyObject_CallFunctionObjArgs(func, py_data, NULL);
    1083           2 :   if (PyErr_Occurred())
    1084           0 :     err = _gpg_exception2code();
    1085           2 :   Py_DECREF(py_data);
    1086           2 :   Py_XDECREF(retval);
    1087             : 
    1088             :  leave:
    1089           2 :   if (err)
    1090           0 :     _gpg_stash_callback_exception(self);
    1091           2 :   PyGILState_Release(state);
    1092           2 :   return err;
    1093             : }
    1094             : 
    1095             : gpgme_error_t
    1096           0 : _gpg_assuan_inquire_cb (void *hook, const char *name, const char *args,
    1097             :                          gpgme_data_t *r_data)
    1098             : {
    1099           0 :   PyGILState_STATE state = PyGILState_Ensure();
    1100           0 :   gpgme_error_t err = 0;
    1101           0 :   PyObject *pyhook = (PyObject *) hook;
    1102           0 :   PyObject *self = NULL;
    1103           0 :   PyObject *func = NULL;
    1104           0 :   PyObject *py_name = NULL;
    1105           0 :   PyObject *py_args = NULL;
    1106           0 :   PyObject *retval = NULL;
    1107             : 
    1108             :   assert (PyTuple_Check(pyhook));
    1109             :   assert (PyTuple_Size(pyhook) == 2);
    1110           0 :   self = PyTuple_GetItem(pyhook, 0);
    1111           0 :   func = PyTuple_GetItem(pyhook, 1);
    1112             :   assert (PyCallable_Check(func));
    1113             : 
    1114           0 :   py_name = PyUnicode_FromString(name);
    1115           0 :   if (py_name == NULL)
    1116             :     {
    1117           0 :       err = _gpg_exception2code();
    1118           0 :       goto leave;
    1119             :     }
    1120             : 
    1121           0 :   py_args = PyUnicode_FromString(args);
    1122           0 :   if (py_args == NULL)
    1123             :     {
    1124           0 :       err = _gpg_exception2code();
    1125           0 :       goto leave;
    1126             :     }
    1127             : 
    1128           0 :   retval = PyObject_CallFunctionObjArgs(func, py_name, py_args, NULL);
    1129           0 :   if (PyErr_Occurred())
    1130           0 :     err = _gpg_exception2code();
    1131           0 :   Py_XDECREF(retval);
    1132             : 
    1133             :   /* FIXME: Returning data is not yet implemented.  */
    1134           0 :   *r_data = NULL;
    1135             : 
    1136             :  leave:
    1137           0 :   Py_XDECREF(py_name);
    1138           0 :   Py_XDECREF(py_args);
    1139           0 :   if (err)
    1140           0 :     _gpg_stash_callback_exception(self);
    1141           0 :   PyGILState_Release(state);
    1142           0 :   return err;
    1143             : }
    1144             : 
    1145             : gpgme_error_t
    1146           1 : _gpg_assuan_status_cb (void *hook, const char *status, const char *args)
    1147             : {
    1148           1 :   PyGILState_STATE state = PyGILState_Ensure();
    1149           1 :   gpgme_error_t err = 0;
    1150           1 :   PyObject *pyhook = (PyObject *) hook;
    1151           1 :   PyObject *self = NULL;
    1152           1 :   PyObject *func = NULL;
    1153           1 :   PyObject *py_status = NULL;
    1154           1 :   PyObject *py_args = NULL;
    1155           1 :   PyObject *retval = NULL;
    1156             : 
    1157             :   assert (PyTuple_Check(pyhook));
    1158             :   assert (PyTuple_Size(pyhook) == 2);
    1159           1 :   self = PyTuple_GetItem(pyhook, 0);
    1160           1 :   func = PyTuple_GetItem(pyhook, 1);
    1161             :   assert (PyCallable_Check(func));
    1162             : 
    1163           1 :   py_status = PyUnicode_FromString(status);
    1164           1 :   if (py_status == NULL)
    1165             :     {
    1166           0 :       err = _gpg_exception2code();
    1167           0 :       goto leave;
    1168             :     }
    1169             : 
    1170           1 :   py_args = PyUnicode_FromString(args);
    1171           1 :   if (py_args == NULL)
    1172             :     {
    1173           0 :       err = _gpg_exception2code();
    1174           0 :       goto leave;
    1175             :     }
    1176             : 
    1177           1 :   retval = PyObject_CallFunctionObjArgs(func, py_status, py_args, NULL);
    1178           1 :   if (PyErr_Occurred())
    1179           0 :     err = _gpg_exception2code();
    1180           1 :   Py_XDECREF(retval);
    1181             : 
    1182             :  leave:
    1183           1 :   Py_XDECREF(py_status);
    1184           1 :   Py_XDECREF(py_args);
    1185           1 :   if (err)
    1186           0 :     _gpg_stash_callback_exception(self);
    1187           1 :   PyGILState_Release(state);
    1188           1 :   return err;
    1189             : }

Generated by: LCOV version 1.13