lib/hdb/hdb-sqlite.c

   1 /*
   2  * Copyright (c) 2009 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "hdb_locl.h"
  35 #include "sqlite3.h"
  36
  37 #define MAX_RETRIES 10
  38
  39 typedef struct hdb_sqlite_db {
  40     double version;
  41     sqlite3 *db;
  42     char *db_file;
  43
  44     sqlite3_stmt *get_version;
  45     sqlite3_stmt *fetch;
  46     sqlite3_stmt *get_ids;
  47     sqlite3_stmt *add_entry;
  48     sqlite3_stmt *add_principal;
  49     sqlite3_stmt *add_alias;
  50     sqlite3_stmt *delete_aliases;
  51     sqlite3_stmt *update_entry;
  52     sqlite3_stmt *remove;
  53     sqlite3_stmt *get_all_entries;
  54
  55 } hdb_sqlite_db;
  56
  57 /* This should be used to mark updates which make the code incompatible
  58  * with databases created with previous versions. Don't update it if
  59  * compatibility is not broken. */
  60 #define HDBSQLITE_VERSION 0.1
  61
  62 #define _HDBSQLITE_STRINGIFY(x) #x
  63 #define HDBSQLITE_STRINGIFY(x) _HDBSQLITE_STRINGIFY(x)
  64
  65 #define HDBSQLITE_CREATE_TABLES \
  66                  " BEGIN TRANSACTION;" \
  67                  " CREATE TABLE Version (number REAL);" \
  68                  " INSERT INTO Version (number)" \
  69                  " VALUES (" HDBSQLITE_STRINGIFY(HDBSQLITE_VERSION) ");" \
  70                  " CREATE TABLE Principal" \
  71                  "  (id INTEGER PRIMARY KEY," \
  72                  "   principal TEXT UNIQUE NOT NULL," \
  73                  "   canonical INTEGER," \
  74                  "   entry INTEGER);" \
  75                  " CREATE TABLE Entry" \
  76                  "  (id INTEGER PRIMARY KEY," \
  77                  "   data BLOB);" \
  78                  " COMMIT"
  79 #define HDBSQLITE_CREATE_TRIGGERS \
  80                  " CREATE TRIGGER remove_principals AFTER DELETE ON Entry" \
  81                  " BEGIN" \
  82                  "  DELETE FROM Principal" \
  83                  "  WHERE entry = OLD.id;" \
  84                  " END"
  85 #define HDBSQLITE_GET_VERSION \
  86                  " SELECT number FROM Version"
  87 #define HDBSQLITE_FETCH \
  88                  " SELECT Entry.data FROM Principal, Entry" \
  89                  " WHERE Principal.principal = ? AND" \
  90                  "       Entry.id = Principal.entry"
  91 #define HDBSQLITE_GET_IDS \
  92                  " SELECT id, entry FROM Principal" \
  93                  " WHERE principal = ?"
  94 #define HDBSQLITE_ADD_ENTRY \
  95                  " INSERT INTO Entry (data) VALUES (?)"
  96 #define HDBSQLITE_ADD_PRINCIPAL \
  97                  " INSERT INTO Principal (principal, entry, canonical)" \
  98                  " VALUES (?, last_insert_rowid(), 1)"
  99 #define HDBSQLITE_ADD_ALIAS \
 100                  " INSERT INTO Principal (principal, entry, canonical)" \
 101                  " VALUES(?, ?, 0)"
 102 #define HDBSQLITE_DELETE_ALIASES \
 103                  " DELETE FROM Principal" \
 104                  " WHERE entry = ? AND canonical = 0"
 105 #define HDBSQLITE_UPDATE_ENTRY \
 106                  " UPDATE Entry SET data = ?" \
 107                  " WHERE id = ?"
 108 #define HDBSQLITE_REMOVE \
 109                  " DELETE FROM ENTRY WHERE id = " \
 110                  "  (SELECT entry FROM Principal" \
 111                  "   WHERE principal = ?)"
 112 #define HDBSQLITE_GET_ALL_ENTRIES \
 113                  " SELECT data FROM Entry"
 114
 115 /**
 116  * Wrapper around sqlite3_prepare_v2.
 117  *
 118  * @param context   The current krb5 context
 119  * @param statement Where to store the pointer to the statement
 120  *                  after preparing it
 121  * @param str       SQL code for the statement
 122  *
 123  * @return          0 if OK, an error code if not
 124  */
 125 static krb5_error_code
 126 hdb_sqlite_prepare_stmt(krb5_context context,
 127                         sqlite3 *db,
 128                         sqlite3_stmt **statement,
 129                         const char *str)
 130 {
 131     int ret, tries = 0;
 132
 133     ret = sqlite3_prepare_v2(db, str, -1, statement, NULL);
 134     while((tries++ < MAX_RETRIES) &&
 135           ((ret == SQLITE_BUSY) ||
 136            (ret == SQLITE_IOERR_BLOCKED) ||
 137            (ret == SQLITE_LOCKED))) {
 138         krb5_warnx(context, "hdb-sqlite: prepare busy");
 139         sleep(1);
 140         ret = sqlite3_prepare_v2(db, str, -1, statement, NULL);
 141     }
 142
 143     if (ret != SQLITE_OK) {
 144         krb5_set_error_message(context, EINVAL,
 145                                "Failed to prepare stmt %s: %s",
 146                                str, sqlite3_errmsg(db));
 147         return EINVAL;
 148     }
 149
 150     return 0;
 151 }
 152
 153 /**
 154  * A wrapper around sqlite3_exec.
 155  *
 156  * @param context    The current krb5 context
 157  * @param database   An open sqlite3 database handle
 158  * @param statement  SQL code to execute
 159  * @param error_code What to return if the statement fails
 160  *
 161  * @return           0 if OK, else error_code
 162  */
 163 static krb5_error_code
 164 hdb_sqlite_exec_stmt(krb5_context context,
 165                      sqlite3 *database,
 166                      const char *statement,
 167                      krb5_error_code error_code)
 168 {
 169     int ret;
 170
 171     ret = sqlite3_exec(database, statement, NULL, NULL, NULL);
 172
 173     while(((ret == SQLITE_BUSY) ||
 174            (ret == SQLITE_IOERR_BLOCKED) ||
 175            (ret == SQLITE_LOCKED))) {
 176         krb5_warnx(context, "hdb-sqlite: exec busy: %d", (int)getpid());
 177         sleep(1);
 178         ret = sqlite3_exec(database, statement, NULL, NULL, NULL);
 179     }
 180
 181     if (ret != SQLITE_OK && error_code) {
 182         krb5_set_error_message(context, error_code,
 183                                "Execute %s: %s", statement,
 184                               sqlite3_errmsg(database));
 185         return error_code;
 186     }
 187
 188     return 0;
 189 }
 190
 191 /**
 192  *
 193  */
 194
 195 static krb5_error_code
 196 bind_principal(krb5_context context, krb5_const_principal principal, sqlite3_stmt *stmt, int key)
 197 {
 198     krb5_error_code ret;
 199     char *str = NULL;
 200
 201     ret = krb5_unparse_name(context, principal, &str);
 202     if (ret)
 203         return ret;
 204
 205     sqlite3_bind_text(stmt, key, str, -1, SQLITE_TRANSIENT);
 206     free(str);
 207     return 0;
 208 }
 209
 210 /**
 211  * Opens an sqlite3 database handle to a file, may create the
 212  * database file depending on flags.
 213  *
 214  * @param context The current krb5 context
 215  * @param db      Heimdal database handle
 216  * @param flags   Controls whether or not the file may be created,
 217  *                may be 0 or SQLITE_OPEN_CREATE
 218  */
 219 static krb5_error_code
 220 hdb_sqlite_open_database(krb5_context context, HDB *db, int flags)
 221 {
 222     int ret;
 223     hdb_sqlite_db *hsdb = (hdb_sqlite_db*) db->hdb_db;
 224
 225     ret = sqlite3_open_v2(hsdb->db_file, &hsdb->db,
 226                           SQLITE_OPEN_READWRITE | flags, NULL);
 227
 228     if (ret) {
 229         if (hsdb->db) {
 230             ret = ENOENT;
 231             krb5_set_error_message(context, ret,
 232                                   "Error opening sqlite database %s: %s",
 233                                   hsdb->db_file, sqlite3_errmsg(hsdb->db));
 234             sqlite3_close(hsdb->db);
 235             hsdb->db = NULL;
 236         } else
 237             ret = krb5_enomem(context);
 238         return ret;
 239     }
 240
 241     return 0;
 242 }
 243
 244 static int
 245 hdb_sqlite_step(krb5_context context, sqlite3 *db, sqlite3_stmt *stmt)
 246 {
 247     int ret;
 248
 249     ret = sqlite3_step(stmt);
 250     while(((ret == SQLITE_BUSY) ||
 251            (ret == SQLITE_IOERR_BLOCKED) ||
 252            (ret == SQLITE_LOCKED))) {
 253         krb5_warnx(context, "hdb-sqlite: step busy: %d", (int)getpid());
 254         sleep(1);
 255         ret = sqlite3_step(stmt);
 256     }
 257     return ret;
 258 }
 259
 260 /**
 261  * Closes the database and frees memory allocated for statements.
 262  *
 263  * @param context The current krb5 context
 264  * @param db      Heimdal database handle
 265  */
 266 static krb5_error_code
 267 hdb_sqlite_close_database(krb5_context context, HDB *db)
 268 {
 269     hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
 270
 271     sqlite3_finalize(hsdb->get_version);
 272     sqlite3_finalize(hsdb->fetch);
 273     sqlite3_finalize(hsdb->get_ids);
 274     sqlite3_finalize(hsdb->add_entry);
 275     sqlite3_finalize(hsdb->add_principal);
 276     sqlite3_finalize(hsdb->add_alias);
 277     sqlite3_finalize(hsdb->delete_aliases);
 278     sqlite3_finalize(hsdb->update_entry);
 279     sqlite3_finalize(hsdb->remove);
 280     sqlite3_finalize(hsdb->get_all_entries);
 281
 282     sqlite3_close(hsdb->db);
 283
 284     return 0;
 285 }
 286
 287 /**
 288  * Opens an sqlite database file and prepares it for use.
 289  * If the file does not exist it will be created.
 290  *
 291  * @param context  The current krb5_context
 292  * @param db       The heimdal database handle
 293  * @param filename Where to store the database file
 294  *
 295  * @return         0 if everything worked, an error code if not
 296  */
 297 static krb5_error_code
 298 hdb_sqlite_make_database(krb5_context context, HDB *db, const char *filename)
 299 {
 300     int ret;
 301     int created_file = 0;
 302     hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
 303
 304     hsdb->db_file = strdup(filename);
 305     if(hsdb->db_file == NULL)
 306         return ENOMEM;
 307
 308     ret = hdb_sqlite_open_database(context, db, 0);
 309     if (ret) {
 310         ret = hdb_sqlite_open_database(context, db, SQLITE_OPEN_CREATE);
 311         if (ret) goto out;
 312
 313         created_file = 1;
 314
 315         ret = hdb_sqlite_exec_stmt(context, hsdb->db,
 316                                    HDBSQLITE_CREATE_TABLES,
 317                                    EINVAL);
 318         if (ret) goto out;
 319
 320         ret = hdb_sqlite_exec_stmt(context, hsdb->db,
 321                                    HDBSQLITE_CREATE_TRIGGERS,
 322                                    EINVAL);
 323         if (ret) goto out;
 324     }
 325
 326     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 327                                   &hsdb->get_version,
 328                                   HDBSQLITE_GET_VERSION);
 329     if (ret) goto out;
 330     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 331                                   &hsdb->fetch,
 332                                   HDBSQLITE_FETCH);
 333     if (ret) goto out;
 334     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 335                                   &hsdb->get_ids,
 336                                   HDBSQLITE_GET_IDS);
 337     if (ret) goto out;
 338     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 339                                   &hsdb->add_entry,
 340                                   HDBSQLITE_ADD_ENTRY);
 341     if (ret) goto out;
 342     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 343                                   &hsdb->add_principal,
 344                                   HDBSQLITE_ADD_PRINCIPAL);
 345     if (ret) goto out;
 346     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 347                                   &hsdb->add_alias,
 348                                   HDBSQLITE_ADD_ALIAS);
 349     if (ret) goto out;
 350     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 351                                   &hsdb->delete_aliases,
 352                                   HDBSQLITE_DELETE_ALIASES);
 353     if (ret) goto out;
 354     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 355                                   &hsdb->update_entry,
 356                                   HDBSQLITE_UPDATE_ENTRY);
 357     if (ret) goto out;
 358     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 359                                   &hsdb->remove,
 360                                   HDBSQLITE_REMOVE);
 361     if (ret) goto out;
 362     ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
 363                                   &hsdb->get_all_entries,
 364                                   HDBSQLITE_GET_ALL_ENTRIES);
 365     if (ret) goto out;
 366
 367     ret = hdb_sqlite_step(context, hsdb->db, hsdb->get_version);
 368     if(ret == SQLITE_ROW) {
 369         hsdb->version = sqlite3_column_double(hsdb->get_version, 0);
 370     }
 371     sqlite3_reset(hsdb->get_version);
 372     ret = 0;
 373
 374     if(hsdb->version != HDBSQLITE_VERSION) {
 375         ret = EINVAL;
 376         krb5_set_error_message(context, ret, "HDBSQLITE_VERSION mismatch");
 377     }
 378
 379     if(ret) goto out;
 380
 381     return 0;
 382
 383  out:
 384     if (hsdb->db)
 385         sqlite3_close(hsdb->db);
 386     if (created_file)
 387         unlink(hsdb->db_file);
 388
 389     return ret;
 390 }
 391
 392 /**
 393  * Retrieves an entry by searching for the given
 394  * principal in the Principal database table, both
 395  * for canonical principals and aliases.
 396  *
 397  * @param context   The current krb5_context
 398  * @param db        Heimdal database handle
 399  * @param principal The principal whose entry to search for
 400  * @param flags     Currently only for HDB_F_DECRYPT
 401  * @param kvno      kvno to fetch is HDB_F_KVNO_SPECIFIED use used
 402  *
 403  * @return          0 if everything worked, an error code if not
 404  */
 405 static krb5_error_code
 406 hdb_sqlite_fetch_kvno(krb5_context context, HDB *db, krb5_const_principal principal,
 407                       unsigned flags, krb5_kvno kvno, hdb_entry_ex *entry)
 408 {
 409     int sqlite_error;
 410     krb5_error_code ret;
 411     hdb_sqlite_db *hsdb = (hdb_sqlite_db*)(db->hdb_db);
 412     sqlite3_stmt *fetch = hsdb->fetch;
 413     krb5_data value;
 414
 415     ret = bind_principal(context, principal, fetch, 1);
 416     if (ret)
 417         return ret;
 418
 419     sqlite_error = hdb_sqlite_step(context, hsdb->db, fetch);
 420     if (sqlite_error != SQLITE_ROW) {
 421         if(sqlite_error == SQLITE_DONE) {
 422             ret = HDB_ERR_NOENTRY;
 423             goto out;
 424         } else {
 425             ret = EINVAL;
 426             krb5_set_error_message(context, ret,
 427                                   "sqlite fetch failed: %d",
 428                                   sqlite_error);
 429             goto out;
 430         }
 431     }
 432
 433     value.length = sqlite3_column_bytes(fetch, 0);
 434     value.data = (void *) sqlite3_column_blob(fetch, 0);
 435
 436     ret = hdb_value2entry(context, &value, &entry->entry);
 437     if(ret)
 438         goto out;
 439
 440     if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
 441         ret = hdb_unseal_keys(context, db, &entry->entry);
 442         if(ret) {
 443            hdb_free_entry(context, entry);
 444            goto out;
 445         }
 446     }
 447
 448     ret = 0;
 449
 450 out:
 451
 452     sqlite3_clear_bindings(fetch);
 453     sqlite3_reset(fetch);
 454
 455
 456     return ret;
 457 }
 458
 459 /**
 460  * Convenience function to step a prepared statement with no
 461  * value once.
 462  *
 463  * @param context   The current krb5_context
 464  * @param statement A prepared sqlite3 statement
 465  *
 466  * @return        0 if everything worked, an error code if not
 467  */
 468 static krb5_error_code
 469 hdb_sqlite_step_once(krb5_context context, HDB *db, sqlite3_stmt *statement)
 470 {
 471     int ret;
 472     hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
 473
 474     ret = hdb_sqlite_step(context, hsdb->db, statement);
 475     sqlite3_clear_bindings(statement);
 476     sqlite3_reset(statement);
 477
 478     return ret;
 479 }
 480
 481
 482 /**
 483  * Stores an hdb_entry in the database. If flags contains HDB_F_REPLACE
 484  * a previous entry may be replaced.
 485  *
 486  * @param context The current krb5_context
 487  * @param db      Heimdal database handle
 488  * @param flags   May currently only contain HDB_F_REPLACE
 489  * @param entry   The data to store
 490  *
 491  * @return        0 if everything worked, an error code if not
 492  */
 493 static krb5_error_code
 494 hdb_sqlite_store(krb5_context context, HDB *db, unsigned flags,
 495                  hdb_entry_ex *entry)
 496 {
 497     int ret;
 498     int i;
 499     sqlite_int64 entry_id;
 500     const HDB_Ext_Aliases *aliases;
 501
 502     hdb_sqlite_db *hsdb = (hdb_sqlite_db *)(db->hdb_db);
 503     krb5_data value;
 504     sqlite3_stmt *get_ids = hsdb->get_ids;
 505
 506     ret = hdb_sqlite_exec_stmt(context, hsdb->db,
 507                                "BEGIN IMMEDIATE TRANSACTION", EINVAL);
 508     if(ret != SQLITE_OK) {
 509         ret = EINVAL;
 510         krb5_set_error_message(context, ret,
 511                                "SQLite BEGIN TRANSACTION failed: %s",
 512                                sqlite3_errmsg(hsdb->db));
 513         goto rollback;
 514     }
 515
 516     ret = hdb_seal_keys(context, db, &entry->entry);
 517     if(ret) {
 518         goto rollback;
 519     }
 520
 521     ret = hdb_entry2value(context, &entry->entry, &value);
 522     if(ret) {
 523         goto rollback;
 524     }
 525
 526     ret = bind_principal(context, entry->entry.principal, get_ids, 1);
 527     if (ret)
 528         return ret;
 529
 530     ret = hdb_sqlite_step(context, hsdb->db, get_ids);
 531
 532     if(ret == SQLITE_DONE) { /* No such principal */
 533
 534         sqlite3_bind_blob(hsdb->add_entry, 1,
 535                           value.data, value.length, SQLITE_STATIC);
 536         ret = hdb_sqlite_step(context, hsdb->db, hsdb->add_entry);
 537         sqlite3_clear_bindings(hsdb->add_entry);
 538         sqlite3_reset(hsdb->add_entry);
 539         if(ret != SQLITE_DONE)
 540             goto rollback;
 541
 542         ret = bind_principal(context, entry->entry.principal, hsdb->add_principal, 1);
 543         if (ret)
 544             goto rollback;
 545
 546         ret = hdb_sqlite_step(context, hsdb->db, hsdb->add_principal);
 547         sqlite3_clear_bindings(hsdb->add_principal);
 548         sqlite3_reset(hsdb->add_principal);
 549         if(ret != SQLITE_DONE)
 550             goto rollback;
 551
 552         entry_id = sqlite3_column_int64(get_ids, 1);
 553
 554     } else if(ret == SQLITE_ROW) { /* Found a principal */
 555
 556         if(! (flags & HDB_F_REPLACE)) /* Not allowed to replace it */
 557             goto rollback;
 558
 559         entry_id = sqlite3_column_int64(get_ids, 1);
 560
 561         sqlite3_bind_int64(hsdb->delete_aliases, 1, entry_id);
 562         ret = hdb_sqlite_step_once(context, db, hsdb->delete_aliases);
 563         if(ret != SQLITE_DONE)
 564             goto rollback;
 565
 566         sqlite3_bind_blob(hsdb->update_entry, 1,
 567                           value.data, value.length, SQLITE_STATIC);
 568         sqlite3_bind_int64(hsdb->update_entry, 2, entry_id);
 569         ret = hdb_sqlite_step_once(context, db, hsdb->update_entry);
 570         if(ret != SQLITE_DONE)
 571             goto rollback;
 572
 573     } else {
 574         /* Error! */
 575         goto rollback;
 576     }
 577
 578     ret = hdb_entry_get_aliases(&entry->entry, &aliases);
 579     if(ret || aliases == NULL)
 580         goto commit;
 581
 582     for(i = 0; i < aliases->aliases.len; i++) {
 583
 584         ret = bind_principal(context, &aliases->aliases.val[i], hsdb->add_alias, 1);
 585         if (ret)
 586             goto rollback;
 587
 588         sqlite3_bind_int64(hsdb->add_alias, 2, entry_id);
 589         ret = hdb_sqlite_step_once(context, db, hsdb->add_alias);
 590
 591         if(ret != SQLITE_DONE)
 592             goto rollback;
 593     }
 594
 595     ret = 0;
 596
 597 commit:
 598
 599     krb5_data_free(&value);
 600
 601     sqlite3_clear_bindings(get_ids);
 602     sqlite3_reset(get_ids);
 603
 604     ret = hdb_sqlite_exec_stmt(context, hsdb->db, "COMMIT", EINVAL);
 605     if(ret != SQLITE_OK)
 606         krb5_warnx(context, "hdb-sqlite: COMMIT problem: %d: %s",
 607                    ret, sqlite3_errmsg(hsdb->db));
 608
 609     return ret;
 610
 611 rollback:
 612
 613     krb5_warnx(context, "hdb-sqlite: store rollback problem: %d: %s",
 614                ret, sqlite3_errmsg(hsdb->db));
 615
 616     ret = hdb_sqlite_exec_stmt(context, hsdb->db,
 617                                "ROLLBACK", EINVAL);
 618     return ret;
 619 }
 620
 621 /**
 622  * This may be called often by other code, since the BDB backends
 623  * can not have several open connections. SQLite can handle
 624  * many processes with open handles to the database file
 625  * and closing/opening the handle is an expensive operation.
 626  * Hence, this function does nothing.
 627  *
 628  * @param context The current krb5 context
 629  * @param db      Heimdal database handle
 630  *
 631  * @return        Always returns 0
 632  */
 633 static krb5_error_code
 634 hdb_sqlite_close(krb5_context context, HDB *db)
 635 {
 636     return 0;
 637 }
 638
 639 /**
 640  * The opposite of hdb_sqlite_close. Since SQLite accepts
 641  * many open handles to the database file the handle does not
 642  * need to be closed, or reopened.
 643  *
 644  * @param context The current krb5 context
 645  * @param db      Heimdal database handle
 646  * @param flags
 647  * @param mode_t
 648  *
 649  * @return        Always returns 0
 650  */
 651 static krb5_error_code
 652 hdb_sqlite_open(krb5_context context, HDB *db, int flags, mode_t mode)
 653 {
 654     return 0;
 655 }
 656
 657 /**
 658  * Closes the databse and frees all resources.
 659  *
 660  * @param context The current krb5 context
 661  * @param db      Heimdal database handle
 662  *
 663  * @return        0 on success, an error code if not
 664  */
 665 static krb5_error_code
 666 hdb_sqlite_destroy(krb5_context context, HDB *db)
 667 {
 668     int ret;
 669     hdb_sqlite_db *hsdb;
 670
 671     ret = hdb_clear_master_key(context, db);
 672
 673     hdb_sqlite_close_database(context, db);
 674
 675     hsdb = (hdb_sqlite_db*)(db->hdb_db);
 676
 677     free(hsdb->db_file);
 678     free(db->hdb_db);
 679     free(db);
 680
 681     return ret;
 682 }
 683
 684 /*
 685  * Not sure if this is needed.
 686  */
 687 static krb5_error_code
 688 hdb_sqlite_lock(krb5_context context, HDB *db, int operation)
 689 {
 690     krb5_set_error_message(context, HDB_ERR_CANT_LOCK_DB,
 691                            "lock not implemented");
 692     return HDB_ERR_CANT_LOCK_DB;
 693 }
 694
 695 /*
 696  * Not sure if this is needed.
 697  */
 698 static krb5_error_code
 699 hdb_sqlite_unlock(krb5_context context, HDB *db)
 700 {
 701     krb5_set_error_message(context, HDB_ERR_CANT_LOCK_DB,
 702                           "unlock not implemented");
 703     return HDB_ERR_CANT_LOCK_DB;
 704 }
 705
 706 /*
 707  * Should get the next entry, to allow iteration over all entries.
 708  */
 709 static krb5_error_code
 710 hdb_sqlite_nextkey(krb5_context context, HDB *db, unsigned flags,
 711                    hdb_entry_ex *entry)
 712 {
 713     krb5_error_code ret = 0;
 714     int sqlite_error;
 715     krb5_data value;
 716
 717     hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
 718
 719     sqlite_error = hdb_sqlite_step(context, hsdb->db, hsdb->get_all_entries);
 720     if(sqlite_error == SQLITE_ROW) {
 721         /* Found an entry */
 722         value.length = sqlite3_column_bytes(hsdb->get_all_entries, 0);
 723         value.data = (void *) sqlite3_column_blob(hsdb->get_all_entries, 0);
 724         memset(entry, 0, sizeof(*entry));
 725         ret = hdb_value2entry(context, &value, &entry->entry);
 726     }
 727     else if(sqlite_error == SQLITE_DONE) {
 728         /* No more entries */
 729         ret = HDB_ERR_NOENTRY;
 730         sqlite3_reset(hsdb->get_all_entries);
 731     }
 732     else {
 733         /* XXX SQLite error. Should be handled in some way. */
 734         ret = EINVAL;
 735     }
 736
 737     return ret;
 738 }
 739
 740 /*
 741  * Should get the first entry in the database.
 742  * What is flags used for?
 743  */
 744 static krb5_error_code
 745 hdb_sqlite_firstkey(krb5_context context, HDB *db, unsigned flags,
 746                     hdb_entry_ex *entry)
 747 {
 748     hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
 749     krb5_error_code ret;
 750
 751     sqlite3_reset(hsdb->get_all_entries);
 752
 753     ret = hdb_sqlite_nextkey(context, db, flags, entry);
 754     if(ret)
 755         return ret;
 756
 757     return 0;
 758 }
 759
 760 /*
 761  * Renames the database file.
 762  */
 763 static krb5_error_code
 764 hdb_sqlite_rename(krb5_context context, HDB *db, const char *new_name)
 765 {
 766     hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
 767     int ret;
 768
 769     krb5_warnx(context, "hdb_sqlite_rename");
 770
 771     if (strncasecmp(new_name, "sqlite:", 7) == 0)
 772         new_name += 7;
 773
 774     hdb_sqlite_close_database(context, db);
 775
 776     ret = rename(hsdb->db_file, new_name);
 777     free(hsdb->db_file);
 778
 779     hdb_sqlite_make_database(context, db, new_name);
 780
 781     return ret;
 782 }
 783
 784 /*
 785  * Removes a principal, including aliases and associated entry.
 786  */
 787 static krb5_error_code
 788 hdb_sqlite_remove(krb5_context context, HDB *db,
 789                   krb5_const_principal principal)
 790 {
 791     krb5_error_code ret;
 792     hdb_sqlite_db *hsdb = (hdb_sqlite_db*)(db->hdb_db);
 793     sqlite3_stmt *rm = hsdb->remove;
 794
 795     bind_principal(context, principal, rm, 1);
 796
 797     ret = hdb_sqlite_step(context, hsdb->db, rm);
 798     if (ret != SQLITE_DONE) {
 799         ret = EINVAL;
 800         krb5_set_error_message(context, ret,
 801                               "sqlite remove failed: %d",
 802                               ret);
 803     } else
 804         ret = 0;
 805
 806     sqlite3_clear_bindings(rm);
 807     sqlite3_reset(rm);
 808
 809     return ret;
 810 }
 811
 812 /**
 813  * Create SQLITE object, and creates the on disk database if its doesn't exists.
 814  *
 815  * @param context A Kerberos 5 context.
 816  * @param db a returned database handle.
 817  * @param argument filename
 818  *
 819  * @return        0 on success, an error code if not
 820  */
 821
 822 krb5_error_code
 823 hdb_sqlite_create(krb5_context context, HDB **db, const char *argument)
 824 {
 825     krb5_error_code ret;
 826     hdb_sqlite_db *hsdb;
 827
 828     *db = calloc(1, sizeof (**db));
 829     if (*db == NULL)
 830         return krb5_enomem(context);
 831
 832     hsdb = (hdb_sqlite_db*) calloc(1, sizeof (*hsdb));
 833     if (hsdb == NULL) {
 834         free(*db);
 835         *db = NULL;
 836         return krb5_enomem(context);
 837     }
 838
 839     (*db)->hdb_db = hsdb;
 840
 841     /* XXX make_database should make sure everything else is freed on error */
 842     ret = hdb_sqlite_make_database(context, *db, argument);
 843     if (ret) {
 844         free((*db)->hdb_db);
 845         free(*db);
 846
 847         return ret;
 848     }
 849
 850     (*db)->hdb_master_key_set = 0;
 851     (*db)->hdb_openp = 0;
 852     (*db)->hdb_capability_flags = 0;
 853
 854     (*db)->hdb_open = hdb_sqlite_open;
 855     (*db)->hdb_close = hdb_sqlite_close;
 856
 857     (*db)->hdb_lock = hdb_sqlite_lock;
 858     (*db)->hdb_unlock = hdb_sqlite_unlock;
 859     (*db)->hdb_firstkey = hdb_sqlite_firstkey;
 860     (*db)->hdb_nextkey = hdb_sqlite_nextkey;
 861     (*db)->hdb_fetch_kvno = hdb_sqlite_fetch_kvno;
 862     (*db)->hdb_store = hdb_sqlite_store;
 863     (*db)->hdb_remove = hdb_sqlite_remove;
 864     (*db)->hdb_destroy = hdb_sqlite_destroy;
 865     (*db)->hdb_rename = hdb_sqlite_rename;
 866     (*db)->hdb__get = NULL;
 867     (*db)->hdb__put = NULL;
 868     (*db)->hdb__del = NULL;
 869
 870     return 0;
 871 }