Modules/bsddbmodule.c

   1 /* Berkeley DB interface.
   2    Author: Michael McLay
   3    Hacked: Guido van Rossum
   4    Btree and Recno additions plus sequence methods: David Ely
   5    Hacked by Gustavo Niemeyer <niemeyer@conectiva.com> fixing recno
   6    support.
   7
   8    XXX To do:
   9    - provide a way to access the various hash functions
  10    - support more open flags
  11
  12    The windows port of the Berkeley DB code is hard to find on the web:
  13    www.nightmare.com/software.html
  14 */
  15
  16 #include "Python.h"
  17 #ifdef WITH_THREAD
  18 #include "pythread.h"
  19 #endif
  20
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #ifdef HAVE_DB_185_H
  25 #include <db_185.h>
  26 #else
  27 #include <db.h>
  28 #endif
  29 /* Please don't include internal header files of the Berkeley db package
  30    (it messes up the info required in the Setup file) */
  31
  32 typedef struct {
  33         PyObject_HEAD
  34         DB *di_bsddb;
  35         int di_size;    /* -1 means recompute */
  36         int di_type;
  37 #ifdef WITH_THREAD
  38         PyThread_type_lock di_lock;
  39 #endif
  40 } bsddbobject;
  41
  42 static PyTypeObject Bsddbtype;
  43
  44 #define is_bsddbobject(v) ((v)->ob_type == &Bsddbtype)
  45 #define check_bsddbobject_open(v, r) if ((v)->di_bsddb == NULL) \
  46                { PyErr_SetString(BsddbError, \
  47                                  "BSDDB object has already been closed"); \
  48                  return r; }
  49
  50 static PyObject *BsddbError;
  51
  52 static PyObject *
  53 newdbhashobject(char *file, int flags, int mode,
  54                 int bsize, int ffactor, int nelem, int cachesize,
  55                 int hash, int lorder)
  56 {
  57         bsddbobject *dp;
  58         HASHINFO info;
  59
  60         if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
  61                 return NULL;
  62
  63         info.bsize = bsize;
  64         info.ffactor = ffactor;
  65         info.nelem = nelem;
  66         info.cachesize = cachesize;
  67         info.hash = NULL; /* XXX should derive from hash argument */
  68         info.lorder = lorder;
  69
  70 #ifdef O_BINARY
  71         flags |= O_BINARY;
  72 #endif
  73         Py_BEGIN_ALLOW_THREADS
  74         dp->di_bsddb = dbopen(file, flags, mode, DB_HASH, &info);
  75         Py_END_ALLOW_THREADS
  76         if (dp->di_bsddb == NULL) {
  77                 PyErr_SetFromErrno(BsddbError);
  78 #ifdef WITH_THREAD
  79                 dp->di_lock = NULL;
  80 #endif
  81                 Py_DECREF(dp);
  82                 return NULL;
  83         }
  84
  85         dp->di_size = -1;
  86         dp->di_type = DB_HASH;
  87
  88 #ifdef WITH_THREAD
  89         dp->di_lock = PyThread_allocate_lock();
  90         if (dp->di_lock == NULL) {
  91                 PyErr_SetString(BsddbError, "can't allocate lock");
  92                 Py_DECREF(dp);
  93                 return NULL;
  94         }
  95 #endif
  96
  97         return (PyObject *)dp;
  98 }
  99
 100 static PyObject *
 101 newdbbtobject(char *file, int flags, int mode,
 102               int btflags, int cachesize, int maxkeypage,
 103               int minkeypage, int psize, int lorder)
 104 {
 105         bsddbobject *dp;
 106         BTREEINFO info;
 107
 108         if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
 109                 return NULL;
 110
 111         info.flags = btflags;
 112         info.cachesize = cachesize;
 113         info.maxkeypage = maxkeypage;
 114         info.minkeypage = minkeypage;
 115         info.psize = psize;
 116         info.lorder = lorder;
 117         info.compare = 0; /* Use default comparison functions, for now..*/
 118         info.prefix = 0;
 119
 120 #ifdef O_BINARY
 121         flags |= O_BINARY;
 122 #endif
 123         Py_BEGIN_ALLOW_THREADS
 124         dp->di_bsddb = dbopen(file, flags, mode, DB_BTREE, &info);
 125         Py_END_ALLOW_THREADS
 126         if (dp->di_bsddb == NULL) {
 127                 PyErr_SetFromErrno(BsddbError);
 128 #ifdef WITH_THREAD
 129                 dp->di_lock = NULL;
 130 #endif
 131                 Py_DECREF(dp);
 132                 return NULL;
 133         }
 134
 135         dp->di_size = -1;
 136         dp->di_type = DB_BTREE;
 137
 138 #ifdef WITH_THREAD
 139         dp->di_lock = PyThread_allocate_lock();
 140         if (dp->di_lock == NULL) {
 141                 PyErr_SetString(BsddbError, "can't allocate lock");
 142                 Py_DECREF(dp);
 143                 return NULL;
 144         }
 145 #endif
 146
 147         return (PyObject *)dp;
 148 }
 149
 150 static PyObject *
 151 newdbrnobject(char *file, int flags, int mode,
 152               int rnflags, int cachesize, int psize, int lorder,
 153               size_t reclen, u_char bval, char *bfname)
 154 {
 155         bsddbobject *dp;
 156         RECNOINFO info;
 157         int fd;
 158
 159         if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
 160                 return NULL;
 161
 162         info.flags = rnflags;
 163         info.cachesize = cachesize;
 164         info.psize = psize;
 165         info.lorder = lorder;
 166         info.reclen = reclen;
 167         info.bval = bval;
 168         info.bfname = bfname;
 169
 170 #ifdef O_BINARY
 171         flags |= O_BINARY;
 172 #endif
 173         /* This is a hack to avoid a dbopen() bug that happens when
 174          * it fails. */
 175         fd = open(file, flags);
 176         if (fd == -1) {
 177                 dp->di_bsddb = NULL;
 178         }
 179         else {
 180                 close(fd);
 181                 Py_BEGIN_ALLOW_THREADS
 182                 dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info);
 183                 Py_END_ALLOW_THREADS
 184         }
 185         if (dp->di_bsddb == NULL) {
 186                 PyErr_SetFromErrno(BsddbError);
 187 #ifdef WITH_THREAD
 188                 dp->di_lock = NULL;
 189 #endif
 190                 Py_DECREF(dp);
 191                 return NULL;
 192         }
 193
 194         dp->di_size = -1;
 195         dp->di_type = DB_RECNO;
 196
 197 #ifdef WITH_THREAD
 198         dp->di_lock = PyThread_allocate_lock();
 199         if (dp->di_lock == NULL) {
 200                 PyErr_SetString(BsddbError, "can't allocate lock");
 201                 Py_DECREF(dp);
 202                 return NULL;
 203         }
 204 #endif
 205
 206         return (PyObject *)dp;
 207 }
 208
 209 static void
 210 bsddb_dealloc(bsddbobject *dp)
 211 {
 212 #ifdef WITH_THREAD
 213         if (dp->di_lock) {
 214                 PyThread_acquire_lock(dp->di_lock, 0);
 215                 PyThread_release_lock(dp->di_lock);
 216                 PyThread_free_lock(dp->di_lock);
 217                 dp->di_lock = NULL;
 218         }
 219 #endif
 220         if (dp->di_bsddb != NULL) {
 221                 int status;
 222                 Py_BEGIN_ALLOW_THREADS
 223                 status = (dp->di_bsddb->close)(dp->di_bsddb);
 224                 Py_END_ALLOW_THREADS
 225                 if (status != 0)
 226                         fprintf(stderr,
 227                                 "Python bsddb: close errno %d in dealloc\n",
 228                                 errno);
 229         }
 230         PyObject_Del(dp);
 231 }
 232
 233 #ifdef WITH_THREAD
 234 #define BSDDB_BGN_SAVE(_dp) \
 235         Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_dp->di_lock,1);
 236 #define BSDDB_END_SAVE(_dp) \
 237         PyThread_release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
 238 #else
 239 #define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS
 240 #define BSDDB_END_SAVE(_dp) Py_END_ALLOW_THREADS
 241 #endif
 242
 243 static Py_ssize_t
 244 bsddb_length(bsddbobject *dp)
 245 {
 246         check_bsddbobject_open(dp, -1);
 247         if (dp->di_size < 0) {
 248                 DBT krec, drec;
 249                 int status;
 250                 int size = 0;
 251                 BSDDB_BGN_SAVE(dp)
 252                 for (status = (dp->di_bsddb->seq)(dp->di_bsddb,
 253                                                   &krec, &drec,R_FIRST);
 254                      status == 0;
 255                      status = (dp->di_bsddb->seq)(dp->di_bsddb,
 256                                                   &krec, &drec, R_NEXT))
 257                         size++;
 258                 BSDDB_END_SAVE(dp)
 259                 if (status < 0) {
 260                         PyErr_SetFromErrno(BsddbError);
 261                         return -1;
 262                 }
 263                 dp->di_size = size;
 264         }
 265         return dp->di_size;
 266 }
 267
 268 static PyObject *
 269 bsddb_subscript(bsddbobject *dp, PyObject *key)
 270 {
 271         int status;
 272         DBT krec, drec;
 273         char *data,buf[4096];
 274         int size;
 275         PyObject *result;
 276         recno_t recno;
 277
 278         if (dp->di_type == DB_RECNO) {
 279                 if (!PyArg_Parse(key, "i", &recno)) {
 280                         PyErr_SetString(PyExc_TypeError,
 281                                         "key type must be integer");
 282                         return NULL;
 283                 }
 284                 krec.data = &recno;
 285                 krec.size = sizeof(recno);
 286         }
 287         else {
 288                 if (!PyArg_Parse(key, "s#", &data, &size)) {
 289                         PyErr_SetString(PyExc_TypeError,
 290                                         "key type must be string");
 291                         return NULL;
 292                 }
 293                 krec.data = data;
 294                 krec.size = size;
 295         }
 296         check_bsddbobject_open(dp, NULL);
 297
 298         BSDDB_BGN_SAVE(dp)
 299         status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
 300         if (status == 0) {
 301                 if (drec.size > sizeof(buf)) data = malloc(drec.size);
 302                 else data = buf;
 303                 if (data!=NULL) memcpy(data,drec.data,drec.size);
 304         }
 305         BSDDB_END_SAVE(dp)
 306         if (data==NULL) return PyErr_NoMemory();
 307         if (status != 0) {
 308                 if (status < 0)
 309                         PyErr_SetFromErrno(BsddbError);
 310                 else
 311                         PyErr_SetObject(PyExc_KeyError, key);
 312                 return NULL;
 313         }
 314
 315         result = PyString_FromStringAndSize(data, (int)drec.size);
 316         if (data != buf) free(data);
 317         return result;
 318 }
 319
 320 static int
 321 bsddb_ass_sub(bsddbobject *dp, PyObject *key, PyObject *value)
 322 {
 323         int status;
 324         DBT krec, drec;
 325         char *data;
 326         int size;
 327         recno_t recno;
 328
 329         if (dp->di_type == DB_RECNO) {
 330                 if (!PyArg_Parse(key, "i", &recno)) {
 331                         PyErr_SetString(PyExc_TypeError,
 332                                         "bsddb key type must be integer");
 333                         return -1;
 334                 }
 335                 krec.data = &recno;
 336                 krec.size = sizeof(recno);
 337         }
 338         else {
 339                 if (!PyArg_Parse(key, "s#", &data, &size)) {
 340                         PyErr_SetString(PyExc_TypeError,
 341                                         "bsddb key type must be string");
 342                         return -1;
 343                 }
 344                 krec.data = data;
 345                 krec.size = size;
 346         }
 347         check_bsddbobject_open(dp, -1);
 348         dp->di_size = -1;
 349         if (value == NULL) {
 350                 BSDDB_BGN_SAVE(dp)
 351                 status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0);
 352                 BSDDB_END_SAVE(dp)
 353         }
 354         else {
 355                 if (!PyArg_Parse(value, "s#", &data, &size)) {
 356                         PyErr_SetString(PyExc_TypeError,
 357                                         "bsddb value type must be string");
 358                         return -1;
 359                 }
 360                 drec.data = data;
 361                 drec.size = size;
 362                 BSDDB_BGN_SAVE(dp)
 363                 status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0);
 364                 BSDDB_END_SAVE(dp)
 365         }
 366         if (status != 0) {
 367                 if (status < 0)
 368                         PyErr_SetFromErrno(BsddbError);
 369                 else
 370                         PyErr_SetObject(PyExc_KeyError, key);
 371                 return -1;
 372         }
 373         return 0;
 374 }
 375
 376 static PyMappingMethods bsddb_as_mapping = {
 377         (lenfunc)bsddb_length,          /*mp_length*/
 378         (binaryfunc)bsddb_subscript,    /*mp_subscript*/
 379         (objobjargproc)bsddb_ass_sub,   /*mp_ass_subscript*/
 380 };
 381
 382 static PyObject *
 383 bsddb_close(bsddbobject *dp)
 384 {
 385         if (dp->di_bsddb != NULL) {
 386                 int status;
 387                 BSDDB_BGN_SAVE(dp)
 388                 status = (dp->di_bsddb->close)(dp->di_bsddb);
 389                 BSDDB_END_SAVE(dp)
 390                 if (status != 0) {
 391                         dp->di_bsddb = NULL;
 392                         PyErr_SetFromErrno(BsddbError);
 393                         return NULL;
 394                 }
 395         }
 396         dp->di_bsddb = NULL;
 397         Py_INCREF(Py_None);
 398         return Py_None;
 399 }
 400
 401 static PyObject *
 402 bsddb_keys(bsddbobject *dp)
 403 {
 404         PyObject *list, *item=NULL;
 405         DBT krec, drec;
 406         char *data=NULL,buf[4096];
 407         int status;
 408         int err;
 409
 410         check_bsddbobject_open(dp, NULL);
 411         list = PyList_New(0);
 412         if (list == NULL)
 413                 return NULL;
 414         BSDDB_BGN_SAVE(dp)
 415         status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST);
 416         if (status == 0) {
 417                 if (krec.size > sizeof(buf)) data = malloc(krec.size);
 418                 else data = buf;
 419                 if (data != NULL) memcpy(data,krec.data,krec.size);
 420         }
 421         BSDDB_END_SAVE(dp)
 422         if (status == 0 && data==NULL) return PyErr_NoMemory();
 423         while (status == 0) {
 424                 if (dp->di_type == DB_RECNO)
 425                         item = PyInt_FromLong(*((int*)data));
 426                 else
 427                         item = PyString_FromStringAndSize(data,
 428                                                           (int)krec.size);
 429                 if (data != buf) free(data);
 430                 if (item == NULL) {
 431                         Py_DECREF(list);
 432                         return NULL;
 433                 }
 434                 err = PyList_Append(list, item);
 435                 Py_DECREF(item);
 436                 if (err != 0) {
 437                         Py_DECREF(list);
 438                         return NULL;
 439                 }
 440                 BSDDB_BGN_SAVE(dp)
 441                 status = (dp->di_bsddb->seq)
 442                         (dp->di_bsddb, &krec, &drec, R_NEXT);
 443                 if (status == 0) {
 444                         if (krec.size > sizeof(buf))
 445                                 data = malloc(krec.size);
 446                         else data = buf;
 447                         if (data != NULL)
 448                                 memcpy(data,krec.data,krec.size);
 449                 }
 450                 BSDDB_END_SAVE(dp)
 451                 if (data == NULL) return PyErr_NoMemory();
 452         }
 453         if (status < 0) {
 454                 PyErr_SetFromErrno(BsddbError);
 455                 Py_DECREF(list);
 456                 return NULL;
 457         }
 458         if (dp->di_size < 0)
 459                 dp->di_size = PyList_Size(list); /* We just did the work */
 460         return list;
 461 }
 462
 463 static PyObject *
 464 bsddb_has_key(bsddbobject *dp, PyObject *args)
 465 {
 466         DBT krec, drec;
 467         int status;
 468         char *data;
 469         int size;
 470         recno_t recno;
 471
 472         if (dp->di_type == DB_RECNO) {
 473                 if (!PyArg_ParseTuple(args, "i;key type must be integer",
 474                                       &recno)) {
 475                         return NULL;
 476                 }
 477                 krec.data = &recno;
 478                 krec.size = sizeof(recno);
 479         }
 480         else {
 481                 if (!PyArg_ParseTuple(args, "s#;key type must be string",
 482                                       &data, &size)) {
 483                         return NULL;
 484                 }
 485                 krec.data = data;
 486                 krec.size = size;
 487         }
 488         check_bsddbobject_open(dp, NULL);
 489
 490         BSDDB_BGN_SAVE(dp)
 491         status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
 492         BSDDB_END_SAVE(dp)
 493         if (status < 0) {
 494                 PyErr_SetFromErrno(BsddbError);
 495                 return NULL;
 496         }
 497
 498         return PyInt_FromLong(status == 0);
 499 }
 500
 501 static PyObject *
 502 bsddb_set_location(bsddbobject *dp, PyObject *key)
 503 {
 504         int status;
 505         DBT krec, drec;
 506         char *data,buf[4096];
 507         int size;
 508         PyObject *result;
 509         recno_t recno;
 510
 511         if (dp->di_type == DB_RECNO) {
 512                 if (!PyArg_ParseTuple(key, "i;key type must be integer",
 513                                       &recno)) {
 514                         return NULL;
 515                 }
 516                 krec.data = &recno;
 517                 krec.size = sizeof(recno);
 518         }
 519         else {
 520                 if (!PyArg_ParseTuple(key, "s#;key type must be string",
 521                                       &data, &size)) {
 522                         return NULL;
 523                 }
 524                 krec.data = data;
 525                 krec.size = size;
 526         }
 527         check_bsddbobject_open(dp, NULL);
 528
 529         BSDDB_BGN_SAVE(dp)
 530         status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR);
 531         if (status == 0) {
 532                 if (drec.size > sizeof(buf)) data = malloc(drec.size);
 533                 else data = buf;
 534                 if (data!=NULL) memcpy(data,drec.data,drec.size);
 535         }
 536         BSDDB_END_SAVE(dp)
 537         if (data==NULL) return PyErr_NoMemory();
 538         if (status != 0) {
 539                 if (status < 0)
 540                         PyErr_SetFromErrno(BsddbError);
 541                 else
 542                         PyErr_SetObject(PyExc_KeyError, key);
 543                 return NULL;
 544         }
 545
 546         if (dp->di_type == DB_RECNO)
 547                 result = Py_BuildValue("is#", *((int*)krec.data),
 548                                        data, drec.size);
 549         else
 550                 result = Py_BuildValue("s#s#", krec.data, krec.size,
 551                                        data, drec.size);
 552         if (data != buf) free(data);
 553         return result;
 554 }
 555
 556 static PyObject *
 557 bsddb_seq(bsddbobject *dp, int sequence_request)
 558 {
 559         int status;
 560         DBT krec, drec;
 561         char *kdata=NULL,kbuf[4096];
 562         char *ddata=NULL,dbuf[4096];
 563         PyObject *result;
 564
 565         check_bsddbobject_open(dp, NULL);
 566         krec.data = 0;
 567         krec.size = 0;
 568
 569         BSDDB_BGN_SAVE(dp)
 570         status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec,
 571                                      &drec, sequence_request);
 572         if (status == 0) {
 573                 if (krec.size > sizeof(kbuf)) kdata = malloc(krec.size);
 574                 else kdata = kbuf;
 575                 if (kdata != NULL) memcpy(kdata,krec.data,krec.size);
 576                 if (drec.size > sizeof(dbuf)) ddata = malloc(drec.size);
 577                 else ddata = dbuf;
 578                 if (ddata != NULL) memcpy(ddata,drec.data,drec.size);
 579         }
 580         BSDDB_END_SAVE(dp)
 581         if (status == 0) {
 582                 if ((kdata == NULL) || (ddata == NULL))
 583                         return PyErr_NoMemory();
 584         }
 585         else {
 586                 /* (status != 0) */
 587                 if (status < 0)
 588                         PyErr_SetFromErrno(BsddbError);
 589                 else
 590                         PyErr_SetString(PyExc_KeyError, "no key/data pairs");
 591                 return NULL;
 592         }
 593
 594         if (dp->di_type == DB_RECNO)
 595                 result = Py_BuildValue("is#", *((int*)kdata),
 596                                        ddata, drec.size);
 597         else
 598                 result = Py_BuildValue("s#s#", kdata, krec.size,
 599                                        ddata, drec.size);
 600         if (kdata != kbuf) free(kdata);
 601         if (ddata != dbuf) free(ddata);
 602         return result;
 603 }
 604
 605 static PyObject *
 606 bsddb_next(bsddbobject *dp)
 607 {
 608         return bsddb_seq(dp, R_NEXT);
 609 }
 610 static PyObject *
 611 bsddb_previous(bsddbobject *dp)
 612 {
 613         return bsddb_seq(dp, R_PREV);
 614 }
 615 static PyObject *
 616 bsddb_first(bsddbobject *dp)
 617 {
 618         return bsddb_seq(dp, R_FIRST);
 619 }
 620 static PyObject *
 621 bsddb_last(bsddbobject *dp)
 622 {
 623         return bsddb_seq(dp, R_LAST);
 624 }
 625 static PyObject *
 626 bsddb_sync(bsddbobject *dp)
 627 {
 628         int status;
 629
 630         check_bsddbobject_open(dp, NULL);
 631         BSDDB_BGN_SAVE(dp)
 632         status = (dp->di_bsddb->sync)(dp->di_bsddb, 0);
 633         BSDDB_END_SAVE(dp)
 634         if (status != 0) {
 635                 PyErr_SetFromErrno(BsddbError);
 636                 return NULL;
 637         }
 638         return PyInt_FromLong(status = 0);
 639 }
 640 static PyMethodDef bsddb_methods[] = {
 641         {"close",               (PyCFunction)bsddb_close, METH_NOARGS},
 642         {"keys",                (PyCFunction)bsddb_keys, METH_NOARGS},
 643         {"has_key",             (PyCFunction)bsddb_has_key, METH_VARARGS},
 644         {"set_location",        (PyCFunction)bsddb_set_location, METH_VARARGS},
 645         {"next",                (PyCFunction)bsddb_next, METH_NOARGS},
 646         {"previous",    (PyCFunction)bsddb_previous, METH_NOARGS},
 647         {"first",               (PyCFunction)bsddb_first, METH_NOARGS},
 648         {"last",                (PyCFunction)bsddb_last, METH_NOARGS},
 649         {"sync",                (PyCFunction)bsddb_sync, METH_NOARGS},
 650         {NULL,          NULL}           /* sentinel */
 651 };
 652
 653 static PyObject *
 654 bsddb_getattr(PyObject *dp, char *name)
 655 {
 656         return Py_FindMethod(bsddb_methods, dp, name);
 657 }
 658
 659 static PyTypeObject Bsddbtype = {
 660         PyObject_HEAD_INIT(NULL)
 661         0,
 662         "bsddb.bsddb",
 663         sizeof(bsddbobject),
 664         0,
 665         (destructor)bsddb_dealloc, /*tp_dealloc*/
 666         0,                      /*tp_print*/
 667         (getattrfunc)bsddb_getattr, /*tp_getattr*/
 668         0,                      /*tp_setattr*/
 669         0,                      /*tp_compare*/
 670         0,                      /*tp_repr*/
 671         0,                      /*tp_as_number*/
 672         0,                      /*tp_as_sequence*/
 673         &bsddb_as_mapping,      /*tp_as_mapping*/
 674 };
 675
 676 static PyObject *
 677 bsdhashopen(PyObject *self, PyObject *args)
 678 {
 679         char *file;
 680         char *flag = NULL;
 681         int flags = O_RDONLY;
 682         int mode = 0666;
 683         int bsize = 0;
 684         int ffactor = 0;
 685         int nelem = 0;
 686         int cachesize = 0;
 687         int hash = 0; /* XXX currently ignored */
 688         int lorder = 0;
 689
 690         if (!PyArg_ParseTuple(args, "z|siiiiiii:hashopen",
 691                               &file, &flag, &mode,
 692                               &bsize, &ffactor, &nelem, &cachesize,
 693                               &hash, &lorder))
 694                 return NULL;
 695         if (flag != NULL) {
 696                 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
 697                 if (flag[0] == 'r')
 698                         flags = O_RDONLY;
 699                 else if (flag[0] == 'w')
 700                         flags = O_RDWR;
 701                 else if (flag[0] == 'c')
 702                         flags = O_RDWR|O_CREAT;
 703                 else if (flag[0] == 'n')
 704                         flags = O_RDWR|O_CREAT|O_TRUNC;
 705                 else {
 706                         PyErr_SetString(BsddbError,
 707                                 "Flag should begin with 'r', 'w', 'c' or 'n'");
 708                         return NULL;
 709                 }
 710                 if (flag[1] == 'l') {
 711 #if defined(O_EXLOCK) && defined(O_SHLOCK)
 712                         if (flag[0] == 'r')
 713                                 flags |= O_SHLOCK;
 714                         else
 715                                 flags |= O_EXLOCK;
 716 #else
 717                         PyErr_SetString(BsddbError,
 718                                      "locking not supported on this platform");
 719                         return NULL;
 720 #endif
 721                 }
 722         }
 723         return newdbhashobject(file, flags, mode,
 724                                bsize, ffactor, nelem, cachesize, hash, lorder);
 725 }
 726
 727 static PyObject *
 728 bsdbtopen(PyObject *self, PyObject *args)
 729 {
 730         char *file;
 731         char *flag = NULL;
 732         int flags = O_RDONLY;
 733         int mode = 0666;
 734         int cachesize = 0;
 735         int maxkeypage = 0;
 736         int minkeypage = 0;
 737         int btflags = 0;
 738         unsigned int psize = 0;
 739         int lorder = 0;
 740
 741         if (!PyArg_ParseTuple(args, "z|siiiiiii:btopen",
 742                               &file, &flag, &mode,
 743                               &btflags, &cachesize, &maxkeypage, &minkeypage,
 744                               &psize, &lorder))
 745                 return NULL;
 746         if (flag != NULL) {
 747                 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
 748                 if (flag[0] == 'r')
 749                         flags = O_RDONLY;
 750                 else if (flag[0] == 'w')
 751                         flags = O_RDWR;
 752                 else if (flag[0] == 'c')
 753                         flags = O_RDWR|O_CREAT;
 754                 else if (flag[0] == 'n')
 755                         flags = O_RDWR|O_CREAT|O_TRUNC;
 756                 else {
 757                         PyErr_SetString(BsddbError,
 758                                "Flag should begin with 'r', 'w', 'c' or 'n'");
 759                         return NULL;
 760                 }
 761                 if (flag[1] == 'l') {
 762 #if defined(O_EXLOCK) && defined(O_SHLOCK)
 763                         if (flag[0] == 'r')
 764                                 flags |= O_SHLOCK;
 765                         else
 766                                 flags |= O_EXLOCK;
 767 #else
 768                         PyErr_SetString(BsddbError,
 769                                     "locking not supported on this platform");
 770                         return NULL;
 771 #endif
 772                 }
 773         }
 774         return newdbbtobject(file, flags, mode,
 775                              btflags, cachesize, maxkeypage, minkeypage,
 776                              psize, lorder);
 777 }
 778
 779 static PyObject *
 780 bsdrnopen(PyObject *self, PyObject *args)
 781 {
 782         char *file;
 783         char *flag = NULL;
 784         int flags = O_RDONLY;
 785         int mode = 0666;
 786         int cachesize = 0;
 787         int rnflags = 0;
 788         unsigned int psize = 0;
 789         int lorder = 0;
 790         size_t reclen = 0;
 791         char  *bval = "";
 792         char *bfname = NULL;
 793
 794         if (!PyArg_ParseTuple(args, "z|siiiiiiss:rnopen",
 795                               &file, &flag, &mode,
 796                               &rnflags, &cachesize, &psize, &lorder,
 797                               &reclen, &bval, &bfname))
 798                 return NULL;
 799
 800         if (flag != NULL) {
 801                 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
 802                 if (flag[0] == 'r')
 803                         flags = O_RDONLY;
 804                 else if (flag[0] == 'w')
 805                         flags = O_RDWR;
 806                 else if (flag[0] == 'c')
 807                         flags = O_RDWR|O_CREAT;
 808                 else if (flag[0] == 'n')
 809                         flags = O_RDWR|O_CREAT|O_TRUNC;
 810                 else {
 811                         PyErr_SetString(BsddbError,
 812                                "Flag should begin with 'r', 'w', 'c' or 'n'");
 813                         return NULL;
 814                 }
 815                 if (flag[1] == 'l') {
 816 #if defined(O_EXLOCK) && defined(O_SHLOCK)
 817                         if (flag[0] == 'r')
 818                                 flags |= O_SHLOCK;
 819                         else
 820                                 flags |= O_EXLOCK;
 821 #else
 822                         PyErr_SetString(BsddbError,
 823                                     "locking not supported on this platform");
 824                         return NULL;
 825 #endif
 826                 }
 827                 else if (flag[1] != '\0') {
 828                         PyErr_SetString(BsddbError,
 829                                        "Flag char 2 should be 'l' or absent");
 830                         return NULL;
 831                 }
 832         }
 833         return newdbrnobject(file, flags, mode, rnflags, cachesize,
 834                              psize, lorder, reclen, bval[0], bfname);
 835 }
 836
 837 static PyMethodDef bsddbmodule_methods[] = {
 838         {"hashopen",    (PyCFunction)bsdhashopen, METH_VARARGS},
 839         {"btopen",      (PyCFunction)bsdbtopen, METH_VARARGS},
 840         {"rnopen",      (PyCFunction)bsdrnopen, METH_VARARGS},
 841         /* strictly for use by dbhhash!!! */
 842         {"open",        (PyCFunction)bsdhashopen, METH_VARARGS},
 843         {0,             0},
 844 };
 845
 846 PyMODINIT_FUNC
 847 initbsddb185(void) {
 848         PyObject *m, *d;
 849
 850         Bsddbtype.ob_type = &PyType_Type;
 851         m = Py_InitModule("bsddb185", bsddbmodule_methods);
 852         if (m == NULL)
 853                 return;
 854         d = PyModule_GetDict(m);
 855         BsddbError = PyErr_NewException("bsddb.error", NULL, NULL);
 856         if (BsddbError != NULL)
 857                 PyDict_SetItemString(d, "error", BsddbError);
 858 }