Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 1 | |
| 2 | /* DBM module using dictionary interface */ |
| 3 | |
| 4 | |
Mark Dickinson | fdaa3a3 | 2009-01-16 19:31:13 +0000 | [diff] [blame] | 5 | #define PY_SSIZE_T_CLEAN |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 6 | #include "Python.h" |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 7 | |
| 8 | #include <sys/types.h> |
| 9 | #include <sys/stat.h> |
| 10 | #include <fcntl.h> |
Fred Drake | d94f707 | 2000-09-14 15:48:06 +0000 | [diff] [blame] | 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(HAVE_NDBM_H) |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 16 | #include <ndbm.h> |
Serhiy Storchaka | 2d06e84 | 2015-12-25 19:53:18 +0200 | [diff] [blame] | 17 | static const char which_dbm[] = "GNU gdbm"; /* EMX port of GDBM */ |
Fred Drake | d94f707 | 2000-09-14 15:48:06 +0000 | [diff] [blame] | 18 | #elif defined(HAVE_GDBM_NDBM_H) |
| 19 | #include <gdbm/ndbm.h> |
Serhiy Storchaka | 2d06e84 | 2015-12-25 19:53:18 +0200 | [diff] [blame] | 20 | static const char which_dbm[] = "GNU gdbm"; |
Skip Montanaro | c1ce286 | 2008-12-06 17:25:02 +0000 | [diff] [blame] | 21 | #elif defined(HAVE_GDBM_DASH_NDBM_H) |
| 22 | #include <gdbm-ndbm.h> |
Serhiy Storchaka | 2d06e84 | 2015-12-25 19:53:18 +0200 | [diff] [blame] | 23 | static const char which_dbm[] = "GNU gdbm"; |
Skip Montanaro | 71ffc5c | 2002-08-02 17:13:01 +0000 | [diff] [blame] | 24 | #elif defined(HAVE_BERKDB_H) |
| 25 | #include <db.h> |
Serhiy Storchaka | 2d06e84 | 2015-12-25 19:53:18 +0200 | [diff] [blame] | 26 | static const char which_dbm[] = "Berkeley DB"; |
Fred Drake | d94f707 | 2000-09-14 15:48:06 +0000 | [diff] [blame] | 27 | #else |
| 28 | #error "No ndbm.h available!" |
| 29 | #endif |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 30 | |
Larry Hastings | 61272b7 | 2014-01-07 12:41:53 -0800 | [diff] [blame] | 31 | /*[clinic input] |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 32 | module _dbm |
| 33 | class _dbm.dbm "dbmobject *" "&Dbmtype" |
Larry Hastings | 61272b7 | 2014-01-07 12:41:53 -0800 | [diff] [blame] | 34 | [clinic start generated code]*/ |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 35 | /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b1aa8756d16150e]*/ |
Larry Hastings | 44e2eaa | 2013-11-23 15:37:55 -0800 | [diff] [blame] | 36 | |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 37 | typedef struct { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 38 | PyObject_HEAD |
| 39 | int di_size; /* -1 means recompute */ |
| 40 | DBM *di_dbm; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 41 | } dbmobject; |
| 42 | |
Serhiy Storchaka | 1009bf1 | 2015-04-03 23:53:51 +0300 | [diff] [blame] | 43 | #include "clinic/_dbmmodule.c.h" |
| 44 | |
Jeremy Hylton | 938ace6 | 2002-07-17 16:30:39 +0000 | [diff] [blame] | 45 | static PyTypeObject Dbmtype; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 46 | |
Christian Heimes | 90aa764 | 2007-12-19 02:45:37 +0000 | [diff] [blame] | 47 | #define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype) |
Guido van Rossum | 77eecfa | 1997-07-17 22:56:01 +0000 | [diff] [blame] | 48 | #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \ |
| 49 | { PyErr_SetString(DbmError, "DBM object has already been closed"); \ |
| 50 | return NULL; } |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 51 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 52 | static PyObject *DbmError; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 53 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 54 | static PyObject * |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 55 | newdbmobject(const char *file, int flags, int mode) |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 56 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 57 | dbmobject *dp; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 58 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 59 | dp = PyObject_New(dbmobject, &Dbmtype); |
| 60 | if (dp == NULL) |
| 61 | return NULL; |
| 62 | dp->di_size = -1; |
Christian Heimes | 8ff6f3e | 2013-12-06 00:20:00 +0100 | [diff] [blame] | 63 | /* See issue #19296 */ |
| 64 | if ( (dp->di_dbm = dbm_open((char *)file, flags, mode)) == 0 ) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 65 | PyErr_SetFromErrno(DbmError); |
| 66 | Py_DECREF(dp); |
| 67 | return NULL; |
| 68 | } |
| 69 | return (PyObject *)dp; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | /* Methods */ |
| 73 | |
| 74 | static void |
Antoine Pitrou | 9ed5f27 | 2013-08-13 20:18:52 +0200 | [diff] [blame] | 75 | dbm_dealloc(dbmobject *dp) |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 76 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 77 | if ( dp->di_dbm ) |
| 78 | dbm_close(dp->di_dbm); |
| 79 | PyObject_Del(dp); |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 80 | } |
| 81 | |
Martin v. Löwis | 18e1655 | 2006-02-15 17:27:45 +0000 | [diff] [blame] | 82 | static Py_ssize_t |
Peter Schneider-Kamp | cb27c35 | 2000-07-10 17:06:38 +0000 | [diff] [blame] | 83 | dbm_length(dbmobject *dp) |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 84 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 85 | if (dp->di_dbm == NULL) { |
| 86 | PyErr_SetString(DbmError, "DBM object has already been closed"); |
| 87 | return -1; |
| 88 | } |
| 89 | if ( dp->di_size < 0 ) { |
| 90 | datum key; |
| 91 | int size; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 92 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 93 | size = 0; |
| 94 | for ( key=dbm_firstkey(dp->di_dbm); key.dptr; |
| 95 | key = dbm_nextkey(dp->di_dbm)) |
| 96 | size++; |
| 97 | dp->di_size = size; |
| 98 | } |
| 99 | return dp->di_size; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 100 | } |
| 101 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 102 | static PyObject * |
Antoine Pitrou | 9ed5f27 | 2013-08-13 20:18:52 +0200 | [diff] [blame] | 103 | dbm_subscript(dbmobject *dp, PyObject *key) |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 104 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 105 | datum drec, krec; |
| 106 | Py_ssize_t tmp_size; |
| 107 | |
| 108 | if (!PyArg_Parse(key, "s#", &krec.dptr, &tmp_size) ) |
| 109 | return NULL; |
| 110 | |
| 111 | krec.dsize = tmp_size; |
| 112 | check_dbmobject_open(dp); |
| 113 | drec = dbm_fetch(dp->di_dbm, krec); |
| 114 | if ( drec.dptr == 0 ) { |
| 115 | PyErr_SetObject(PyExc_KeyError, key); |
| 116 | return NULL; |
| 117 | } |
| 118 | if ( dbm_error(dp->di_dbm) ) { |
| 119 | dbm_clearerr(dp->di_dbm); |
| 120 | PyErr_SetString(DbmError, ""); |
| 121 | return NULL; |
| 122 | } |
| 123 | return PyBytes_FromStringAndSize(drec.dptr, drec.dsize); |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 124 | } |
| 125 | |
| 126 | static int |
Peter Schneider-Kamp | cb27c35 | 2000-07-10 17:06:38 +0000 | [diff] [blame] | 127 | dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w) |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 128 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 129 | datum krec, drec; |
| 130 | Py_ssize_t tmp_size; |
| 131 | |
| 132 | if ( !PyArg_Parse(v, "s#", &krec.dptr, &tmp_size) ) { |
| 133 | PyErr_SetString(PyExc_TypeError, |
| 134 | "dbm mappings have bytes or string keys only"); |
| 135 | return -1; |
| 136 | } |
| 137 | krec.dsize = tmp_size; |
| 138 | if (dp->di_dbm == NULL) { |
| 139 | PyErr_SetString(DbmError, "DBM object has already been closed"); |
| 140 | return -1; |
| 141 | } |
| 142 | dp->di_size = -1; |
| 143 | if (w == NULL) { |
| 144 | if ( dbm_delete(dp->di_dbm, krec) < 0 ) { |
| 145 | dbm_clearerr(dp->di_dbm); |
| 146 | PyErr_SetObject(PyExc_KeyError, v); |
| 147 | return -1; |
Guido van Rossum | 77eecfa | 1997-07-17 22:56:01 +0000 | [diff] [blame] | 148 | } |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 149 | } else { |
| 150 | if ( !PyArg_Parse(w, "s#", &drec.dptr, &tmp_size) ) { |
| 151 | PyErr_SetString(PyExc_TypeError, |
| 152 | "dbm mappings have byte or string elements only"); |
| 153 | return -1; |
| 154 | } |
| 155 | drec.dsize = tmp_size; |
| 156 | if ( dbm_store(dp->di_dbm, krec, drec, DBM_REPLACE) < 0 ) { |
| 157 | dbm_clearerr(dp->di_dbm); |
| 158 | PyErr_SetString(DbmError, |
| 159 | "cannot add item to database"); |
| 160 | return -1; |
| 161 | } |
| 162 | } |
| 163 | if ( dbm_error(dp->di_dbm) ) { |
| 164 | dbm_clearerr(dp->di_dbm); |
| 165 | PyErr_SetString(DbmError, ""); |
| 166 | return -1; |
| 167 | } |
| 168 | return 0; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 169 | } |
| 170 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 171 | static PyMappingMethods dbm_as_mapping = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 172 | (lenfunc)dbm_length, /*mp_length*/ |
| 173 | (binaryfunc)dbm_subscript, /*mp_subscript*/ |
| 174 | (objobjargproc)dbm_ass_sub, /*mp_ass_subscript*/ |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 175 | }; |
| 176 | |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 177 | /*[clinic input] |
| 178 | _dbm.dbm.close |
| 179 | |
| 180 | Close the database. |
| 181 | [clinic start generated code]*/ |
| 182 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 183 | static PyObject * |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 184 | _dbm_dbm_close_impl(dbmobject *self) |
| 185 | /*[clinic end generated code: output=c8dc5b6709600b86 input=046db72377d51be8]*/ |
Guido van Rossum | 807b7be | 1995-07-07 22:37:11 +0000 | [diff] [blame] | 186 | { |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 187 | if (self->di_dbm) |
| 188 | dbm_close(self->di_dbm); |
| 189 | self->di_dbm = NULL; |
Serhiy Storchaka | 228b12e | 2017-01-23 09:47:21 +0200 | [diff] [blame] | 190 | Py_RETURN_NONE; |
Guido van Rossum | 807b7be | 1995-07-07 22:37:11 +0000 | [diff] [blame] | 191 | } |
| 192 | |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 193 | /*[clinic input] |
| 194 | _dbm.dbm.keys |
| 195 | |
| 196 | Return a list of all keys in the database. |
| 197 | [clinic start generated code]*/ |
| 198 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 199 | static PyObject * |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 200 | _dbm_dbm_keys_impl(dbmobject *self) |
| 201 | /*[clinic end generated code: output=434549f7c121b33c input=d210ba778cd9c68a]*/ |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 202 | { |
Antoine Pitrou | 9ed5f27 | 2013-08-13 20:18:52 +0200 | [diff] [blame] | 203 | PyObject *v, *item; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 204 | datum key; |
| 205 | int err; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 206 | |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 207 | check_dbmobject_open(self); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 208 | v = PyList_New(0); |
| 209 | if (v == NULL) |
| 210 | return NULL; |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 211 | for (key = dbm_firstkey(self->di_dbm); key.dptr; |
| 212 | key = dbm_nextkey(self->di_dbm)) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 213 | item = PyBytes_FromStringAndSize(key.dptr, key.dsize); |
| 214 | if (item == NULL) { |
| 215 | Py_DECREF(v); |
| 216 | return NULL; |
| 217 | } |
| 218 | err = PyList_Append(v, item); |
| 219 | Py_DECREF(item); |
| 220 | if (err != 0) { |
| 221 | Py_DECREF(v); |
| 222 | return NULL; |
| 223 | } |
| 224 | } |
| 225 | return v; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 226 | } |
| 227 | |
Guido van Rossum | ef67111 | 2006-08-19 23:11:47 +0000 | [diff] [blame] | 228 | static int |
| 229 | dbm_contains(PyObject *self, PyObject *arg) |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 230 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 231 | dbmobject *dp = (dbmobject *)self; |
| 232 | datum key, val; |
Martin v. Löwis | d63a3b8 | 2011-09-28 07:41:54 +0200 | [diff] [blame] | 233 | Py_ssize_t size; |
Guido van Rossum | ef67111 | 2006-08-19 23:11:47 +0000 | [diff] [blame] | 234 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 235 | if ((dp)->di_dbm == NULL) { |
| 236 | PyErr_SetString(DbmError, |
| 237 | "DBM object has already been closed"); |
| 238 | return -1; |
| 239 | } |
| 240 | if (PyUnicode_Check(arg)) { |
Serhiy Storchaka | 2a404b6 | 2017-01-22 23:07:07 +0200 | [diff] [blame] | 241 | key.dptr = (char *)PyUnicode_AsUTF8AndSize(arg, &size); |
Martin v. Löwis | d63a3b8 | 2011-09-28 07:41:54 +0200 | [diff] [blame] | 242 | key.dsize = size; |
| 243 | if (key.dptr == NULL) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 244 | return -1; |
| 245 | } |
Serhiy Storchaka | 9da33ab | 2013-10-24 23:59:28 +0300 | [diff] [blame] | 246 | else if (!PyBytes_Check(arg)) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 247 | PyErr_Format(PyExc_TypeError, |
Serhiy Storchaka | 9da33ab | 2013-10-24 23:59:28 +0300 | [diff] [blame] | 248 | "dbm key must be bytes or string, not %.100s", |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 249 | arg->ob_type->tp_name); |
| 250 | return -1; |
| 251 | } |
Martin v. Löwis | d63a3b8 | 2011-09-28 07:41:54 +0200 | [diff] [blame] | 252 | else { |
| 253 | key.dptr = PyBytes_AS_STRING(arg); |
| 254 | key.dsize = PyBytes_GET_SIZE(arg); |
| 255 | } |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 256 | val = dbm_fetch(dp->di_dbm, key); |
| 257 | return val.dptr != NULL; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 258 | } |
| 259 | |
Guido van Rossum | ef67111 | 2006-08-19 23:11:47 +0000 | [diff] [blame] | 260 | static PySequenceMethods dbm_as_sequence = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 261 | 0, /* sq_length */ |
| 262 | 0, /* sq_concat */ |
| 263 | 0, /* sq_repeat */ |
| 264 | 0, /* sq_item */ |
| 265 | 0, /* sq_slice */ |
| 266 | 0, /* sq_ass_item */ |
| 267 | 0, /* sq_ass_slice */ |
| 268 | dbm_contains, /* sq_contains */ |
| 269 | 0, /* sq_inplace_concat */ |
| 270 | 0, /* sq_inplace_repeat */ |
Guido van Rossum | ef67111 | 2006-08-19 23:11:47 +0000 | [diff] [blame] | 271 | }; |
| 272 | |
Larry Hastings | 61272b7 | 2014-01-07 12:41:53 -0800 | [diff] [blame] | 273 | /*[clinic input] |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 274 | _dbm.dbm.get |
Larry Hastings | ebdcb50 | 2013-11-23 14:54:00 -0800 | [diff] [blame] | 275 | |
Larry Hastings | 38337d1 | 2015-05-07 23:30:09 -0700 | [diff] [blame] | 276 | key: str(accept={str, robuffer}, zeroes=True) |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 277 | default: object(c_default="NULL") = b'' |
Larry Hastings | ebdcb50 | 2013-11-23 14:54:00 -0800 | [diff] [blame] | 278 | / |
| 279 | |
| 280 | Return the value for key if present, otherwise default. |
Larry Hastings | 61272b7 | 2014-01-07 12:41:53 -0800 | [diff] [blame] | 281 | [clinic start generated code]*/ |
Larry Hastings | ebdcb50 | 2013-11-23 14:54:00 -0800 | [diff] [blame] | 282 | |
Larry Hastings | ebdcb50 | 2013-11-23 14:54:00 -0800 | [diff] [blame] | 283 | static PyObject * |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 284 | _dbm_dbm_get_impl(dbmobject *self, const char *key, |
| 285 | Py_ssize_clean_t key_length, PyObject *default_value) |
Larry Hastings | 38337d1 | 2015-05-07 23:30:09 -0700 | [diff] [blame] | 286 | /*[clinic end generated code: output=b44f95eba8203d93 input=a3a279957f85eb6d]*/ |
| 287 | /*[clinic end generated code: output=4f5c0e523eaf1251 input=9402c0af8582dc69]*/ |
Larry Hastings | ebdcb50 | 2013-11-23 14:54:00 -0800 | [diff] [blame] | 288 | { |
| 289 | datum dbm_key, val; |
| 290 | |
Larry Hastings | ebdcb50 | 2013-11-23 14:54:00 -0800 | [diff] [blame] | 291 | dbm_key.dptr = (char *)key; |
| 292 | dbm_key.dsize = key_length; |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 293 | check_dbmobject_open(self); |
| 294 | val = dbm_fetch(self->di_dbm, dbm_key); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 295 | if (val.dptr != NULL) |
| 296 | return PyBytes_FromStringAndSize(val.dptr, val.dsize); |
Larry Hastings | ebdcb50 | 2013-11-23 14:54:00 -0800 | [diff] [blame] | 297 | |
| 298 | Py_INCREF(default_value); |
| 299 | return default_value; |
Fred Drake | 1ac526d | 2000-09-15 21:35:14 +0000 | [diff] [blame] | 300 | } |
| 301 | |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 302 | /*[clinic input] |
| 303 | _dbm.dbm.setdefault |
Larry Hastings | 38337d1 | 2015-05-07 23:30:09 -0700 | [diff] [blame] | 304 | key: str(accept={str, robuffer}, zeroes=True) |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 305 | default: object(c_default="NULL") = b'' |
| 306 | / |
| 307 | |
| 308 | Return the value for key if present, otherwise default. |
| 309 | |
| 310 | If key is not in the database, it is inserted with default as the value. |
| 311 | [clinic start generated code]*/ |
| 312 | |
Fred Drake | 1ac526d | 2000-09-15 21:35:14 +0000 | [diff] [blame] | 313 | static PyObject * |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 314 | _dbm_dbm_setdefault_impl(dbmobject *self, const char *key, |
| 315 | Py_ssize_clean_t key_length, |
| 316 | PyObject *default_value) |
Larry Hastings | 38337d1 | 2015-05-07 23:30:09 -0700 | [diff] [blame] | 317 | /*[clinic end generated code: output=52545886cf272161 input=bf40c48edaca01d6]*/ |
Fred Drake | 1ac526d | 2000-09-15 21:35:14 +0000 | [diff] [blame] | 318 | { |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 319 | datum dbm_key, val; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 320 | Py_ssize_t tmp_size; |
Fred Drake | 1ac526d | 2000-09-15 21:35:14 +0000 | [diff] [blame] | 321 | |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 322 | dbm_key.dptr = (char *)key; |
| 323 | dbm_key.dsize = key_length; |
| 324 | check_dbmobject_open(self); |
| 325 | val = dbm_fetch(self->di_dbm, dbm_key); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 326 | if (val.dptr != NULL) |
| 327 | return PyBytes_FromStringAndSize(val.dptr, val.dsize); |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 328 | if (default_value == NULL) { |
| 329 | default_value = PyBytes_FromStringAndSize(NULL, 0); |
| 330 | if (default_value == NULL) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 331 | return NULL; |
| 332 | val.dptr = NULL; |
| 333 | val.dsize = 0; |
| 334 | } |
| 335 | else { |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 336 | if ( !PyArg_Parse(default_value, "s#", &val.dptr, &tmp_size) ) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 337 | PyErr_SetString(PyExc_TypeError, |
| 338 | "dbm mappings have byte string elements only"); |
| 339 | return NULL; |
| 340 | } |
| 341 | val.dsize = tmp_size; |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 342 | Py_INCREF(default_value); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 343 | } |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 344 | if (dbm_store(self->di_dbm, dbm_key, val, DBM_INSERT) < 0) { |
| 345 | dbm_clearerr(self->di_dbm); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 346 | PyErr_SetString(DbmError, "cannot add item to database"); |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 347 | Py_DECREF(default_value); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 348 | return NULL; |
| 349 | } |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 350 | return default_value; |
Fred Drake | 1ac526d | 2000-09-15 21:35:14 +0000 | [diff] [blame] | 351 | } |
| 352 | |
Nick Coghlan | c610aba | 2013-11-17 15:59:51 +1000 | [diff] [blame] | 353 | static PyObject * |
| 354 | dbm__enter__(PyObject *self, PyObject *args) |
| 355 | { |
| 356 | Py_INCREF(self); |
| 357 | return self; |
| 358 | } |
| 359 | |
| 360 | static PyObject * |
| 361 | dbm__exit__(PyObject *self, PyObject *args) |
| 362 | { |
| 363 | _Py_IDENTIFIER(close); |
| 364 | return _PyObject_CallMethodId(self, &PyId_close, NULL); |
| 365 | } |
| 366 | |
| 367 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 368 | static PyMethodDef dbm_methods[] = { |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 369 | _DBM_DBM_CLOSE_METHODDEF |
| 370 | _DBM_DBM_KEYS_METHODDEF |
| 371 | _DBM_DBM_GET_METHODDEF |
| 372 | _DBM_DBM_SETDEFAULT_METHODDEF |
Nick Coghlan | c610aba | 2013-11-17 15:59:51 +1000 | [diff] [blame] | 373 | {"__enter__", dbm__enter__, METH_NOARGS, NULL}, |
| 374 | {"__exit__", dbm__exit__, METH_VARARGS, NULL}, |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 375 | {NULL, NULL} /* sentinel */ |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 376 | }; |
| 377 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 378 | static PyTypeObject Dbmtype = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 379 | PyVarObject_HEAD_INIT(NULL, 0) |
| 380 | "_dbm.dbm", |
| 381 | sizeof(dbmobject), |
| 382 | 0, |
| 383 | (destructor)dbm_dealloc, /*tp_dealloc*/ |
| 384 | 0, /*tp_print*/ |
| 385 | 0, /*tp_getattr*/ |
| 386 | 0, /*tp_setattr*/ |
| 387 | 0, /*tp_reserved*/ |
| 388 | 0, /*tp_repr*/ |
| 389 | 0, /*tp_as_number*/ |
| 390 | &dbm_as_sequence, /*tp_as_sequence*/ |
| 391 | &dbm_as_mapping, /*tp_as_mapping*/ |
| 392 | 0, /*tp_hash*/ |
| 393 | 0, /*tp_call*/ |
| 394 | 0, /*tp_str*/ |
| 395 | 0, /*tp_getattro*/ |
| 396 | 0, /*tp_setattro*/ |
| 397 | 0, /*tp_as_buffer*/ |
| 398 | Py_TPFLAGS_DEFAULT, /*tp_flags*/ |
| 399 | 0, /*tp_doc*/ |
| 400 | 0, /*tp_traverse*/ |
| 401 | 0, /*tp_clear*/ |
| 402 | 0, /*tp_richcompare*/ |
| 403 | 0, /*tp_weaklistoffset*/ |
| 404 | 0, /*tp_iter*/ |
| 405 | 0, /*tp_iternext*/ |
| 406 | dbm_methods, /*tp_methods*/ |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 407 | }; |
| 408 | |
| 409 | /* ----------------------------------------------------------------- */ |
| 410 | |
Larry Hastings | 61272b7 | 2014-01-07 12:41:53 -0800 | [diff] [blame] | 411 | /*[clinic input] |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 412 | |
Serhiy Storchaka | 9260e77 | 2015-04-17 21:05:18 +0300 | [diff] [blame] | 413 | _dbm.open as dbmopen |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 414 | |
| 415 | filename: str |
| 416 | The filename to open. |
| 417 | |
| 418 | flags: str="r" |
| 419 | How to open the file. "r" for reading, "w" for writing, etc. |
| 420 | |
Larry Hastings | 2a72791 | 2014-01-16 11:32:01 -0800 | [diff] [blame] | 421 | mode: int(py_default="0o666") = 0o666 |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 422 | If creating a new file, the mode bits for the new file |
| 423 | (e.g. os.O_RDWR). |
| 424 | |
| 425 | / |
| 426 | |
| 427 | Return a database object. |
| 428 | |
Larry Hastings | 61272b7 | 2014-01-07 12:41:53 -0800 | [diff] [blame] | 429 | [clinic start generated code]*/ |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 430 | |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 431 | static PyObject * |
Serhiy Storchaka | 1a2b24f | 2016-07-07 17:35:15 +0300 | [diff] [blame] | 432 | dbmopen_impl(PyObject *module, const char *filename, const char *flags, |
Larry Hastings | 89964c4 | 2015-04-14 18:07:59 -0400 | [diff] [blame] | 433 | int mode) |
Serhiy Storchaka | 1a2b24f | 2016-07-07 17:35:15 +0300 | [diff] [blame] | 434 | /*[clinic end generated code: output=5fade8cf16e0755f input=226334bade5764e6]*/ |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 435 | { |
| 436 | int iflags; |
| 437 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 438 | if ( strcmp(flags, "r") == 0 ) |
| 439 | iflags = O_RDONLY; |
| 440 | else if ( strcmp(flags, "w") == 0 ) |
| 441 | iflags = O_RDWR; |
| 442 | else if ( strcmp(flags, "rw") == 0 ) /* B/W compat */ |
| 443 | iflags = O_RDWR|O_CREAT; |
| 444 | else if ( strcmp(flags, "c") == 0 ) |
| 445 | iflags = O_RDWR|O_CREAT; |
| 446 | else if ( strcmp(flags, "n") == 0 ) |
| 447 | iflags = O_RDWR|O_CREAT|O_TRUNC; |
| 448 | else { |
| 449 | PyErr_SetString(DbmError, |
| 450 | "arg 2 to open should be 'r', 'w', 'c', or 'n'"); |
| 451 | return NULL; |
| 452 | } |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 453 | return newdbmobject(filename, iflags, mode); |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 454 | } |
| 455 | |
Roger E. Masse | b0dfe96 | 1996-12-10 00:07:00 +0000 | [diff] [blame] | 456 | static PyMethodDef dbmmodule_methods[] = { |
Larry Hastings | 3182680 | 2013-10-19 00:09:25 -0700 | [diff] [blame] | 457 | DBMOPEN_METHODDEF |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 458 | { 0, 0 }, |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 459 | }; |
| 460 | |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 461 | |
| 462 | static struct PyModuleDef _dbmmodule = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 463 | PyModuleDef_HEAD_INIT, |
| 464 | "_dbm", |
| 465 | NULL, |
| 466 | -1, |
| 467 | dbmmodule_methods, |
| 468 | NULL, |
| 469 | NULL, |
| 470 | NULL, |
| 471 | NULL |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 472 | }; |
| 473 | |
Mark Hammond | fe51c6d | 2002-08-02 02:27:13 +0000 | [diff] [blame] | 474 | PyMODINIT_FUNC |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 475 | PyInit__dbm(void) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 476 | PyObject *m, *d, *s; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 477 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 478 | if (PyType_Ready(&Dbmtype) < 0) |
| 479 | return NULL; |
| 480 | m = PyModule_Create(&_dbmmodule); |
| 481 | if (m == NULL) |
| 482 | return NULL; |
| 483 | d = PyModule_GetDict(m); |
| 484 | if (DbmError == NULL) |
| 485 | DbmError = PyErr_NewException("_dbm.error", |
Serhiy Storchaka | 55fe1ae | 2017-04-16 10:46:38 +0300 | [diff] [blame] | 486 | PyExc_OSError, NULL); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 487 | s = PyUnicode_FromString(which_dbm); |
| 488 | if (s != NULL) { |
| 489 | PyDict_SetItemString(d, "library", s); |
| 490 | Py_DECREF(s); |
| 491 | } |
| 492 | if (DbmError != NULL) |
| 493 | PyDict_SetItemString(d, "error", DbmError); |
| 494 | if (PyErr_Occurred()) { |
| 495 | Py_DECREF(m); |
| 496 | m = NULL; |
| 497 | } |
| 498 | return m; |
Guido van Rossum | dd9ed83 | 1992-06-29 17:10:40 +0000 | [diff] [blame] | 499 | } |