LCOV - code coverage report
Current view: top level - Objects - capsule.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 59 122 48.4 %
Date: 2023-03-20 08:15:36 Functions: 7 15 46.7 %
Branches: 26 62 41.9 %

           Branch data     Line data    Source code
       1                 :            : /* Wrap void * pointers to be passed between C modules */
       2                 :            : 
       3                 :            : #include "Python.h"
       4                 :            : 
       5                 :            : /* Internal structure of PyCapsule */
       6                 :            : typedef struct {
       7                 :            :     PyObject_HEAD
       8                 :            :     void *pointer;
       9                 :            :     const char *name;
      10                 :            :     void *context;
      11                 :            :     PyCapsule_Destructor destructor;
      12                 :            : } PyCapsule;
      13                 :            : 
      14                 :            : 
      15                 :            : 
      16                 :            : static int
      17                 :      12709 : _is_legal_capsule(PyCapsule *capsule, const char *invalid_capsule)
      18                 :            : {
      19   [ +  -  +  -  :      12709 :     if (!capsule || !PyCapsule_CheckExact(capsule) || capsule->pointer == NULL) {
                   -  + ]
      20                 :          0 :         PyErr_SetString(PyExc_ValueError, invalid_capsule);
      21                 :          0 :         return 0;
      22                 :            :     }
      23                 :      12709 :     return 1;
      24                 :            : }
      25                 :            : 
      26                 :            : #define is_legal_capsule(capsule, name) \
      27                 :            :     (_is_legal_capsule(capsule, \
      28                 :            :      name " called with invalid PyCapsule object"))
      29                 :            : 
      30                 :            : 
      31                 :            : static int
      32                 :      12714 : name_matches(const char *name1, const char *name2) {
      33                 :            :     /* if either is NULL, */
      34   [ +  -  -  + ]:      12714 :     if (!name1 || !name2) {
      35                 :            :         /* they're only the same if they're both NULL. */
      36                 :          0 :         return name1 == name2;
      37                 :            :     }
      38                 :      12714 :     return !strcmp(name1, name2);
      39                 :            : }
      40                 :            : 
      41                 :            : 
      42                 :            : 
      43                 :            : PyObject *
      44                 :       7751 : PyCapsule_New(void *pointer, const char *name, PyCapsule_Destructor destructor)
      45                 :            : {
      46                 :            :     PyCapsule *capsule;
      47                 :            : 
      48         [ -  + ]:       7751 :     if (!pointer) {
      49                 :          0 :         PyErr_SetString(PyExc_ValueError, "PyCapsule_New called with null pointer");
      50                 :          0 :         return NULL;
      51                 :            :     }
      52                 :            : 
      53                 :       7751 :     capsule = PyObject_New(PyCapsule, &PyCapsule_Type);
      54         [ -  + ]:       7751 :     if (capsule == NULL) {
      55                 :          0 :         return NULL;
      56                 :            :     }
      57                 :            : 
      58                 :       7751 :     capsule->pointer = pointer;
      59                 :       7751 :     capsule->name = name;
      60                 :       7751 :     capsule->context = NULL;
      61                 :       7751 :     capsule->destructor = destructor;
      62                 :            : 
      63                 :       7751 :     return (PyObject *)capsule;
      64                 :            : }
      65                 :            : 
      66                 :            : 
      67                 :            : int
      68                 :          5 : PyCapsule_IsValid(PyObject *o, const char *name)
      69                 :            : {
      70                 :          5 :     PyCapsule *capsule = (PyCapsule *)o;
      71                 :            : 
      72         [ +  - ]:          5 :     return (capsule != NULL &&
      73                 :          5 :             PyCapsule_CheckExact(capsule) &&
      74   [ +  -  +  -  :         15 :             capsule->pointer != NULL &&
                   +  - ]
      75                 :          5 :             name_matches(capsule->name, name));
      76                 :            : }
      77                 :            : 
      78                 :            : 
      79                 :            : void *
      80                 :      12709 : PyCapsule_GetPointer(PyObject *o, const char *name)
      81                 :            : {
      82                 :      12709 :     PyCapsule *capsule = (PyCapsule *)o;
      83                 :            : 
      84         [ -  + ]:      12709 :     if (!is_legal_capsule(capsule, "PyCapsule_GetPointer")) {
      85                 :          0 :         return NULL;
      86                 :            :     }
      87                 :            : 
      88         [ -  + ]:      12709 :     if (!name_matches(name, capsule->name)) {
      89                 :          0 :         PyErr_SetString(PyExc_ValueError, "PyCapsule_GetPointer called with incorrect name");
      90                 :          0 :         return NULL;
      91                 :            :     }
      92                 :            : 
      93                 :      12709 :     return capsule->pointer;
      94                 :            : }
      95                 :            : 
      96                 :            : 
      97                 :            : const char *
      98                 :          0 : PyCapsule_GetName(PyObject *o)
      99                 :            : {
     100                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     101                 :            : 
     102         [ #  # ]:          0 :     if (!is_legal_capsule(capsule, "PyCapsule_GetName")) {
     103                 :          0 :         return NULL;
     104                 :            :     }
     105                 :          0 :     return capsule->name;
     106                 :            : }
     107                 :            : 
     108                 :            : 
     109                 :            : PyCapsule_Destructor
     110                 :          0 : PyCapsule_GetDestructor(PyObject *o)
     111                 :            : {
     112                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     113                 :            : 
     114         [ #  # ]:          0 :     if (!is_legal_capsule(capsule, "PyCapsule_GetDestructor")) {
     115                 :          0 :         return NULL;
     116                 :            :     }
     117                 :          0 :     return capsule->destructor;
     118                 :            : }
     119                 :            : 
     120                 :            : 
     121                 :            : void *
     122                 :          0 : PyCapsule_GetContext(PyObject *o)
     123                 :            : {
     124                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     125                 :            : 
     126         [ #  # ]:          0 :     if (!is_legal_capsule(capsule, "PyCapsule_GetContext")) {
     127                 :          0 :         return NULL;
     128                 :            :     }
     129                 :          0 :     return capsule->context;
     130                 :            : }
     131                 :            : 
     132                 :            : 
     133                 :            : int
     134                 :          0 : PyCapsule_SetPointer(PyObject *o, void *pointer)
     135                 :            : {
     136                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     137                 :            : 
     138         [ #  # ]:          0 :     if (!pointer) {
     139                 :          0 :         PyErr_SetString(PyExc_ValueError, "PyCapsule_SetPointer called with null pointer");
     140                 :          0 :         return -1;
     141                 :            :     }
     142                 :            : 
     143         [ #  # ]:          0 :     if (!is_legal_capsule(capsule, "PyCapsule_SetPointer")) {
     144                 :          0 :         return -1;
     145                 :            :     }
     146                 :            : 
     147                 :          0 :     capsule->pointer = pointer;
     148                 :          0 :     return 0;
     149                 :            : }
     150                 :            : 
     151                 :            : 
     152                 :            : int
     153                 :          0 : PyCapsule_SetName(PyObject *o, const char *name)
     154                 :            : {
     155                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     156                 :            : 
     157         [ #  # ]:          0 :     if (!is_legal_capsule(capsule, "PyCapsule_SetName")) {
     158                 :          0 :         return -1;
     159                 :            :     }
     160                 :            : 
     161                 :          0 :     capsule->name = name;
     162                 :          0 :     return 0;
     163                 :            : }
     164                 :            : 
     165                 :            : 
     166                 :            : int
     167                 :          0 : PyCapsule_SetDestructor(PyObject *o, PyCapsule_Destructor destructor)
     168                 :            : {
     169                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     170                 :            : 
     171         [ #  # ]:          0 :     if (!is_legal_capsule(capsule, "PyCapsule_SetDestructor")) {
     172                 :          0 :         return -1;
     173                 :            :     }
     174                 :            : 
     175                 :          0 :     capsule->destructor = destructor;
     176                 :          0 :     return 0;
     177                 :            : }
     178                 :            : 
     179                 :            : 
     180                 :            : int
     181                 :          0 : PyCapsule_SetContext(PyObject *o, void *context)
     182                 :            : {
     183                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     184                 :            : 
     185         [ #  # ]:          0 :     if (!is_legal_capsule(capsule, "PyCapsule_SetContext")) {
     186                 :          0 :         return -1;
     187                 :            :     }
     188                 :            : 
     189                 :          0 :     capsule->context = context;
     190                 :          0 :     return 0;
     191                 :            : }
     192                 :            : 
     193                 :            : 
     194                 :            : void *
     195                 :          5 : PyCapsule_Import(const char *name, int no_block)
     196                 :            : {
     197                 :          5 :     PyObject *object = NULL;
     198                 :          5 :     void *return_value = NULL;
     199                 :            :     char *trace;
     200                 :          5 :     size_t name_length = (strlen(name) + 1) * sizeof(char);
     201                 :          5 :     char *name_dup = (char *)PyMem_Malloc(name_length);
     202                 :            : 
     203         [ -  + ]:          5 :     if (!name_dup) {
     204                 :          0 :         return PyErr_NoMemory();
     205                 :            :     }
     206                 :            : 
     207                 :          5 :     memcpy(name_dup, name, name_length);
     208                 :            : 
     209                 :          5 :     trace = name_dup;
     210         [ +  + ]:         15 :     while (trace) {
     211                 :         10 :         char *dot = strchr(trace, '.');
     212         [ +  + ]:         10 :         if (dot) {
     213                 :          5 :             *dot++ = '\0';
     214                 :            :         }
     215                 :            : 
     216         [ +  + ]:         10 :         if (object == NULL) {
     217                 :          5 :             object = PyImport_ImportModule(trace);
     218         [ -  + ]:          5 :             if (!object) {
     219                 :          0 :                 PyErr_Format(PyExc_ImportError, "PyCapsule_Import could not import module \"%s\"", trace);
     220                 :            :             }
     221                 :            :         } else {
     222                 :          5 :             PyObject *object2 = PyObject_GetAttrString(object, trace);
     223                 :          5 :             Py_SETREF(object, object2);
     224                 :            :         }
     225         [ -  + ]:         10 :         if (!object) {
     226                 :          0 :             goto EXIT;
     227                 :            :         }
     228                 :            : 
     229                 :         10 :         trace = dot;
     230                 :            :     }
     231                 :            : 
     232                 :            :     /* compare attribute name to module.name by hand */
     233         [ +  - ]:          5 :     if (PyCapsule_IsValid(object, name)) {
     234                 :          5 :         PyCapsule *capsule = (PyCapsule *)object;
     235                 :          5 :         return_value = capsule->pointer;
     236                 :            :     } else {
     237                 :          0 :         PyErr_Format(PyExc_AttributeError,
     238                 :            :             "PyCapsule_Import \"%s\" is not valid",
     239                 :            :             name);
     240                 :            :     }
     241                 :            : 
     242                 :          5 : EXIT:
     243                 :          5 :     Py_XDECREF(object);
     244         [ +  - ]:          5 :     if (name_dup) {
     245                 :          5 :         PyMem_Free(name_dup);
     246                 :            :     }
     247                 :          5 :     return return_value;
     248                 :            : }
     249                 :            : 
     250                 :            : 
     251                 :            : static void
     252                 :       7751 : capsule_dealloc(PyObject *o)
     253                 :            : {
     254                 :       7751 :     PyCapsule *capsule = (PyCapsule *)o;
     255         [ +  + ]:       7751 :     if (capsule->destructor) {
     256                 :          6 :         capsule->destructor(o);
     257                 :            :     }
     258                 :       7751 :     PyObject_Free(o);
     259                 :       7751 : }
     260                 :            : 
     261                 :            : 
     262                 :            : static PyObject *
     263                 :          0 : capsule_repr(PyObject *o)
     264                 :            : {
     265                 :          0 :     PyCapsule *capsule = (PyCapsule *)o;
     266                 :            :     const char *name;
     267                 :            :     const char *quote;
     268                 :            : 
     269         [ #  # ]:          0 :     if (capsule->name) {
     270                 :          0 :         quote = "\"";
     271                 :          0 :         name = capsule->name;
     272                 :            :     } else {
     273                 :          0 :         quote = "";
     274                 :          0 :         name = "NULL";
     275                 :            :     }
     276                 :            : 
     277                 :          0 :     return PyUnicode_FromFormat("<capsule object %s%s%s at %p>",
     278                 :            :         quote, name, quote, capsule);
     279                 :            : }
     280                 :            : 
     281                 :            : 
     282                 :            : 
     283                 :            : PyDoc_STRVAR(PyCapsule_Type__doc__,
     284                 :            : "Capsule objects let you wrap a C \"void *\" pointer in a Python\n\
     285                 :            : object.  They're a way of passing data through the Python interpreter\n\
     286                 :            : without creating your own custom type.\n\
     287                 :            : \n\
     288                 :            : Capsules are used for communication between extension modules.\n\
     289                 :            : They provide a way for an extension module to export a C interface\n\
     290                 :            : to other extension modules, so that extension modules can use the\n\
     291                 :            : Python import mechanism to link to one another.\n\
     292                 :            : ");
     293                 :            : 
     294                 :            : PyTypeObject PyCapsule_Type = {
     295                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     296                 :            :     "PyCapsule",                /*tp_name*/
     297                 :            :     sizeof(PyCapsule),          /*tp_basicsize*/
     298                 :            :     0,                          /*tp_itemsize*/
     299                 :            :     /* methods */
     300                 :            :     capsule_dealloc, /*tp_dealloc*/
     301                 :            :     0,                          /*tp_vectorcall_offset*/
     302                 :            :     0,                          /*tp_getattr*/
     303                 :            :     0,                          /*tp_setattr*/
     304                 :            :     0,                          /*tp_as_async*/
     305                 :            :     capsule_repr, /*tp_repr*/
     306                 :            :     0,                          /*tp_as_number*/
     307                 :            :     0,                          /*tp_as_sequence*/
     308                 :            :     0,                          /*tp_as_mapping*/
     309                 :            :     0,                          /*tp_hash*/
     310                 :            :     0,                          /*tp_call*/
     311                 :            :     0,                          /*tp_str*/
     312                 :            :     0,                          /*tp_getattro*/
     313                 :            :     0,                          /*tp_setattro*/
     314                 :            :     0,                          /*tp_as_buffer*/
     315                 :            :     0,                          /*tp_flags*/
     316                 :            :     PyCapsule_Type__doc__       /*tp_doc*/
     317                 :            : };
     318                 :            : 
     319                 :            : 

Generated by: LCOV version 1.14