source: heimdal/trunk/lib/hdb/hdb-sqlite.c

Last change on this file was 1, checked in by Paul Smedley, 10 years ago

Initial commit of Heimdal 1.5.3
File size: 25.3 KB
Line 
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
39typedef 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 */
125static krb5_error_code
126hdb_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 */
163static krb5_error_code
164hdb_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 */
200static krb5_error_code
201hdb_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
225static int
226hdb_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 */
247static krb5_error_code
248hdb_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 */
278static krb5_error_code
279hdb_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 */
386static krb5_error_code
387hdb_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
436out:
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 */
455static krb5_error_code
456hdb_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 */
480static krb5_error_code
481hdb_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
594commit:
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
610rollback:
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 */
634static krb5_error_code
635hdb_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 */
652static krb5_error_code
653hdb_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 */
666static krb5_error_code
667hdb_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 */
688static krb5_error_code
689hdb_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 */
699static krb5_error_code
700hdb_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 */
710static krb5_error_code
711hdb_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 */
745static krb5_error_code
746hdb_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 */
764static krb5_error_code
765hdb_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 */
788static krb5_error_code
789hdb_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
830krb5_error_code
831hdb_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}
Note: See TracBrowser for help on using the repository browser.