2 * Copyright (c) 2009 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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.
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.
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
37 #define MAX_RETRIES 10
39 typedef struct hdb_sqlite_db {
44 sqlite3_stmt *get_version;
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;
53 sqlite3_stmt *get_all_entries;
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
62 #define _HDBSQLITE_STRINGIFY(x) #x
63 #define HDBSQLITE_STRINGIFY(x) _HDBSQLITE_STRINGIFY(x)
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," \
75 " CREATE TABLE Entry" \
76 " (id INTEGER PRIMARY KEY," \
79 #define HDBSQLITE_CREATE_TRIGGERS \
80 " CREATE TRIGGER remove_principals AFTER DELETE ON Entry" \
82 " DELETE FROM Principal" \
83 " WHERE entry = OLD.id;" \
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)" \
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 = ?" \
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"
116 * Wrapper around sqlite3_prepare_v2.
118 * @param context The current krb5 context
119 * @param statement Where to store the pointer to the statement
121 * @param str SQL code for the statement
123 * @return 0 if OK, an error code if not
125 static krb5_error_code
126 hdb_sqlite_prepare_stmt(krb5_context context,
128 sqlite3_stmt **statement,
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");
140 ret = sqlite3_prepare_v2(db, str, -1, statement, NULL);
143 if (ret != SQLITE_OK) {
144 krb5_set_error_message(context, EINVAL,
145 "Failed to prepare stmt %s: %s",
146 str, sqlite3_errmsg(db));
154 * A wrapper around sqlite3_exec.
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
161 * @return 0 if OK, else error_code
163 static krb5_error_code
164 hdb_sqlite_exec_stmt(krb5_context context,
166 const char *statement,
167 krb5_error_code error_code)
171 ret = sqlite3_exec(database, statement, NULL, NULL, NULL);
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());
178 ret = sqlite3_exec(database, statement, NULL, NULL, NULL);
181 if (ret != SQLITE_OK && error_code) {
182 krb5_set_error_message(context, error_code,
183 "Execute %s: %s", statement,
184 sqlite3_errmsg(database));
192 * Opens an sqlite3 database handle to a file, may create the
193 * database file depending on flags.
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
200 static krb5_error_code
201 hdb_sqlite_open_database(krb5_context context, HDB *db, int flags)
204 hdb_sqlite_db *hsdb = (hdb_sqlite_db*) db->hdb_db;
206 ret = sqlite3_open_v2(hsdb->db_file, &hsdb->db,
207 SQLITE_OPEN_READWRITE | flags, NULL);
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);
218 ret = krb5_enomem(context);
226 hdb_sqlite_step(krb5_context context, sqlite3 *db, sqlite3_stmt *stmt)
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());
236 ret = sqlite3_step(stmt);
242 * Closes the database and frees memory allocated for statements.
244 * @param context The current krb5 context
245 * @param db Heimdal database handle
247 static krb5_error_code
248 hdb_sqlite_close_database(krb5_context context, HDB *db)
250 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
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);
263 sqlite3_close(hsdb->db);
269 * Opens an sqlite database file and prepares it for use.
270 * If the file does not exist it will be created.
272 * @param context The current krb5_context
273 * @param db The heimdal database handle
274 * @param filename Where to store the database file
276 * @return 0 if everything worked, an error code if not
278 static krb5_error_code
279 hdb_sqlite_make_database(krb5_context context, HDB *db, const char *filename)
282 int created_file = 0;
283 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
285 hsdb->db_file = strdup(filename);
286 if(hsdb->db_file == NULL)
289 ret = hdb_sqlite_open_database(context, db, 0);
291 ret = hdb_sqlite_open_database(context, db, SQLITE_OPEN_CREATE);
296 ret = hdb_sqlite_exec_stmt(context, hsdb->db,
297 HDBSQLITE_CREATE_TABLES,
301 ret = hdb_sqlite_exec_stmt(context, hsdb->db,
302 HDBSQLITE_CREATE_TRIGGERS,
307 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
309 HDBSQLITE_GET_VERSION);
311 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
315 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
319 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
321 HDBSQLITE_ADD_ENTRY);
323 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
324 &hsdb->add_principal,
325 HDBSQLITE_ADD_PRINCIPAL);
327 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
329 HDBSQLITE_ADD_ALIAS);
331 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
332 &hsdb->delete_aliases,
333 HDBSQLITE_DELETE_ALIASES);
335 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
337 HDBSQLITE_UPDATE_ENTRY);
339 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
343 ret = hdb_sqlite_prepare_stmt(context, hsdb->db,
344 &hsdb->get_all_entries,
345 HDBSQLITE_GET_ALL_ENTRIES);
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);
352 sqlite3_reset(hsdb->get_version);
355 if(hsdb->version != HDBSQLITE_VERSION) {
357 krb5_set_error_message(context, ret, "HDBSQLITE_VERSION mismatch");
366 sqlite3_close(hsdb->db);
368 unlink(hsdb->db_file);
374 * Retrieves an entry by searching for the given
375 * principal in the Principal database table, both
376 * for canonical principals and aliases.
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
384 * @return 0 if everything worked, an error code if not
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)
392 char *principal_string;
393 hdb_sqlite_db *hsdb = (hdb_sqlite_db*)(db->hdb_db);
394 sqlite3_stmt *fetch = hsdb->fetch;
397 ret = krb5_unparse_name(context, principal, &principal_string);
399 free(principal_string);
403 sqlite3_bind_text(fetch, 1, principal_string, -1, SQLITE_STATIC);
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;
412 krb5_set_error_message(context, ret,
413 "sqlite fetch failed: %d",
419 value.length = sqlite3_column_bytes(fetch, 0);
420 value.data = (void *) sqlite3_column_blob(fetch, 0);
422 ret = hdb_value2entry(context, &value, &entry->entry);
426 if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
427 ret = hdb_unseal_keys(context, db, &entry->entry);
429 hdb_free_entry(context, entry);
438 sqlite3_clear_bindings(fetch);
439 sqlite3_reset(fetch);
441 free(principal_string);
447 * Convenience function to step a prepared statement with no
450 * @param context The current krb5_context
451 * @param statement A prepared sqlite3 statement
453 * @return 0 if everything worked, an error code if not
455 static krb5_error_code
456 hdb_sqlite_step_once(krb5_context context, HDB *db, sqlite3_stmt *statement)
459 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
461 ret = hdb_sqlite_step(context, hsdb->db, statement);
462 sqlite3_clear_bindings(statement);
463 sqlite3_reset(statement);
470 * Stores an hdb_entry in the database. If flags contains HDB_F_REPLACE
471 * a previous entry may be replaced.
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
478 * @return 0 if everything worked, an error code if not
480 static krb5_error_code
481 hdb_sqlite_store(krb5_context context, HDB *db, unsigned flags,
486 sqlite_int64 entry_id;
487 char *principal_string = NULL;
489 const HDB_Ext_Aliases *aliases;
491 hdb_sqlite_db *hsdb = (hdb_sqlite_db *)(db->hdb_db);
493 sqlite3_stmt *get_ids = hsdb->get_ids;
495 ret = hdb_sqlite_exec_stmt(context, hsdb->db,
496 "BEGIN IMMEDIATE TRANSACTION", EINVAL);
497 if(ret != SQLITE_OK) {
499 krb5_set_error_message(context, ret,
500 "SQLite BEGIN TRANSACTION failed: %s",
501 sqlite3_errmsg(hsdb->db));
505 ret = krb5_unparse_name(context,
506 entry->entry.principal, &principal_string);
511 ret = hdb_seal_keys(context, db, &entry->entry);
516 ret = hdb_entry2value(context, &entry->entry, &value);
521 sqlite3_bind_text(get_ids, 1, principal_string, -1, SQLITE_STATIC);
522 ret = hdb_sqlite_step(context, hsdb->db, get_ids);
524 if(ret == SQLITE_DONE) { /* No such principal */
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)
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)
542 entry_id = sqlite3_column_int64(get_ids, 1);
544 } else if(ret == SQLITE_ROW) { /* Found a principal */
546 if(! (flags & HDB_F_REPLACE)) /* Not allowed to replace it */
549 entry_id = sqlite3_column_int64(get_ids, 1);
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)
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)
568 ret = hdb_entry_get_aliases(&entry->entry, &aliases);
569 if(ret || aliases == NULL)
572 for(i = 0; i < aliases->aliases.len; i++) {
574 ret = krb5_unparse_name(context, &aliases->aliases.val[i],
581 sqlite3_bind_text(hsdb->add_alias, 1, alias_string,
583 sqlite3_bind_int64(hsdb->add_alias, 2, entry_id);
584 ret = hdb_sqlite_step_once(context, db, hsdb->add_alias);
588 if(ret != SQLITE_DONE)
596 free(principal_string);
598 krb5_data_free(&value);
600 sqlite3_clear_bindings(get_ids);
601 sqlite3_reset(get_ids);
603 ret = hdb_sqlite_exec_stmt(context, hsdb->db, "COMMIT", EINVAL);
605 krb5_warnx(context, "hdb-sqlite: COMMIT problem: %d: %s",
606 ret, sqlite3_errmsg(hsdb->db));
612 krb5_warnx(context, "hdb-sqlite: store rollback problem: %d: %s",
613 ret, sqlite3_errmsg(hsdb->db));
615 free(principal_string);
617 ret = hdb_sqlite_exec_stmt(context, hsdb->db,
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.
629 * @param context The current krb5 context
630 * @param db Heimdal database handle
632 * @return Always returns 0
634 static krb5_error_code
635 hdb_sqlite_close(krb5_context context, HDB *db)
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.
645 * @param context The current krb5 context
646 * @param db Heimdal database handle
650 * @return Always returns 0
652 static krb5_error_code
653 hdb_sqlite_open(krb5_context context, HDB *db, int flags, mode_t mode)
659 * Closes the databse and frees all resources.
661 * @param context The current krb5 context
662 * @param db Heimdal database handle
664 * @return 0 on success, an error code if not
666 static krb5_error_code
667 hdb_sqlite_destroy(krb5_context context, HDB *db)
672 ret = hdb_clear_master_key(context, db);
674 hdb_sqlite_close_database(context, db);
676 hsdb = (hdb_sqlite_db*)(db->hdb_db);
686 * Not sure if this is needed.
688 static krb5_error_code
689 hdb_sqlite_lock(krb5_context context, HDB *db, int operation)
691 krb5_set_error_message(context, HDB_ERR_CANT_LOCK_DB,
692 "lock not implemented");
693 return HDB_ERR_CANT_LOCK_DB;
697 * Not sure if this is needed.
699 static krb5_error_code
700 hdb_sqlite_unlock(krb5_context context, HDB *db)
702 krb5_set_error_message(context, HDB_ERR_CANT_LOCK_DB,
703 "unlock not implemented");
704 return HDB_ERR_CANT_LOCK_DB;
708 * Should get the next entry, to allow iteration over all entries.
710 static krb5_error_code
711 hdb_sqlite_nextkey(krb5_context context, HDB *db, unsigned flags,
714 krb5_error_code ret = 0;
718 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
720 sqlite_error = hdb_sqlite_step(context, hsdb->db, hsdb->get_all_entries);
721 if(sqlite_error == SQLITE_ROW) {
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);
728 else if(sqlite_error == SQLITE_DONE) {
729 /* No more entries */
730 ret = HDB_ERR_NOENTRY;
731 sqlite3_reset(hsdb->get_all_entries);
734 /* XXX SQLite error. Should be handled in some way. */
742 * Should get the first entry in the database.
743 * What is flags used for?
745 static krb5_error_code
746 hdb_sqlite_firstkey(krb5_context context, HDB *db, unsigned flags,
749 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
752 sqlite3_reset(hsdb->get_all_entries);
754 ret = hdb_sqlite_nextkey(context, db, flags, entry);
762 * Renames the database file.
764 static krb5_error_code
765 hdb_sqlite_rename(krb5_context context, HDB *db, const char *new_name)
767 hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db;
770 krb5_warnx(context, "hdb_sqlite_rename");
772 if (strncasecmp(new_name, "sqlite:", 7) == 0)
775 hdb_sqlite_close_database(context, db);
777 ret = rename(hsdb->db_file, new_name);
780 hdb_sqlite_make_database(context, db, new_name);
786 * Removes a principal, including aliases and associated entry.
788 static krb5_error_code
789 hdb_sqlite_remove(krb5_context context, HDB *db,
790 krb5_const_principal principal)
793 char *principal_string;
794 hdb_sqlite_db *hsdb = (hdb_sqlite_db*)(db->hdb_db);
795 sqlite3_stmt *remove = hsdb->remove;
797 ret = krb5_unparse_name(context, principal, &principal_string);
799 free(principal_string);
803 sqlite3_bind_text(remove, 1, principal_string, -1, SQLITE_STATIC);
805 ret = hdb_sqlite_step(context, hsdb->db, remove);
806 if (ret != SQLITE_DONE) {
808 krb5_set_error_message(context, ret,
809 "sqlite remove failed: %d",
814 sqlite3_clear_bindings(remove);
815 sqlite3_reset(remove);
821 * Create SQLITE object, and creates the on disk database if its doesn't exists.
823 * @param context A Kerberos 5 context.
824 * @param db a returned database handle.
825 * @param argument filename
827 * @return 0 on success, an error code if not
831 hdb_sqlite_create(krb5_context context, HDB **db, const char *argument)
836 *db = calloc(1, sizeof (**db));
838 return krb5_enomem(context);
840 hsdb = (hdb_sqlite_db*) calloc(1, sizeof (*hsdb));
844 return krb5_enomem(context);
847 (*db)->hdb_db = hsdb;
849 /* XXX make_database should make sure everything else is freed on error */
850 ret = hdb_sqlite_make_database(context, *db, argument);
858 (*db)->hdb_master_key_set = 0;
859 (*db)->hdb_openp = 0;
860 (*db)->hdb_capability_flags = 0;
862 (*db)->hdb_open = hdb_sqlite_open;
863 (*db)->hdb_close = hdb_sqlite_close;
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;