LCOV - code coverage report
Current view: top level - Modules - _dbmmodule.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 27 229 11.8 %
Date: 2023-03-20 08:15:36 Functions: 6 21 28.6 %
Branches: 12 118 10.2 %

           Branch data     Line data    Source code
       1                 :            : 
       2                 :            : /* DBM module using dictionary interface */
       3                 :            : 
       4                 :            : 
       5                 :            : #define PY_SSIZE_T_CLEAN
       6                 :            : #include "Python.h"
       7                 :            : 
       8                 :            : #include <sys/types.h>
       9                 :            : #include <sys/stat.h>
      10                 :            : #include <fcntl.h>
      11                 :            : 
      12                 :            : /* Some Linux systems install gdbm/ndbm.h, but not ndbm.h.  This supports
      13                 :            :  * whichever configure was able to locate.
      14                 :            :  */
      15                 :            : #if defined(USE_GDBM_COMPAT)
      16                 :            :   #ifdef HAVE_GDBM_NDBM_H
      17                 :            :     #include <gdbm/ndbm.h>
      18                 :            :   #elif HAVE_GDBM_DASH_NDBM_H
      19                 :            :     #include <gdbm-ndbm.h>
      20                 :            :   #else
      21                 :            :     #error "No gdbm/ndbm.h or gdbm-ndbm.h available"
      22                 :            :   #endif
      23                 :            :   static const char which_dbm[] = "GNU gdbm";
      24                 :            : #elif defined(USE_NDBM)
      25                 :            :   #include <ndbm.h>
      26                 :            :   static const char which_dbm[] = "GNU gdbm";
      27                 :            : #elif defined(USE_BERKDB)
      28                 :            :   #ifndef DB_DBM_HSEARCH
      29                 :            :     #define DB_DBM_HSEARCH 1
      30                 :            :   #endif
      31                 :            :   #include <db.h>
      32                 :            :   static const char which_dbm[] = "Berkeley DB";
      33                 :            : #else
      34                 :            :   #error "No ndbm.h available!"
      35                 :            : #endif
      36                 :            : 
      37                 :            : typedef struct {
      38                 :            :     PyTypeObject *dbm_type;
      39                 :            :     PyObject *dbm_error;
      40                 :            : } _dbm_state;
      41                 :            : 
      42                 :            : static inline _dbm_state*
      43                 :         11 : get_dbm_state(PyObject *module)
      44                 :            : {
      45                 :         11 :     void *state = PyModule_GetState(module);
      46                 :            :     assert(state != NULL);
      47                 :         11 :     return (_dbm_state *)state;
      48                 :            : }
      49                 :            : 
      50                 :            : /*[clinic input]
      51                 :            : module _dbm
      52                 :            : class _dbm.dbm "dbmobject *" "&Dbmtype"
      53                 :            : [clinic start generated code]*/
      54                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b1aa8756d16150e]*/
      55                 :            : 
      56                 :            : typedef struct {
      57                 :            :     PyObject_HEAD
      58                 :            :     int flags;
      59                 :            :     int di_size;        /* -1 means recompute */
      60                 :            :     DBM *di_dbm;
      61                 :            : } dbmobject;
      62                 :            : 
      63                 :            : #include "clinic/_dbmmodule.c.h"
      64                 :            : 
      65                 :            : #define check_dbmobject_open(v, err)                                \
      66                 :            :     if ((v)->di_dbm == NULL) {                                      \
      67                 :            :         PyErr_SetString(err, "DBM object has already been closed"); \
      68                 :            :         return NULL;                                                \
      69                 :            :     }
      70                 :            : 
      71                 :            : static PyObject *
      72                 :          0 : newdbmobject(_dbm_state *state, const char *file, int flags, int mode)
      73                 :            : {
      74                 :          0 :     dbmobject *dp = PyObject_GC_New(dbmobject, state->dbm_type);
      75         [ #  # ]:          0 :     if (dp == NULL) {
      76                 :          0 :         return NULL;
      77                 :            :     }
      78                 :          0 :     dp->di_size = -1;
      79                 :          0 :     dp->flags = flags;
      80                 :          0 :     PyObject_GC_Track(dp);
      81                 :            : 
      82                 :            :     /* See issue #19296 */
      83         [ #  # ]:          0 :     if ( (dp->di_dbm = dbm_open((char *)file, flags, mode)) == 0 ) {
      84                 :          0 :         PyErr_SetFromErrnoWithFilename(state->dbm_error, file);
      85                 :          0 :         Py_DECREF(dp);
      86                 :          0 :         return NULL;
      87                 :            :     }
      88                 :          0 :     return (PyObject *)dp;
      89                 :            : }
      90                 :            : 
      91                 :            : /* Methods */
      92                 :            : static int
      93                 :          0 : dbm_traverse(dbmobject *dp, visitproc visit, void *arg)
      94                 :            : {
      95   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(dp));
      96                 :          0 :     return 0;
      97                 :            : }
      98                 :            : 
      99                 :            : static void
     100                 :          0 : dbm_dealloc(dbmobject *dp)
     101                 :            : {
     102                 :          0 :     PyObject_GC_UnTrack(dp);
     103         [ #  # ]:          0 :     if (dp->di_dbm) {
     104                 :          0 :         dbm_close(dp->di_dbm);
     105                 :            :     }
     106                 :          0 :     PyTypeObject *tp = Py_TYPE(dp);
     107                 :          0 :     tp->tp_free(dp);
     108                 :          0 :     Py_DECREF(tp);
     109                 :          0 : }
     110                 :            : 
     111                 :            : static Py_ssize_t
     112                 :          0 : dbm_length(dbmobject *dp)
     113                 :            : {
     114                 :          0 :     _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
     115                 :            :     assert(state != NULL);
     116         [ #  # ]:          0 :     if (dp->di_dbm == NULL) {
     117                 :          0 :              PyErr_SetString(state->dbm_error, "DBM object has already been closed");
     118                 :          0 :              return -1;
     119                 :            :     }
     120         [ #  # ]:          0 :     if ( dp->di_size < 0 ) {
     121                 :            :         datum key;
     122                 :            :         int size;
     123                 :            : 
     124                 :          0 :         size = 0;
     125         [ #  # ]:          0 :         for ( key=dbm_firstkey(dp->di_dbm); key.dptr;
     126                 :          0 :               key = dbm_nextkey(dp->di_dbm))
     127                 :          0 :             size++;
     128                 :          0 :         dp->di_size = size;
     129                 :            :     }
     130                 :          0 :     return dp->di_size;
     131                 :            : }
     132                 :            : 
     133                 :            : static int
     134                 :          0 : dbm_bool(dbmobject *dp)
     135                 :            : {
     136                 :          0 :     _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
     137                 :            :     assert(state != NULL);
     138                 :            : 
     139         [ #  # ]:          0 :     if (dp->di_dbm == NULL) {
     140                 :          0 :         PyErr_SetString(state->dbm_error, "DBM object has already been closed");
     141                 :          0 :         return -1;
     142                 :            :     }
     143                 :            : 
     144         [ #  # ]:          0 :     if (dp->di_size > 0) {
     145                 :            :         /* Known non-zero size. */
     146                 :          0 :         return 1;
     147                 :            :     }
     148         [ #  # ]:          0 :     if (dp->di_size == 0) {
     149                 :            :         /* Known zero size. */
     150                 :          0 :         return 0;
     151                 :            :     }
     152                 :            : 
     153                 :            :     /* Unknown size.  Ensure DBM object has an entry. */
     154                 :          0 :     datum key = dbm_firstkey(dp->di_dbm);
     155         [ #  # ]:          0 :     if (key.dptr == NULL) {
     156                 :            :         /* Empty. Cache this fact. */
     157                 :          0 :         dp->di_size = 0;
     158                 :          0 :         return 0;
     159                 :            :     }
     160                 :            :     /* Non-empty. Don't cache the length since we don't know. */
     161                 :          0 :     return 1;
     162                 :            : }
     163                 :            : 
     164                 :            : static PyObject *
     165                 :          0 : dbm_subscript(dbmobject *dp, PyObject *key)
     166                 :            : {
     167                 :            :     datum drec, krec;
     168                 :            :     Py_ssize_t tmp_size;
     169                 :          0 :     _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
     170                 :            :     assert(state != NULL);
     171         [ #  # ]:          0 :     if (!PyArg_Parse(key, "s#", &krec.dptr, &tmp_size)) {
     172                 :          0 :         return NULL;
     173                 :            :     }
     174                 :            : 
     175                 :          0 :     krec.dsize = tmp_size;
     176         [ #  # ]:          0 :     check_dbmobject_open(dp, state->dbm_error);
     177                 :          0 :     drec = dbm_fetch(dp->di_dbm, krec);
     178         [ #  # ]:          0 :     if ( drec.dptr == 0 ) {
     179                 :          0 :         PyErr_SetObject(PyExc_KeyError, key);
     180                 :          0 :         return NULL;
     181                 :            :     }
     182         [ #  # ]:          0 :     if ( dbm_error(dp->di_dbm) ) {
     183                 :          0 :         dbm_clearerr(dp->di_dbm);
     184                 :          0 :         PyErr_SetString(state->dbm_error, "");
     185                 :          0 :         return NULL;
     186                 :            :     }
     187                 :          0 :     return PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
     188                 :            : }
     189                 :            : 
     190                 :            : static int
     191                 :          0 : dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
     192                 :            : {
     193                 :            :     datum krec, drec;
     194                 :            :     Py_ssize_t tmp_size;
     195                 :            : 
     196         [ #  # ]:          0 :     if ( !PyArg_Parse(v, "s#", &krec.dptr, &tmp_size) ) {
     197                 :          0 :         PyErr_SetString(PyExc_TypeError,
     198                 :            :                         "dbm mappings have bytes or string keys only");
     199                 :          0 :         return -1;
     200                 :            :     }
     201                 :          0 :     _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
     202                 :            :     assert(state != NULL);
     203                 :          0 :     krec.dsize = tmp_size;
     204         [ #  # ]:          0 :     if (dp->di_dbm == NULL) {
     205                 :          0 :              PyErr_SetString(state->dbm_error, "DBM object has already been closed");
     206                 :          0 :              return -1;
     207                 :            :     }
     208                 :          0 :     dp->di_size = -1;
     209         [ #  # ]:          0 :     if (w == NULL) {
     210         [ #  # ]:          0 :         if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
     211                 :          0 :             dbm_clearerr(dp->di_dbm);
     212                 :            :             /* we might get a failure for reasons like file corrupted,
     213                 :            :                but we are not able to distinguish it */
     214         [ #  # ]:          0 :             if (dp->flags & O_RDWR) {
     215                 :          0 :                 PyErr_SetObject(PyExc_KeyError, v);
     216                 :            :             }
     217                 :            :             else {
     218                 :          0 :                 PyErr_SetString(state->dbm_error, "cannot delete item from database");
     219                 :            :             }
     220                 :          0 :             return -1;
     221                 :            :         }
     222                 :            :     } else {
     223         [ #  # ]:          0 :         if ( !PyArg_Parse(w, "s#", &drec.dptr, &tmp_size) ) {
     224                 :          0 :             PyErr_SetString(PyExc_TypeError,
     225                 :            :                  "dbm mappings have bytes or string elements only");
     226                 :          0 :             return -1;
     227                 :            :         }
     228                 :          0 :         drec.dsize = tmp_size;
     229         [ #  # ]:          0 :         if ( dbm_store(dp->di_dbm, krec, drec, DBM_REPLACE) < 0 ) {
     230                 :          0 :             dbm_clearerr(dp->di_dbm);
     231                 :          0 :             PyErr_SetString(state->dbm_error,
     232                 :            :                             "cannot add item to database");
     233                 :          0 :             return -1;
     234                 :            :         }
     235                 :            :     }
     236         [ #  # ]:          0 :     if ( dbm_error(dp->di_dbm) ) {
     237                 :          0 :         dbm_clearerr(dp->di_dbm);
     238                 :          0 :         PyErr_SetString(state->dbm_error, "");
     239                 :          0 :         return -1;
     240                 :            :     }
     241                 :          0 :     return 0;
     242                 :            : }
     243                 :            : 
     244                 :            : /*[clinic input]
     245                 :            : _dbm.dbm.close
     246                 :            : 
     247                 :            : Close the database.
     248                 :            : [clinic start generated code]*/
     249                 :            : 
     250                 :            : static PyObject *
     251                 :          0 : _dbm_dbm_close_impl(dbmobject *self)
     252                 :            : /*[clinic end generated code: output=c8dc5b6709600b86 input=046db72377d51be8]*/
     253                 :            : {
     254         [ #  # ]:          0 :     if (self->di_dbm) {
     255                 :          0 :         dbm_close(self->di_dbm);
     256                 :            :     }
     257                 :          0 :     self->di_dbm = NULL;
     258                 :          0 :     Py_RETURN_NONE;
     259                 :            : }
     260                 :            : 
     261                 :            : /*[clinic input]
     262                 :            : _dbm.dbm.keys
     263                 :            : 
     264                 :            :     cls: defining_class
     265                 :            : 
     266                 :            : Return a list of all keys in the database.
     267                 :            : [clinic start generated code]*/
     268                 :            : 
     269                 :            : static PyObject *
     270                 :          0 : _dbm_dbm_keys_impl(dbmobject *self, PyTypeObject *cls)
     271                 :            : /*[clinic end generated code: output=f2a593b3038e5996 input=d3706a28fc051097]*/
     272                 :            : {
     273                 :            :     PyObject *v, *item;
     274                 :            :     datum key;
     275                 :            :     int err;
     276                 :            : 
     277                 :          0 :     _dbm_state *state = PyType_GetModuleState(cls);
     278                 :            :     assert(state != NULL);
     279         [ #  # ]:          0 :     check_dbmobject_open(self, state->dbm_error);
     280                 :          0 :     v = PyList_New(0);
     281         [ #  # ]:          0 :     if (v == NULL) {
     282                 :          0 :         return NULL;
     283                 :            :     }
     284         [ #  # ]:          0 :     for (key = dbm_firstkey(self->di_dbm); key.dptr;
     285                 :          0 :          key = dbm_nextkey(self->di_dbm)) {
     286                 :          0 :         item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
     287         [ #  # ]:          0 :         if (item == NULL) {
     288                 :          0 :             Py_DECREF(v);
     289                 :          0 :             return NULL;
     290                 :            :         }
     291                 :          0 :         err = PyList_Append(v, item);
     292                 :          0 :         Py_DECREF(item);
     293         [ #  # ]:          0 :         if (err != 0) {
     294                 :          0 :             Py_DECREF(v);
     295                 :          0 :             return NULL;
     296                 :            :         }
     297                 :            :     }
     298                 :          0 :     return v;
     299                 :            : }
     300                 :            : 
     301                 :            : static int
     302                 :          0 : dbm_contains(PyObject *self, PyObject *arg)
     303                 :            : {
     304                 :          0 :     dbmobject *dp = (dbmobject *)self;
     305                 :            :     datum key, val;
     306                 :            :     Py_ssize_t size;
     307                 :            : 
     308                 :          0 :     _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
     309                 :            :     assert(state != NULL);
     310         [ #  # ]:          0 :     if ((dp)->di_dbm == NULL) {
     311                 :          0 :         PyErr_SetString(state->dbm_error,
     312                 :            :                         "DBM object has already been closed");
     313                 :          0 :          return -1;
     314                 :            :     }
     315         [ #  # ]:          0 :     if (PyUnicode_Check(arg)) {
     316                 :          0 :         key.dptr = (char *)PyUnicode_AsUTF8AndSize(arg, &size);
     317                 :          0 :         key.dsize = size;
     318         [ #  # ]:          0 :         if (key.dptr == NULL)
     319                 :          0 :             return -1;
     320                 :            :     }
     321         [ #  # ]:          0 :     else if (!PyBytes_Check(arg)) {
     322                 :          0 :         PyErr_Format(PyExc_TypeError,
     323                 :            :                      "dbm key must be bytes or string, not %.100s",
     324                 :          0 :                      Py_TYPE(arg)->tp_name);
     325                 :          0 :         return -1;
     326                 :            :     }
     327                 :            :     else {
     328                 :          0 :         key.dptr = PyBytes_AS_STRING(arg);
     329                 :          0 :         key.dsize = PyBytes_GET_SIZE(arg);
     330                 :            :     }
     331                 :          0 :     val = dbm_fetch(dp->di_dbm, key);
     332                 :          0 :     return val.dptr != NULL;
     333                 :            : }
     334                 :            : 
     335                 :            : /*[clinic input]
     336                 :            : _dbm.dbm.get
     337                 :            :     cls: defining_class
     338                 :            :     key: str(accept={str, robuffer}, zeroes=True)
     339                 :            :     default: object = None
     340                 :            :     /
     341                 :            : 
     342                 :            : Return the value for key if present, otherwise default.
     343                 :            : [clinic start generated code]*/
     344                 :            : 
     345                 :            : static PyObject *
     346                 :          0 : _dbm_dbm_get_impl(dbmobject *self, PyTypeObject *cls, const char *key,
     347                 :            :                   Py_ssize_t key_length, PyObject *default_value)
     348                 :            : /*[clinic end generated code: output=b4e55f8b6d482bc4 input=66b993b8349fa8c1]*/
     349                 :            : {
     350                 :            :     datum dbm_key, val;
     351                 :          0 :     _dbm_state *state = PyType_GetModuleState(cls);
     352                 :            :     assert(state != NULL);
     353                 :          0 :     dbm_key.dptr = (char *)key;
     354                 :          0 :     dbm_key.dsize = key_length;
     355         [ #  # ]:          0 :     check_dbmobject_open(self, state->dbm_error);
     356                 :          0 :     val = dbm_fetch(self->di_dbm, dbm_key);
     357         [ #  # ]:          0 :     if (val.dptr != NULL) {
     358                 :          0 :         return PyBytes_FromStringAndSize(val.dptr, val.dsize);
     359                 :            :     }
     360                 :            : 
     361                 :          0 :     return Py_NewRef(default_value);
     362                 :            : }
     363                 :            : 
     364                 :            : /*[clinic input]
     365                 :            : _dbm.dbm.setdefault
     366                 :            :     cls: defining_class
     367                 :            :     key: str(accept={str, robuffer}, zeroes=True)
     368                 :            :     default: object(c_default="NULL") = b''
     369                 :            :     /
     370                 :            : 
     371                 :            : Return the value for key if present, otherwise default.
     372                 :            : 
     373                 :            : If key is not in the database, it is inserted with default as the value.
     374                 :            : [clinic start generated code]*/
     375                 :            : 
     376                 :            : static PyObject *
     377                 :          0 : _dbm_dbm_setdefault_impl(dbmobject *self, PyTypeObject *cls, const char *key,
     378                 :            :                          Py_ssize_t key_length, PyObject *default_value)
     379                 :            : /*[clinic end generated code: output=9c2f6ea6d0fb576c input=126a3ff15c5f8232]*/
     380                 :            : {
     381                 :            :     datum dbm_key, val;
     382                 :            :     Py_ssize_t tmp_size;
     383                 :          0 :     _dbm_state *state = PyType_GetModuleState(cls);
     384                 :            :     assert(state != NULL);
     385                 :          0 :     dbm_key.dptr = (char *)key;
     386                 :          0 :     dbm_key.dsize = key_length;
     387         [ #  # ]:          0 :     check_dbmobject_open(self, state->dbm_error);
     388                 :          0 :     val = dbm_fetch(self->di_dbm, dbm_key);
     389         [ #  # ]:          0 :     if (val.dptr != NULL) {
     390                 :          0 :         return PyBytes_FromStringAndSize(val.dptr, val.dsize);
     391                 :            :     }
     392         [ #  # ]:          0 :     if (default_value == NULL) {
     393                 :          0 :         default_value = PyBytes_FromStringAndSize(NULL, 0);
     394         [ #  # ]:          0 :         if (default_value == NULL) {
     395                 :          0 :             return NULL;
     396                 :            :         }
     397                 :          0 :         val.dptr = NULL;
     398                 :          0 :         val.dsize = 0;
     399                 :            :     }
     400                 :            :     else {
     401         [ #  # ]:          0 :         if ( !PyArg_Parse(default_value, "s#", &val.dptr, &tmp_size) ) {
     402                 :          0 :             PyErr_SetString(PyExc_TypeError,
     403                 :            :                 "dbm mappings have bytes or string elements only");
     404                 :          0 :             return NULL;
     405                 :            :         }
     406                 :          0 :         val.dsize = tmp_size;
     407                 :          0 :         Py_INCREF(default_value);
     408                 :            :     }
     409         [ #  # ]:          0 :     if (dbm_store(self->di_dbm, dbm_key, val, DBM_INSERT) < 0) {
     410                 :          0 :         dbm_clearerr(self->di_dbm);
     411                 :          0 :         PyErr_SetString(state->dbm_error, "cannot add item to database");
     412                 :          0 :         Py_DECREF(default_value);
     413                 :          0 :         return NULL;
     414                 :            :     }
     415                 :          0 :     return default_value;
     416                 :            : }
     417                 :            : 
     418                 :            : static PyObject *
     419                 :          0 : dbm__enter__(PyObject *self, PyObject *args)
     420                 :            : {
     421                 :          0 :     return Py_NewRef(self);
     422                 :            : }
     423                 :            : 
     424                 :            : static PyObject *
     425                 :          0 : dbm__exit__(PyObject *self, PyObject *args)
     426                 :            : {
     427                 :          0 :     return _dbm_dbm_close_impl((dbmobject *)self);
     428                 :            : }
     429                 :            : 
     430                 :            : static PyMethodDef dbm_methods[] = {
     431                 :            :     _DBM_DBM_CLOSE_METHODDEF
     432                 :            :     _DBM_DBM_KEYS_METHODDEF
     433                 :            :     _DBM_DBM_GET_METHODDEF
     434                 :            :     _DBM_DBM_SETDEFAULT_METHODDEF
     435                 :            :     {"__enter__", dbm__enter__, METH_NOARGS, NULL},
     436                 :            :     {"__exit__",  dbm__exit__, METH_VARARGS, NULL},
     437                 :            :     {NULL,  NULL}           /* sentinel */
     438                 :            : };
     439                 :            : 
     440                 :            : static PyType_Slot dbmtype_spec_slots[] = {
     441                 :            :     {Py_tp_dealloc, dbm_dealloc},
     442                 :            :     {Py_tp_traverse, dbm_traverse},
     443                 :            :     {Py_tp_methods, dbm_methods},
     444                 :            :     {Py_sq_contains, dbm_contains},
     445                 :            :     {Py_mp_length, dbm_length},
     446                 :            :     {Py_mp_subscript, dbm_subscript},
     447                 :            :     {Py_mp_ass_subscript, dbm_ass_sub},
     448                 :            :     {Py_nb_bool, dbm_bool},
     449                 :            :     {0, 0}
     450                 :            : };
     451                 :            : 
     452                 :            : 
     453                 :            : static PyType_Spec dbmtype_spec = {
     454                 :            :     .name = "_dbm.dbm",
     455                 :            :     .basicsize = sizeof(dbmobject),
     456                 :            :     // Calling PyType_GetModuleState() on a subclass is not safe.
     457                 :            :     // dbmtype_spec does not have Py_TPFLAGS_BASETYPE flag
     458                 :            :     // which prevents to create a subclass.
     459                 :            :     // So calling PyType_GetModuleState() in this file is always safe.
     460                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     461                 :            :               Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
     462                 :            :     .slots = dbmtype_spec_slots,
     463                 :            : };
     464                 :            : 
     465                 :            : /* ----------------------------------------------------------------- */
     466                 :            : 
     467                 :            : /*[clinic input]
     468                 :            : 
     469                 :            : _dbm.open as dbmopen
     470                 :            : 
     471                 :            :     filename: object
     472                 :            :         The filename to open.
     473                 :            : 
     474                 :            :     flags: str="r"
     475                 :            :         How to open the file.  "r" for reading, "w" for writing, etc.
     476                 :            : 
     477                 :            :     mode: int(py_default="0o666") = 0o666
     478                 :            :         If creating a new file, the mode bits for the new file
     479                 :            :         (e.g. os.O_RDWR).
     480                 :            : 
     481                 :            :     /
     482                 :            : 
     483                 :            : Return a database object.
     484                 :            : 
     485                 :            : [clinic start generated code]*/
     486                 :            : 
     487                 :            : static PyObject *
     488                 :          0 : dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
     489                 :            :              int mode)
     490                 :            : /*[clinic end generated code: output=9527750f5df90764 input=d8cf50a9f81218c8]*/
     491                 :            : {
     492                 :            :     int iflags;
     493                 :          0 :     _dbm_state *state =  get_dbm_state(module);
     494                 :            :     assert(state != NULL);
     495         [ #  # ]:          0 :     if (strcmp(flags, "r") == 0) {
     496                 :          0 :         iflags = O_RDONLY;
     497                 :            :     }
     498         [ #  # ]:          0 :     else if (strcmp(flags, "w") == 0) {
     499                 :          0 :         iflags = O_RDWR;
     500                 :            :     }
     501         [ #  # ]:          0 :     else if (strcmp(flags, "rw") == 0) {
     502                 :            :         /* Backward compatibility */
     503                 :          0 :         iflags = O_RDWR|O_CREAT;
     504                 :            :     }
     505         [ #  # ]:          0 :     else if (strcmp(flags, "c") == 0) {
     506                 :          0 :         iflags = O_RDWR|O_CREAT;
     507                 :            :     }
     508         [ #  # ]:          0 :     else if (strcmp(flags, "n") == 0) {
     509                 :          0 :         iflags = O_RDWR|O_CREAT|O_TRUNC;
     510                 :            :     }
     511                 :            :     else {
     512                 :          0 :         PyErr_SetString(state->dbm_error,
     513                 :            :                         "arg 2 to open should be 'r', 'w', 'c', or 'n'");
     514                 :          0 :         return NULL;
     515                 :            :     }
     516                 :            : 
     517                 :            :     PyObject *filenamebytes;
     518         [ #  # ]:          0 :     if (!PyUnicode_FSConverter(filename, &filenamebytes)) {
     519                 :          0 :         return NULL;
     520                 :            :     }
     521                 :            : 
     522                 :          0 :     const char *name = PyBytes_AS_STRING(filenamebytes);
     523         [ #  # ]:          0 :     if (strlen(name) != (size_t)PyBytes_GET_SIZE(filenamebytes)) {
     524                 :          0 :         Py_DECREF(filenamebytes);
     525                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
     526                 :          0 :         return NULL;
     527                 :            :     }
     528                 :          0 :     PyObject *self = newdbmobject(state, name, iflags, mode);
     529                 :          0 :     Py_DECREF(filenamebytes);
     530                 :          0 :     return self;
     531                 :            : }
     532                 :            : 
     533                 :            : static PyMethodDef dbmmodule_methods[] = {
     534                 :            :     DBMOPEN_METHODDEF
     535                 :            :     { 0, 0 },
     536                 :            : };
     537                 :            : 
     538                 :            : static int
     539                 :          1 : _dbm_exec(PyObject *module)
     540                 :            : {
     541                 :          1 :     _dbm_state *state = get_dbm_state(module);
     542                 :          1 :     state->dbm_type = (PyTypeObject *)PyType_FromModuleAndSpec(module,
     543                 :            :                                                         &dbmtype_spec, NULL);
     544         [ -  + ]:          1 :     if (state->dbm_type == NULL) {
     545                 :          0 :         return -1;
     546                 :            :     }
     547                 :          1 :     state->dbm_error = PyErr_NewException("_dbm.error", PyExc_OSError, NULL);
     548         [ -  + ]:          1 :     if (state->dbm_error == NULL) {
     549                 :          0 :         return -1;
     550                 :            :     }
     551         [ -  + ]:          1 :     if (PyModule_AddStringConstant(module, "library", which_dbm) < 0) {
     552                 :          0 :         return -1;
     553                 :            :     }
     554         [ -  + ]:          1 :     if (PyModule_AddType(module, (PyTypeObject *)state->dbm_error) < 0) {
     555                 :          0 :         return -1;
     556                 :            :     }
     557                 :          1 :     return 0;
     558                 :            : }
     559                 :            : 
     560                 :            : static int
     561                 :          8 : _dbm_module_traverse(PyObject *module, visitproc visit, void *arg)
     562                 :            : {
     563                 :          8 :     _dbm_state *state = get_dbm_state(module);
     564   [ +  -  -  + ]:          8 :     Py_VISIT(state->dbm_error);
     565   [ +  -  -  + ]:          8 :     Py_VISIT(state->dbm_type);
     566                 :          8 :     return 0;
     567                 :            : }
     568                 :            : 
     569                 :            : static int
     570                 :          2 : _dbm_module_clear(PyObject *module)
     571                 :            : {
     572                 :          2 :     _dbm_state *state = get_dbm_state(module);
     573         [ +  + ]:          2 :     Py_CLEAR(state->dbm_error);
     574         [ +  + ]:          2 :     Py_CLEAR(state->dbm_type);
     575                 :          2 :     return 0;
     576                 :            : }
     577                 :            : 
     578                 :            : static void
     579                 :          1 : _dbm_module_free(void *module)
     580                 :            : {
     581                 :          1 :     _dbm_module_clear((PyObject *)module);
     582                 :          1 : }
     583                 :            : 
     584                 :            : static PyModuleDef_Slot _dbmmodule_slots[] = {
     585                 :            :     {Py_mod_exec, _dbm_exec},
     586                 :            :     {0, NULL}
     587                 :            : };
     588                 :            : 
     589                 :            : static struct PyModuleDef _dbmmodule = {
     590                 :            :     PyModuleDef_HEAD_INIT,
     591                 :            :     .m_name = "_dbm",
     592                 :            :     .m_size = sizeof(_dbm_state),
     593                 :            :     .m_methods = dbmmodule_methods,
     594                 :            :     .m_slots = _dbmmodule_slots,
     595                 :            :     .m_traverse = _dbm_module_traverse,
     596                 :            :     .m_clear = _dbm_module_clear,
     597                 :            :     .m_free = _dbm_module_free,
     598                 :            : };
     599                 :            : 
     600                 :            : PyMODINIT_FUNC
     601                 :          1 : PyInit__dbm(void)
     602                 :            : {
     603                 :          1 :     return PyModuleDef_Init(&_dbmmodule);
     604                 :            : }

Generated by: LCOV version 1.14