contrib/sendmail/libsmdb/smndbm.c

   1 /*
   2 ** Copyright (c) 1999-2002 Proofpoint, Inc. and its suppliers.
   3 **      All rights reserved.
   4 **
   5 ** By using this file, you agree to the terms and conditions set
   6 ** forth in the LICENSE file which can be found at the top level of
   7 ** the sendmail distribution.
   8 */
   9
  10 #include <sm/gen.h>
  11 SM_RCSID("@(#)$Id: smndbm.c,v 8.55 2013-11-22 20:51:49 ca Exp $")
  12
  13 #include <fcntl.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16
  17 #include <sendmail/sendmail.h>
  18 #include <libsmdb/smdb.h>
  19
  20 #ifdef NDBM
  21
  22 # define SMNDB_PAG_FILE_EXTENSION "pag"
  23
  24 struct smdb_dbm_database_struct
  25 {
  26         DBM     *smndbm_dbm;
  27         int     smndbm_lock_fd;
  28         bool    smndbm_cursor_in_use;
  29 };
  30 typedef struct smdb_dbm_database_struct SMDB_DBM_DATABASE;
  31
  32 struct smdb_dbm_cursor_struct
  33 {
  34         SMDB_DBM_DATABASE       *smndbmc_db;
  35         datum                   smndbmc_current_key;
  36 };
  37 typedef struct smdb_dbm_cursor_struct SMDB_DBM_CURSOR;
  38
  39 /*
  40 **  SMDB_PUT_FLAGS_TO_NDBM_FLAGS -- Translates smdb put flags to ndbm put flags.
  41 **
  42 **      Parameters:
  43 **              flags -- The flags to translate.
  44 **
  45 **      Returns:
  46 **              The ndbm flags that are equivalent to the smdb flags.
  47 **
  48 **      Notes:
  49 **              Any invalid flags are ignored.
  50 **
  51 */
  52
  53 int
  54 smdb_put_flags_to_ndbm_flags(flags)
  55         SMDB_FLAG flags;
  56 {
  57         int return_flags;
  58
  59         return_flags = 0;
  60         if (bitset(SMDBF_NO_OVERWRITE, flags))
  61                 return_flags = DBM_INSERT;
  62         else
  63                 return_flags = DBM_REPLACE;
  64
  65         return return_flags;
  66 }
  67
  68 /*
  69 **  Except for smdb_ndbm_open, the rest of these function correspond to the
  70 **  interface laid out in smdb.h.
  71 */
  72
  73 SMDB_DBM_DATABASE *
  74 smdbm_malloc_database()
  75 {
  76         SMDB_DBM_DATABASE *db;
  77
  78         db = (SMDB_DBM_DATABASE *) malloc(sizeof(SMDB_DBM_DATABASE));
  79         if (db != NULL)
  80         {
  81                 db->smndbm_dbm = NULL;
  82                 db->smndbm_lock_fd = -1;
  83                 db->smndbm_cursor_in_use = false;
  84         }
  85
  86         return db;
  87 }
  88
  89 int
  90 smdbm_close(database)
  91         SMDB_DATABASE *database;
  92 {
  93         SMDB_DBM_DATABASE *db = (SMDB_DBM_DATABASE *) database->smdb_impl;
  94         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
  95
  96         dbm_close(dbm);
  97         if (db->smndbm_lock_fd != -1)
  98                 close(db->smndbm_lock_fd);
  99
 100         free(db);
 101         database->smdb_impl = NULL;
 102
 103         return SMDBE_OK;
 104 }
 105
 106 int
 107 smdbm_del(database, key, flags)
 108         SMDB_DATABASE *database;
 109         SMDB_DBENT *key;
 110         unsigned int flags;
 111 {
 112         int result;
 113         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
 114         datum dbkey;
 115
 116         (void) memset(&dbkey, '\0', sizeof dbkey);
 117         dbkey.dptr = key->data;
 118         dbkey.dsize = key->size;
 119
 120         errno = 0;
 121         result = dbm_delete(dbm, dbkey);
 122         if (result != 0)
 123         {
 124                 int save_errno = errno;
 125
 126                 if (dbm_error(dbm))
 127                         return SMDBE_IO_ERROR;
 128
 129                 if (save_errno != 0)
 130                         return save_errno;
 131
 132                 return SMDBE_NOT_FOUND;
 133         }
 134         return SMDBE_OK;
 135 }
 136
 137 int
 138 smdbm_fd(database, fd)
 139         SMDB_DATABASE *database;
 140         int *fd;
 141 {
 142         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
 143
 144         *fd = dbm_dirfno(dbm);
 145         if (*fd <= 0)
 146                 return EINVAL;
 147
 148         return SMDBE_OK;
 149 }
 150
 151 int
 152 smdbm_lockfd(database)
 153         SMDB_DATABASE *database;
 154 {
 155         SMDB_DBM_DATABASE *db = (SMDB_DBM_DATABASE *) database->smdb_impl;
 156
 157         return db->smndbm_lock_fd;
 158 }
 159
 160 int
 161 smdbm_get(database, key, data, flags)
 162         SMDB_DATABASE *database;
 163         SMDB_DBENT *key;
 164         SMDB_DBENT *data;
 165         unsigned int flags;
 166 {
 167         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
 168         datum dbkey, dbdata;
 169
 170         (void) memset(&dbkey, '\0', sizeof dbkey);
 171         (void) memset(&dbdata, '\0', sizeof dbdata);
 172         dbkey.dptr = key->data;
 173         dbkey.dsize = key->size;
 174
 175         errno = 0;
 176         dbdata = dbm_fetch(dbm, dbkey);
 177         if (dbdata.dptr == NULL)
 178         {
 179                 int save_errno = errno;
 180
 181                 if (dbm_error(dbm))
 182                         return SMDBE_IO_ERROR;
 183
 184                 if (save_errno != 0)
 185                         return save_errno;
 186
 187                 return SMDBE_NOT_FOUND;
 188         }
 189         data->data = dbdata.dptr;
 190         data->size = dbdata.dsize;
 191         return SMDBE_OK;
 192 }
 193
 194 int
 195 smdbm_put(database, key, data, flags)
 196         SMDB_DATABASE *database;
 197         SMDB_DBENT *key;
 198         SMDB_DBENT *data;
 199         unsigned int flags;
 200 {
 201         int result;
 202         int save_errno;
 203         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
 204         datum dbkey, dbdata;
 205
 206         (void) memset(&dbkey, '\0', sizeof dbkey);
 207         (void) memset(&dbdata, '\0', sizeof dbdata);
 208         dbkey.dptr = key->data;
 209         dbkey.dsize = key->size;
 210         dbdata.dptr = data->data;
 211         dbdata.dsize = data->size;
 212
 213         errno = 0;
 214         result = dbm_store(dbm, dbkey, dbdata,
 215                            smdb_put_flags_to_ndbm_flags(flags));
 216         switch (result)
 217         {
 218           case 1:
 219                 return SMDBE_DUPLICATE;
 220
 221           case 0:
 222                 return SMDBE_OK;
 223
 224           default:
 225                 save_errno = errno;
 226
 227                 if (dbm_error(dbm))
 228                         return SMDBE_IO_ERROR;
 229
 230                 if (save_errno != 0)
 231                         return save_errno;
 232
 233                 return SMDBE_IO_ERROR;
 234         }
 235         /* NOTREACHED */
 236 }
 237
 238 int
 239 smndbm_set_owner(database, uid, gid)
 240         SMDB_DATABASE *database;
 241         uid_t uid;
 242         gid_t gid;
 243 {
 244 # if HASFCHOWN
 245         int fd;
 246         int result;
 247         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
 248
 249         fd = dbm_dirfno(dbm);
 250         if (fd <= 0)
 251                 return EINVAL;
 252
 253         result = fchown(fd, uid, gid);
 254         if (result < 0)
 255                 return errno;
 256
 257         fd = dbm_pagfno(dbm);
 258         if (fd <= 0)
 259                 return EINVAL;
 260
 261         result = fchown(fd, uid, gid);
 262         if (result < 0)
 263                 return errno;
 264 # endif /* HASFCHOWN */
 265
 266         return SMDBE_OK;
 267 }
 268
 269 int
 270 smdbm_sync(database, flags)
 271         SMDB_DATABASE *database;
 272         unsigned int flags;
 273 {
 274         return SMDBE_UNSUPPORTED;
 275 }
 276
 277 int
 278 smdbm_cursor_close(cursor)
 279         SMDB_CURSOR *cursor;
 280 {
 281         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
 282         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
 283
 284         if (!db->smndbm_cursor_in_use)
 285                 return SMDBE_NOT_A_VALID_CURSOR;
 286
 287         db->smndbm_cursor_in_use = false;
 288         free(dbm_cursor);
 289         free(cursor);
 290
 291         return SMDBE_OK;
 292 }
 293
 294 int
 295 smdbm_cursor_del(cursor, flags)
 296         SMDB_CURSOR *cursor;
 297         unsigned int flags;
 298 {
 299         int result;
 300         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
 301         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
 302         DBM *dbm = db->smndbm_dbm;
 303
 304         errno = 0;
 305         result = dbm_delete(dbm, dbm_cursor->smndbmc_current_key);
 306         if (result != 0)
 307         {
 308                 int save_errno = errno;
 309
 310                 if (dbm_error(dbm))
 311                         return SMDBE_IO_ERROR;
 312
 313                 if (save_errno != 0)
 314                         return save_errno;
 315
 316                 return SMDBE_NOT_FOUND;
 317         }
 318         return SMDBE_OK;
 319 }
 320
 321 int
 322 smdbm_cursor_get(cursor, key, value, flags)
 323         SMDB_CURSOR *cursor;
 324         SMDB_DBENT *key;
 325         SMDB_DBENT *value;
 326         SMDB_FLAG flags;
 327 {
 328         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
 329         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
 330         DBM *dbm = db->smndbm_dbm;
 331         datum dbkey, dbdata;
 332
 333         (void) memset(&dbkey, '\0', sizeof dbkey);
 334         (void) memset(&dbdata, '\0', sizeof dbdata);
 335
 336         if (flags == SMDB_CURSOR_GET_RANGE)
 337                 return SMDBE_UNSUPPORTED;
 338
 339         if (dbm_cursor->smndbmc_current_key.dptr == NULL)
 340         {
 341                 dbm_cursor->smndbmc_current_key = dbm_firstkey(dbm);
 342                 if (dbm_cursor->smndbmc_current_key.dptr == NULL)
 343                 {
 344                         if (dbm_error(dbm))
 345                                 return SMDBE_IO_ERROR;
 346                         return SMDBE_LAST_ENTRY;
 347                 }
 348         }
 349         else
 350         {
 351                 dbm_cursor->smndbmc_current_key = dbm_nextkey(dbm);
 352                 if (dbm_cursor->smndbmc_current_key.dptr == NULL)
 353                 {
 354                         if (dbm_error(dbm))
 355                                 return SMDBE_IO_ERROR;
 356                         return SMDBE_LAST_ENTRY;
 357                 }
 358         }
 359
 360         errno = 0;
 361         dbdata = dbm_fetch(dbm, dbm_cursor->smndbmc_current_key);
 362         if (dbdata.dptr == NULL)
 363         {
 364                 int save_errno = errno;
 365
 366                 if (dbm_error(dbm))
 367                         return SMDBE_IO_ERROR;
 368
 369                 if (save_errno != 0)
 370                         return save_errno;
 371
 372                 return SMDBE_NOT_FOUND;
 373         }
 374         value->data = dbdata.dptr;
 375         value->size = dbdata.dsize;
 376         key->data = dbm_cursor->smndbmc_current_key.dptr;
 377         key->size = dbm_cursor->smndbmc_current_key.dsize;
 378
 379         return SMDBE_OK;
 380 }
 381
 382 int
 383 smdbm_cursor_put(cursor, key, value, flags)
 384         SMDB_CURSOR *cursor;
 385         SMDB_DBENT *key;
 386         SMDB_DBENT *value;
 387         SMDB_FLAG flags;
 388 {
 389         int result;
 390         int save_errno;
 391         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
 392         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
 393         DBM *dbm = db->smndbm_dbm;
 394         datum dbdata;
 395
 396         (void) memset(&dbdata, '\0', sizeof dbdata);
 397         dbdata.dptr = value->data;
 398         dbdata.dsize = value->size;
 399
 400         errno = 0;
 401         result = dbm_store(dbm, dbm_cursor->smndbmc_current_key, dbdata,
 402                            smdb_put_flags_to_ndbm_flags(flags));
 403         switch (result)
 404         {
 405           case 1:
 406                 return SMDBE_DUPLICATE;
 407
 408           case 0:
 409                 return SMDBE_OK;
 410
 411           default:
 412                 save_errno = errno;
 413
 414                 if (dbm_error(dbm))
 415                         return SMDBE_IO_ERROR;
 416
 417                 if (save_errno != 0)
 418                         return save_errno;
 419
 420                 return SMDBE_IO_ERROR;
 421         }
 422         /* NOTREACHED */
 423 }
 424
 425 int
 426 smdbm_cursor(database, cursor, flags)
 427         SMDB_DATABASE *database;
 428         SMDB_CURSOR **cursor;
 429         SMDB_FLAG flags;
 430 {
 431         SMDB_DBM_DATABASE *db = (SMDB_DBM_DATABASE *) database->smdb_impl;
 432         SMDB_CURSOR *cur;
 433         SMDB_DBM_CURSOR *dbm_cursor;
 434
 435         if (db->smndbm_cursor_in_use)
 436                 return SMDBE_ONLY_SUPPORTS_ONE_CURSOR;
 437
 438         db->smndbm_cursor_in_use = true;
 439         dbm_cursor = (SMDB_DBM_CURSOR *) malloc(sizeof(SMDB_DBM_CURSOR));
 440         if (dbm_cursor == NULL)
 441                 return SMDBE_MALLOC;
 442         dbm_cursor->smndbmc_db = db;
 443         dbm_cursor->smndbmc_current_key.dptr = NULL;
 444         dbm_cursor->smndbmc_current_key.dsize = 0;
 445
 446         cur = (SMDB_CURSOR*) malloc(sizeof(SMDB_CURSOR));
 447         if (cur == NULL)
 448         {
 449                 free(dbm_cursor);
 450                 return SMDBE_MALLOC;
 451         }
 452
 453         cur->smdbc_impl = dbm_cursor;
 454         cur->smdbc_close = smdbm_cursor_close;
 455         cur->smdbc_del = smdbm_cursor_del;
 456         cur->smdbc_get = smdbm_cursor_get;
 457         cur->smdbc_put = smdbm_cursor_put;
 458         *cursor = cur;
 459
 460         return SMDBE_OK;
 461 }
 462 /*
 463 **  SMDB_NDBM_OPEN -- Opens a ndbm database.
 464 **
 465 **      Parameters:
 466 **              database -- An unallocated database pointer to a pointer.
 467 **              db_name -- The name of the database without extension.
 468 **              mode -- File permisions on a created database.
 469 **              mode_mask -- Mode bits that much match on an opened database.
 470 **              sff -- Flags to safefile.
 471 **              type -- The type of database to open.
 472 **                      Only SMDB_NDBM is supported.
 473 **              user_info -- Information on the user to use for file
 474 **                          permissions.
 475 **              db_params -- No params are supported.
 476 **
 477 **      Returns:
 478 **              SMDBE_OK -- Success, otherwise errno:
 479 **              SMDBE_MALLOC -- Cannot allocate memory.
 480 **              SMDBE_UNSUPPORTED -- The type is not supported.
 481 **              SMDBE_GDBM_IS_BAD -- We have detected GDBM and we don't
 482 **                                  like it.
 483 **              SMDBE_BAD_OPEN -- dbm_open failed and errno was not set.
 484 **              Anything else: errno
 485 */
 486
 487 int
 488 smdb_ndbm_open(database, db_name, mode, mode_mask, sff, type, user_info,
 489                db_params)
 490         SMDB_DATABASE **database;
 491         char *db_name;
 492         int mode;
 493         int mode_mask;
 494         long sff;
 495         SMDB_DBTYPE type;
 496         SMDB_USER_INFO *user_info;
 497         SMDB_DBPARAMS *db_params;
 498 {
 499         bool lockcreated = false;
 500         int result;
 501         int lock_fd;
 502         SMDB_DATABASE *smdb_db;
 503         SMDB_DBM_DATABASE *db;
 504         DBM *dbm = NULL;
 505         struct stat dir_stat_info;
 506         struct stat pag_stat_info;
 507
 508         result = SMDBE_OK;
 509         *database = NULL;
 510
 511         if (type == NULL)
 512                 return SMDBE_UNKNOWN_DB_TYPE;
 513
 514         result = smdb_setup_file(db_name, SMNDB_DIR_FILE_EXTENSION, mode_mask,
 515                                  sff, user_info, &dir_stat_info);
 516         if (result != SMDBE_OK)
 517                 return result;
 518
 519         result = smdb_setup_file(db_name, SMNDB_PAG_FILE_EXTENSION, mode_mask,
 520                                  sff, user_info, &pag_stat_info);
 521         if (result != SMDBE_OK)
 522                 return result;
 523
 524         if ((dir_stat_info.st_mode == ST_MODE_NOFILE ||
 525              pag_stat_info.st_mode == ST_MODE_NOFILE) &&
 526             bitset(mode, O_CREAT))
 527                 lockcreated = true;
 528
 529         lock_fd = -1;
 530         result = smdb_lock_file(&lock_fd, db_name, mode, sff,
 531                                 SMNDB_DIR_FILE_EXTENSION);
 532         if (result != SMDBE_OK)
 533                 return result;
 534
 535         if (lockcreated)
 536         {
 537                 int pag_fd;
 538
 539                 /* Need to pre-open the .pag file as well with O_EXCL */
 540                 result = smdb_lock_file(&pag_fd, db_name, mode, sff,
 541                                         SMNDB_PAG_FILE_EXTENSION);
 542                 if (result != SMDBE_OK)
 543                 {
 544                         (void) close(lock_fd);
 545                         return result;
 546                 }
 547                 (void) close(pag_fd);
 548
 549                 mode |= O_TRUNC;
 550                 mode &= ~(O_CREAT|O_EXCL);
 551         }
 552
 553         smdb_db = smdb_malloc_database();
 554         if (smdb_db == NULL)
 555                 result = SMDBE_MALLOC;
 556
 557         db = smdbm_malloc_database();
 558         if (db == NULL)
 559                 result = SMDBE_MALLOC;
 560
 561         /* Try to open database */
 562         if (result == SMDBE_OK)
 563         {
 564                 db->smndbm_lock_fd = lock_fd;
 565
 566                 errno = 0;
 567                 dbm = dbm_open(db_name, mode, DBMMODE);
 568                 if (dbm == NULL)
 569                 {
 570                         if (errno == 0)
 571                                 result = SMDBE_BAD_OPEN;
 572                         else
 573                                 result = errno;
 574                 }
 575                 db->smndbm_dbm = dbm;
 576         }
 577
 578         /* Check for GDBM */
 579         if (result == SMDBE_OK)
 580         {
 581                 if (dbm_dirfno(dbm) == dbm_pagfno(dbm))
 582                         result = SMDBE_GDBM_IS_BAD;
 583         }
 584
 585         /* Check for filechanged */
 586         if (result == SMDBE_OK)
 587         {
 588                 result = smdb_filechanged(db_name, SMNDB_DIR_FILE_EXTENSION,
 589                                           dbm_dirfno(dbm), &dir_stat_info);
 590                 if (result == SMDBE_OK)
 591                 {
 592                         result = smdb_filechanged(db_name,
 593                                                   SMNDB_PAG_FILE_EXTENSION,
 594                                                   dbm_pagfno(dbm),
 595                                                   &pag_stat_info);
 596                 }
 597         }
 598
 599         /* XXX Got to get fchown stuff in here */
 600
 601         /* Setup driver if everything is ok */
 602         if (result == SMDBE_OK)
 603         {
 604                 *database = smdb_db;
 605
 606                 smdb_db->smdb_close = smdbm_close;
 607                 smdb_db->smdb_del = smdbm_del;
 608                 smdb_db->smdb_fd = smdbm_fd;
 609                 smdb_db->smdb_lockfd = smdbm_lockfd;
 610                 smdb_db->smdb_get = smdbm_get;
 611                 smdb_db->smdb_put = smdbm_put;
 612                 smdb_db->smdb_set_owner = smndbm_set_owner;
 613                 smdb_db->smdb_sync = smdbm_sync;
 614                 smdb_db->smdb_cursor = smdbm_cursor;
 615
 616                 smdb_db->smdb_impl = db;
 617
 618                 return SMDBE_OK;
 619         }
 620
 621         /* If we're here, something bad happened, clean up */
 622         if (dbm != NULL)
 623                 dbm_close(dbm);
 624
 625         smdb_unlock_file(db->smndbm_lock_fd);
 626         free(db);
 627         smdb_free_database(smdb_db);
 628
 629         return result;
 630 }
 631 #endif /* NDBM */