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 * Opens an sqlite3 database handle to a file, may create the 193 * database file depending on flags. 194 * 195 * @param context The current krb5 context 196 * @param db Heimdal database handle 197 * @param flags Controls whether or not the file may be created, 198 * may be 0 or SQLITE_OPEN_CREATE 199 */ 200 static krb5_error_code 201 hdb_sqlite_open_database(krb5_context context, HDB *db, int flags) 202 { 203 int ret; 204 hdb_sqlite_db *hsdb = (hdb_sqlite_db*) db->hdb_db; 205 206 ret = sqlite3_open_v2(hsdb->db_file, &hsdb->db, 207 SQLITE_OPEN_READWRITE | flags, NULL); 208 209 if (ret) { 210 if (hsdb->db) { 211 ret = ENOENT; 212 krb5_set_error_message(context, ret, 213 "Error opening sqlite database %s: %s", 214 hsdb->db_file, sqlite3_errmsg(hsdb->db)); 215 sqlite3_close(hsdb->db); 216 hsdb->db = NULL; 217 } else 218 ret = krb5_enomem(context); 219 return ret; 220 } 221 222 return 0; 223 } 224 225 static int 226 hdb_sqlite_step(krb5_context context, sqlite3 *db, sqlite3_stmt *stmt) 227 { 228 int ret; 229 230 ret = sqlite3_step(stmt); 231 while(((ret == SQLITE_BUSY) || 232 (ret == SQLITE_IOERR_BLOCKED) || 233 (ret == SQLITE_LOCKED))) { 234 krb5_warnx(context, "hdb-sqlite: step busy: %d", (int)getpid()); 235 sleep(1); 236 ret = sqlite3_step(stmt); 237 } 238 return ret; 239 } 240 241 /** 242 * Closes the database and frees memory allocated for statements. 243 * 244 * @param context The current krb5 context 245 * @param db Heimdal database handle 246 */ 247 static krb5_error_code 248 hdb_sqlite_close_database(krb5_context context, HDB *db) 249 { 250 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db; 251 252 sqlite3_finalize(hsdb->get_version); 253 sqlite3_finalize(hsdb->fetch); 254 sqlite3_finalize(hsdb->get_ids); 255 sqlite3_finalize(hsdb->add_entry); 256 sqlite3_finalize(hsdb->add_principal); 257 sqlite3_finalize(hsdb->add_alias); 258 sqlite3_finalize(hsdb->delete_aliases); 259 sqlite3_finalize(hsdb->update_entry); 260 sqlite3_finalize(hsdb->remove); 261 sqlite3_finalize(hsdb->get_all_entries); 262 263 sqlite3_close(hsdb->db); 264 265 return 0; 266 } 267 268 /** 269 * Opens an sqlite database file and prepares it for use. 270 * If the file does not exist it will be created. 271 * 272 * @param context The current krb5_context 273 * @param db The heimdal database handle 274 * @param filename Where to store the database file 275 * 276 * @return 0 if everything worked, an error code if not 277 */ 278 static krb5_error_code 279 hdb_sqlite_make_database(krb5_context context, HDB *db, const char *filename) 280 { 281 int ret; 282 int created_file = 0; 283 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db; 284 285 hsdb->db_file = strdup(filename); 286 if(hsdb->db_file == NULL) 287 return ENOMEM; 288 289 ret = hdb_sqlite_open_database(context, db, 0); 290 if (ret) { 291 ret = hdb_sqlite_open_database(context, db, SQLITE_OPEN_CREATE); 292 if (ret) goto out; 293 294 created_file = 1; 295 296 ret = hdb_sqlite_exec_stmt(context, hsdb->db, 297 HDBSQLITE_CREATE_TABLES, 298 EINVAL); 299 if (ret) goto out; 300 301 ret = hdb_sqlite_exec_stmt(context, hsdb->db, 302 HDBSQLITE_CREATE_TRIGGERS, 303 EINVAL); 304 if (ret) goto out; 305 } 306 307 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 308 &hsdb->get_version, 309 HDBSQLITE_GET_VERSION); 310 if (ret) goto out; 311 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 312 &hsdb->fetch, 313 HDBSQLITE_FETCH); 314 if (ret) goto out; 315 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 316 &hsdb->get_ids, 317 HDBSQLITE_GET_IDS); 318 if (ret) goto out; 319 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 320 &hsdb->add_entry, 321 HDBSQLITE_ADD_ENTRY); 322 if (ret) goto out; 323 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 324 &hsdb->add_principal, 325 HDBSQLITE_ADD_PRINCIPAL); 326 if (ret) goto out; 327 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 328 &hsdb->add_alias, 329 HDBSQLITE_ADD_ALIAS); 330 if (ret) goto out; 331 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 332 &hsdb->delete_aliases, 333 HDBSQLITE_DELETE_ALIASES); 334 if (ret) goto out; 335 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 336 &hsdb->update_entry, 337 HDBSQLITE_UPDATE_ENTRY); 338 if (ret) goto out; 339 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 340 &hsdb->remove, 341 HDBSQLITE_REMOVE); 342 if (ret) goto out; 343 ret = hdb_sqlite_prepare_stmt(context, hsdb->db, 344 &hsdb->get_all_entries, 345 HDBSQLITE_GET_ALL_ENTRIES); 346 if (ret) goto out; 347 348 ret = hdb_sqlite_step(context, hsdb->db, hsdb->get_version); 349 if(ret == SQLITE_ROW) { 350 hsdb->version = sqlite3_column_double(hsdb->get_version, 0); 351 } 352 sqlite3_reset(hsdb->get_version); 353 ret = 0; 354 355 if(hsdb->version != HDBSQLITE_VERSION) { 356 ret = EINVAL; 357 krb5_set_error_message(context, ret, "HDBSQLITE_VERSION mismatch"); 358 } 359 360 if(ret) goto out; 361 362 return 0; 363 364 out: 365 if (hsdb->db) 366 sqlite3_close(hsdb->db); 367 if (created_file) 368 unlink(hsdb->db_file); 369 370 return ret; 371 } 372 373 /** 374 * Retrieves an entry by searching for the given 375 * principal in the Principal database table, both 376 * for canonical principals and aliases. 377 * 378 * @param context The current krb5_context 379 * @param db Heimdal database handle 380 * @param principal The principal whose entry to search for 381 * @param flags Currently only for HDB_F_DECRYPT 382 * @param kvno kvno to fetch is HDB_F_KVNO_SPECIFIED use used 383 * 384 * @return 0 if everything worked, an error code if not 385 */ 386 static krb5_error_code 387 hdb_sqlite_fetch_kvno(krb5_context context, HDB *db, krb5_const_principal principal, 388 unsigned flags, krb5_kvno kvno, hdb_entry_ex *entry) 389 { 390 int sqlite_error; 391 krb5_error_code ret; 392 char *principal_string; 393 hdb_sqlite_db *hsdb = (hdb_sqlite_db*)(db->hdb_db); 394 sqlite3_stmt *fetch = hsdb->fetch; 395 krb5_data value; 396 397 ret = krb5_unparse_name(context, principal, &principal_string); 398 if (ret) { 399 free(principal_string); 400 return ret; 401 } 402 403 sqlite3_bind_text(fetch, 1, principal_string, -1, SQLITE_STATIC); 404 405 sqlite_error = hdb_sqlite_step(context, hsdb->db, fetch); 406 if (sqlite_error != SQLITE_ROW) { 407 if(sqlite_error == SQLITE_DONE) { 408 ret = HDB_ERR_NOENTRY; 409 goto out; 410 } else { 411 ret = EINVAL; 412 krb5_set_error_message(context, ret, 413 "sqlite fetch failed: %d", 414 sqlite_error); 415 goto out; 416 } 417 } 418 419 value.length = sqlite3_column_bytes(fetch, 0); 420 value.data = (void *) sqlite3_column_blob(fetch, 0); 421 422 ret = hdb_value2entry(context, &value, &entry->entry); 423 if(ret) 424 goto out; 425 426 if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) { 427 ret = hdb_unseal_keys(context, db, &entry->entry); 428 if(ret) { 429 hdb_free_entry(context, entry); 430 goto out; 431 } 432 } 433 434 ret = 0; 435 436 out: 437 438 sqlite3_clear_bindings(fetch); 439 sqlite3_reset(fetch); 440 441 free(principal_string); 442 443 return ret; 444 } 445 446 /** 447 * Convenience function to step a prepared statement with no 448 * value once. 449 * 450 * @param context The current krb5_context 451 * @param statement A prepared sqlite3 statement 452 * 453 * @return 0 if everything worked, an error code if not 454 */ 455 static krb5_error_code 456 hdb_sqlite_step_once(krb5_context context, HDB *db, sqlite3_stmt *statement) 457 { 458 int ret; 459 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db; 460 461 ret = hdb_sqlite_step(context, hsdb->db, statement); 462 sqlite3_clear_bindings(statement); 463 sqlite3_reset(statement); 464 465 return ret; 466 } 467 468 469 /** 470 * Stores an hdb_entry in the database. If flags contains HDB_F_REPLACE 471 * a previous entry may be replaced. 472 * 473 * @param context The current krb5_context 474 * @param db Heimdal database handle 475 * @param flags May currently only contain HDB_F_REPLACE 476 * @param entry The data to store 477 * 478 * @return 0 if everything worked, an error code if not 479 */ 480 static krb5_error_code 481 hdb_sqlite_store(krb5_context context, HDB *db, unsigned flags, 482 hdb_entry_ex *entry) 483 { 484 int ret; 485 int i; 486 sqlite_int64 entry_id; 487 char *principal_string = NULL; 488 char *alias_string; 489 const HDB_Ext_Aliases *aliases; 490 491 hdb_sqlite_db *hsdb = (hdb_sqlite_db *)(db->hdb_db); 492 krb5_data value; 493 sqlite3_stmt *get_ids = hsdb->get_ids; 494 495 ret = hdb_sqlite_exec_stmt(context, hsdb->db, 496 "BEGIN IMMEDIATE TRANSACTION", EINVAL); 497 if(ret != SQLITE_OK) { 498 ret = EINVAL; 499 krb5_set_error_message(context, ret, 500 "SQLite BEGIN TRANSACTION failed: %s", 501 sqlite3_errmsg(hsdb->db)); 502 goto rollback; 503 } 504 505 ret = krb5_unparse_name(context, 506 entry->entry.principal, &principal_string); 507 if (ret) { 508 goto rollback; 509 } 510 511 ret = hdb_seal_keys(context, db, &entry->entry); 512 if(ret) { 513 goto rollback; 514 } 515 516 ret = hdb_entry2value(context, &entry->entry, &value); 517 if(ret) { 518 goto rollback; 519 } 520 521 sqlite3_bind_text(get_ids, 1, principal_string, -1, SQLITE_STATIC); 522 ret = hdb_sqlite_step(context, hsdb->db, get_ids); 523 524 if(ret == SQLITE_DONE) { /* No such principal */ 525 526 sqlite3_bind_blob(hsdb->add_entry, 1, 527 value.data, value.length, SQLITE_STATIC); 528 ret = hdb_sqlite_step(context, hsdb->db, hsdb->add_entry); 529 sqlite3_clear_bindings(hsdb->add_entry); 530 sqlite3_reset(hsdb->add_entry); 531 if(ret != SQLITE_DONE) 532 goto rollback; 533 534 sqlite3_bind_text(hsdb->add_principal, 1, 535 principal_string, -1, SQLITE_STATIC); 536 ret = hdb_sqlite_step(context, hsdb->db, hsdb->add_principal); 537 sqlite3_clear_bindings(hsdb->add_principal); 538 sqlite3_reset(hsdb->add_principal); 539 if(ret != SQLITE_DONE) 540 goto rollback; 541 542 entry_id = sqlite3_column_int64(get_ids, 1); 543 544 } else if(ret == SQLITE_ROW) { /* Found a principal */ 545 546 if(! (flags & HDB_F_REPLACE)) /* Not allowed to replace it */ 547 goto rollback; 548 549 entry_id = sqlite3_column_int64(get_ids, 1); 550 551 sqlite3_bind_int64(hsdb->delete_aliases, 1, entry_id); 552 ret = hdb_sqlite_step_once(context, db, hsdb->delete_aliases); 553 if(ret != SQLITE_DONE) 554 goto rollback; 555 556 sqlite3_bind_blob(hsdb->update_entry, 1, 557 value.data, value.length, SQLITE_STATIC); 558 sqlite3_bind_int64(hsdb->update_entry, 2, entry_id); 559 ret = hdb_sqlite_step_once(context, db, hsdb->update_entry); 560 if(ret != SQLITE_DONE) 561 goto rollback; 562 563 } else { 564 /* Error! */ 565 goto rollback; 566 } 567 568 ret = hdb_entry_get_aliases(&entry->entry, &aliases); 569 if(ret || aliases == NULL) 570 goto commit; 571 572 for(i = 0; i < aliases->aliases.len; i++) { 573 574 ret = krb5_unparse_name(context, &aliases->aliases.val[i], 575 &alias_string); 576 if (ret) { 577 free(alias_string); 578 goto rollback; 579 } 580 581 sqlite3_bind_text(hsdb->add_alias, 1, alias_string, 582 -1, SQLITE_STATIC); 583 sqlite3_bind_int64(hsdb->add_alias, 2, entry_id); 584 ret = hdb_sqlite_step_once(context, db, hsdb->add_alias); 585 586 free(alias_string); 587 588 if(ret != SQLITE_DONE) 589 goto rollback; 590 } 591 592 ret = 0; 593 594 commit: 595 596 free(principal_string); 597 598 krb5_data_free(&value); 599 600 sqlite3_clear_bindings(get_ids); 601 sqlite3_reset(get_ids); 602 603 ret = hdb_sqlite_exec_stmt(context, hsdb->db, "COMMIT", EINVAL); 604 if(ret != SQLITE_OK) 605 krb5_warnx(context, "hdb-sqlite: COMMIT problem: %d: %s", 606 ret, sqlite3_errmsg(hsdb->db)); 607 608 return ret; 609 610 rollback: 611 612 krb5_warnx(context, "hdb-sqlite: store rollback problem: %d: %s", 613 ret, sqlite3_errmsg(hsdb->db)); 614 615 free(principal_string); 616 617 ret = hdb_sqlite_exec_stmt(context, hsdb->db, 618 "ROLLBACK", EINVAL); 619 return ret; 620 } 621 622 /** 623 * This may be called often by other code, since the BDB backends 624 * can not have several open connections. SQLite can handle 625 * many processes with open handles to the database file 626 * and closing/opening the handle is an expensive operation. 627 * Hence, this function does nothing. 628 * 629 * @param context The current krb5 context 630 * @param db Heimdal database handle 631 * 632 * @return Always returns 0 633 */ 634 static krb5_error_code 635 hdb_sqlite_close(krb5_context context, HDB *db) 636 { 637 return 0; 638 } 639 640 /** 641 * The opposite of hdb_sqlite_close. Since SQLite accepts 642 * many open handles to the database file the handle does not 643 * need to be closed, or reopened. 644 * 645 * @param context The current krb5 context 646 * @param db Heimdal database handle 647 * @param flags 648 * @param mode_t 649 * 650 * @return Always returns 0 651 */ 652 static krb5_error_code 653 hdb_sqlite_open(krb5_context context, HDB *db, int flags, mode_t mode) 654 { 655 return 0; 656 } 657 658 /** 659 * Closes the databse and frees all resources. 660 * 661 * @param context The current krb5 context 662 * @param db Heimdal database handle 663 * 664 * @return 0 on success, an error code if not 665 */ 666 static krb5_error_code 667 hdb_sqlite_destroy(krb5_context context, HDB *db) 668 { 669 int ret; 670 hdb_sqlite_db *hsdb; 671 672 ret = hdb_clear_master_key(context, db); 673 674 hdb_sqlite_close_database(context, db); 675 676 hsdb = (hdb_sqlite_db*)(db->hdb_db); 677 678 free(hsdb->db_file); 679 free(db->hdb_db); 680 free(db); 681 682 return ret; 683 } 684 685 /* 686 * Not sure if this is needed. 687 */ 688 static krb5_error_code 689 hdb_sqlite_lock(krb5_context context, HDB *db, int operation) 690 { 691 krb5_set_error_message(context, HDB_ERR_CANT_LOCK_DB, 692 "lock not implemented"); 693 return HDB_ERR_CANT_LOCK_DB; 694 } 695 696 /* 697 * Not sure if this is needed. 698 */ 699 static krb5_error_code 700 hdb_sqlite_unlock(krb5_context context, HDB *db) 701 { 702 krb5_set_error_message(context, HDB_ERR_CANT_LOCK_DB, 703 "unlock not implemented"); 704 return HDB_ERR_CANT_LOCK_DB; 705 } 706 707 /* 708 * Should get the next entry, to allow iteration over all entries. 709 */ 710 static krb5_error_code 711 hdb_sqlite_nextkey(krb5_context context, HDB *db, unsigned flags, 712 hdb_entry_ex *entry) 713 { 714 krb5_error_code ret = 0; 715 int sqlite_error; 716 krb5_data value; 717 718 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db; 719 720 sqlite_error = hdb_sqlite_step(context, hsdb->db, hsdb->get_all_entries); 721 if(sqlite_error == SQLITE_ROW) { 722 /* Found an entry */ 723 value.length = sqlite3_column_bytes(hsdb->get_all_entries, 0); 724 value.data = (void *) sqlite3_column_blob(hsdb->get_all_entries, 0); 725 memset(entry, 0, sizeof(*entry)); 726 ret = hdb_value2entry(context, &value, &entry->entry); 727 } 728 else if(sqlite_error == SQLITE_DONE) { 729 /* No more entries */ 730 ret = HDB_ERR_NOENTRY; 731 sqlite3_reset(hsdb->get_all_entries); 732 } 733 else { 734 /* XXX SQLite error. Should be handled in some way. */ 735 ret = EINVAL; 736 } 737 738 return ret; 739 } 740 741 /* 742 * Should get the first entry in the database. 743 * What is flags used for? 744 */ 745 static krb5_error_code 746 hdb_sqlite_firstkey(krb5_context context, HDB *db, unsigned flags, 747 hdb_entry_ex *entry) 748 { 749 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db; 750 krb5_error_code ret; 751 752 sqlite3_reset(hsdb->get_all_entries); 753 754 ret = hdb_sqlite_nextkey(context, db, flags, entry); 755 if(ret) 756 return ret; 757 758 return 0; 759 } 760 761 /* 762 * Renames the database file. 763 */ 764 static krb5_error_code 765 hdb_sqlite_rename(krb5_context context, HDB *db, const char *new_name) 766 { 767 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db; 768 int ret; 769 770 krb5_warnx(context, "hdb_sqlite_rename"); 771 772 if (strncasecmp(new_name, "sqlite:", 7) == 0) 773 new_name += 7; 774 775 hdb_sqlite_close_database(context, db); 776 777 ret = rename(hsdb->db_file, new_name); 778 free(hsdb->db_file); 779 780 hdb_sqlite_make_database(context, db, new_name); 781 782 return ret; 783 } 784 785 /* 786 * Removes a principal, including aliases and associated entry. 787 */ 788 static krb5_error_code 789 hdb_sqlite_remove(krb5_context context, HDB *db, 790 krb5_const_principal principal) 791 { 792 krb5_error_code ret; 793 char *principal_string; 794 hdb_sqlite_db *hsdb = (hdb_sqlite_db*)(db->hdb_db); 795 sqlite3_stmt *remove = hsdb->remove; 796 797 ret = krb5_unparse_name(context, principal, &principal_string); 798 if (ret) { 799 free(principal_string); 800 return ret; 801 } 802 803 sqlite3_bind_text(remove, 1, principal_string, -1, SQLITE_STATIC); 804 805 ret = hdb_sqlite_step(context, hsdb->db, remove); 806 if (ret != SQLITE_DONE) { 807 ret = EINVAL; 808 krb5_set_error_message(context, ret, 809 "sqlite remove failed: %d", 810 ret); 811 } else 812 ret = 0; 813 814 sqlite3_clear_bindings(remove); 815 sqlite3_reset(remove); 816 817 return ret; 818 } 819 820 /** 821 * Create SQLITE object, and creates the on disk database if its doesn't exists. 822 * 823 * @param context A Kerberos 5 context. 824 * @param db a returned database handle. 825 * @param argument filename 826 * 827 * @return 0 on success, an error code if not 828 */ 829 830 krb5_error_code 831 hdb_sqlite_create(krb5_context context, HDB **db, const char *argument) 832 { 833 krb5_error_code ret; 834 hdb_sqlite_db *hsdb; 835 836 *db = calloc(1, sizeof (**db)); 837 if (*db == NULL) 838 return krb5_enomem(context); 839 840 hsdb = (hdb_sqlite_db*) calloc(1, sizeof (*hsdb)); 841 if (hsdb == NULL) { 842 free(*db); 843 *db = NULL; 844 return krb5_enomem(context); 845 } 846 847 (*db)->hdb_db = hsdb; 848 849 /* XXX make_database should make sure everything else is freed on error */ 850 ret = hdb_sqlite_make_database(context, *db, argument); 851 if (ret) { 852 free((*db)->hdb_db); 853 free(*db); 854 855 return ret; 856 } 857 858 (*db)->hdb_master_key_set = 0; 859 (*db)->hdb_openp = 0; 860 (*db)->hdb_capability_flags = 0; 861 862 (*db)->hdb_open = hdb_sqlite_open; 863 (*db)->hdb_close = hdb_sqlite_close; 864 865 (*db)->hdb_lock = hdb_sqlite_lock; 866 (*db)->hdb_unlock = hdb_sqlite_unlock; 867 (*db)->hdb_firstkey = hdb_sqlite_firstkey; 868 (*db)->hdb_nextkey = hdb_sqlite_nextkey; 869 (*db)->hdb_fetch_kvno = hdb_sqlite_fetch_kvno; 870 (*db)->hdb_store = hdb_sqlite_store; 871 (*db)->hdb_remove = hdb_sqlite_remove; 872 (*db)->hdb_destroy = hdb_sqlite_destroy; 873 (*db)->hdb_rename = hdb_sqlite_rename; 874 (*db)->hdb__get = NULL; 875 (*db)->hdb__put = NULL; 876 (*db)->hdb__del = NULL; 877 878 return 0; 879 } 880