d0573d389e91e7b8241b5e375d41a09efb232378
[ira/wip.git] / source4 / lib / ldb / ldb_sqlite3 / ldb_sqlite3.c
1 /*
2    ldb database library
3
4    Copyright (C) Derrell Lipman  2005
5    Copyright (C) Simo Sorce 2005-2009
6
7    ** NOTE! The following LGPL license applies to the ldb
8    ** library. This does NOT imply that all of Samba is released
9    ** under the LGPL
10
11    This library is free software; you can redistribute it and/or
12    modify it under the terms of the GNU Lesser General Public
13    License as published by the Free Software Foundation; either
14    version 3 of the License, or (at your option) any later version.
15
16    This library is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19    Lesser General Public License for more details.
20
21    You should have received a copy of the GNU Lesser General Public
22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 */
24
25 /*
26  *  Name: ldb
27  *
28  *  Component: ldb sqlite3 backend
29  *
30  *  Description: core files for SQLITE3 backend
31  *
32  *  Author: Derrell Lipman (based on Andrew Tridgell's LDAP backend)
33  */
34
35 #include "ldb_module.h"
36
37 #include <sqlite3.h>
38
39 struct lsqlite3_private {
40         int trans_count;
41         char **options;
42         sqlite3 *sqlite;
43 };
44
45 struct lsql_context {
46         struct ldb_module *module;
47         struct ldb_request *req;
48
49         /* search stuff */
50         long long current_eid;
51         const char * const * attrs;
52         struct ldb_reply *ares;
53
54         bool callback_failed;
55         struct tevent_timer *timeout_event;
56 };
57
58 /*
59  * Macros used throughout
60  */
61
62 #ifndef FALSE
63 # define FALSE  (0)
64 # define TRUE   (! FALSE)
65 #endif
66
67 #define RESULT_ATTR_TABLE       "temp_result_attrs"
68
69
70 /* for testing, define to nothing, (create non-temporary table) */
71 #define TEMPTAB                 "TEMPORARY"
72
73 /*
74  * Static variables
75  */
76 sqlite3_stmt *  stmtGetEID = NULL;
77
78 static char *lsqlite3_tprintf(TALLOC_CTX *mem_ctx, const char *fmt, ...)
79 {
80         char *str, *ret;
81         va_list ap;
82
83         va_start(ap, fmt);
84         str = sqlite3_vmprintf(fmt, ap);
85         va_end(ap);
86
87         if (str == NULL) return NULL;
88
89         ret = talloc_strdup(mem_ctx, str);
90         if (ret == NULL) {
91                 sqlite3_free(str);
92                 return NULL;
93         }
94
95         sqlite3_free(str);
96         return ret;
97 }
98
99 static char base160tab[161] = {
100         48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 , /* 0-9 */
101         58 ,59 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 , /* : ; A-H */
102         73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 , /* I-R */
103         83 ,84 ,85 ,86 ,87 ,88 ,89 ,90 ,97 ,98 , /* S-Z , a-b */
104         99 ,100,101,102,103,104,105,106,107,108, /* c-l */
105         109,110,111,112,113,114,115,116,117,118, /* m-v */
106         119,120,121,122,160,161,162,163,164,165, /* w-z, latin1 */
107         166,167,168,169,170,171,172,173,174,175, /* latin1 */
108         176,177,178,179,180,181,182,183,184,185, /* latin1 */
109         186,187,188,189,190,191,192,193,194,195, /* latin1 */
110         196,197,198,199,200,201,202,203,204,205, /* latin1 */
111         206,207,208,209,210,211,212,213,214,215, /* latin1 */
112         216,217,218,219,220,221,222,223,224,225, /* latin1 */
113         226,227,228,229,230,231,232,233,234,235, /* latin1 */
114         236,237,238,239,240,241,242,243,244,245, /* latin1 */
115         246,247,248,249,250,251,252,253,254,255, /* latin1 */
116         '\0'
117 };
118
119
120 /*
121  * base160()
122  *
123  * Convert an unsigned long integer into a base160 representation of the
124  * number.
125  *
126  * Parameters:
127  *   val --
128  *     value to be converted
129  *
130  *   result --
131  *     character array, 5 bytes long, into which the base160 representation
132  *     will be placed.  The result will be a four-digit representation of the
133  *     number (with leading zeros prepended as necessary), and null
134  *     terminated.
135  *
136  * Returns:
137  *   Nothing
138  */
139 static void
140 base160_sql(sqlite3_context * hContext,
141             int argc,
142             sqlite3_value ** argv)
143 {
144     int             i;
145     long long       val;
146     char            result[5];
147
148     val = sqlite3_value_int64(argv[0]);
149
150     for (i = 3; i >= 0; i--) {
151
152         result[i] = base160tab[val % 160];
153         val /= 160;
154     }
155
156     result[4] = '\0';
157
158     sqlite3_result_text(hContext, result, -1, SQLITE_TRANSIENT);
159 }
160
161
162 /*
163  * base160next_sql()
164  *
165  * This function enhances sqlite by adding a "base160_next()" function which is
166  * accessible via queries.
167  *
168  * Retrieve the next-greater number in the base160 sequence for the terminal
169  * tree node (the last four digits).  Only one tree level (four digits) is
170  * operated on.
171  *
172  * Input:
173  *   A character string: either an empty string (in which case no operation is
174  *   performed), or a string of base160 digits with a length of a multiple of
175  *   four digits.
176  *
177  * Output:
178  *   Upon return, the trailing four digits (one tree level) will have been
179  *   incremented by 1.
180  */
181 static void
182 base160next_sql(sqlite3_context * hContext,
183                 int argc,
184                 sqlite3_value ** argv)
185 {
186         int                         i;
187         int                         len;
188         char *             pTab;
189         char *             pBase160 = strdup((const char *)sqlite3_value_text(argv[0]));
190         char *             pStart = pBase160;
191
192         /*
193          * We need a minimum of four digits, and we will always get a multiple
194          * of four digits.
195          */
196         if (pBase160 != NULL &&
197             (len = strlen(pBase160)) >= 4 &&
198             len % 4 == 0) {
199
200                 if (pBase160 == NULL) {
201
202                         sqlite3_result_null(hContext);
203                         return;
204                 }
205
206                 pBase160 += strlen(pBase160) - 1;
207
208                 /* We only carry through four digits: one level in the tree */
209                 for (i = 0; i < 4; i++) {
210
211                         /* What base160 value does this digit have? */
212                         pTab = strchr(base160tab, *pBase160);
213
214                         /* Is there a carry? */
215                         if (pTab < base160tab + sizeof(base160tab) - 1) {
216
217                                 /*
218                                  * Nope.  Just increment this value and we're
219                                  * done.
220                                  */
221                                 *pBase160 = *++pTab;
222                                 break;
223                         } else {
224
225                                 /*
226                                  * There's a carry.  This value gets
227                                  * base160tab[0], we decrement the buffer
228                                  * pointer to get the next higher-order digit,
229                                  * and continue in the loop.
230                                  */
231                                 *pBase160-- = base160tab[0];
232                         }
233                 }
234
235                 sqlite3_result_text(hContext,
236                                     pStart,
237                                     strlen(pStart),
238                                     free);
239         } else {
240                 sqlite3_result_value(hContext, argv[0]);
241                 if (pBase160 != NULL) {
242                         free(pBase160);
243                 }
244         }
245 }
246
247 static char *parsetree_to_sql(struct ldb_module *module,
248                               void *mem_ctx,
249                               const struct ldb_parse_tree *t)
250 {
251         struct ldb_context *ldb;
252         const struct ldb_schema_attribute *a;
253         struct ldb_val value, subval;
254         char *wild_card_string;
255         char *child, *tmp;
256         char *ret = NULL;
257         char *attr;
258         int i;
259
260         ldb = ldb_module_get_ctx(module);
261
262         switch(t->operation) {
263         case LDB_OP_AND:
264
265                 tmp = parsetree_to_sql(module, mem_ctx, t->u.list.elements[0]);
266                 if (tmp == NULL) return NULL;
267
268                 for (i = 1; i < t->u.list.num_elements; i++) {
269
270                         child = parsetree_to_sql(module, mem_ctx, t->u.list.elements[i]);
271                         if (child == NULL) return NULL;
272
273                         tmp = talloc_asprintf_append(tmp, " INTERSECT %s ", child);
274                         if (tmp == NULL) return NULL;
275                 }
276
277                 ret = talloc_asprintf(mem_ctx, "SELECT * FROM ( %s )\n", tmp);
278
279                 return ret;
280
281         case LDB_OP_OR:
282
283                 tmp = parsetree_to_sql(module, mem_ctx, t->u.list.elements[0]);
284                 if (tmp == NULL) return NULL;
285
286                 for (i = 1; i < t->u.list.num_elements; i++) {
287
288                         child = parsetree_to_sql(module, mem_ctx, t->u.list.elements[i]);
289                         if (child == NULL) return NULL;
290
291                         tmp = talloc_asprintf_append(tmp, " UNION %s ", child);
292                         if (tmp == NULL) return NULL;
293                 }
294
295                 return talloc_asprintf(mem_ctx, "SELECT * FROM ( %s ) ", tmp);
296
297         case LDB_OP_NOT:
298
299                 child = parsetree_to_sql(module, mem_ctx, t->u.isnot.child);
300                 if (child == NULL) return NULL;
301
302                 return talloc_asprintf(mem_ctx,
303                                         "SELECT eid FROM ldb_entry "
304                                         "WHERE eid NOT IN ( %s ) ", child);
305
306         case LDB_OP_EQUALITY:
307                 /*
308                  * For simple searches, we want to retrieve the list of EIDs that
309                  * match the criteria.
310                 */
311                 attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
312                 if (attr == NULL) return NULL;
313                 a = ldb_schema_attribute_by_name(ldb, attr);
314
315                 /* Get a canonicalised copy of the data */
316                 a->syntax->canonicalise_fn(ldb, mem_ctx, &(t->u.equality.value), &value);
317                 if (value.data == NULL) {
318                         return NULL;
319                 }
320
321                 if (strcasecmp(t->u.equality.attr, "dn") == 0) {
322                         /* DN query is a special ldb case */
323                         const char *cdn = ldb_dn_get_casefold(
324                                                 ldb_dn_new(mem_ctx, ldb,
325                                                               (const char *)value.data));
326
327                         return lsqlite3_tprintf(mem_ctx,
328                                                 "SELECT eid FROM ldb_entry "
329                                                 "WHERE norm_dn = '%q'", cdn);
330
331                 } else {
332                         /* A normal query. */
333                         return lsqlite3_tprintf(mem_ctx,
334                                                 "SELECT eid FROM ldb_attribute_values "
335                                                 "WHERE norm_attr_name = '%q' "
336                                                 "AND norm_attr_value = '%q'",
337                                                 attr,
338                                                 value.data);
339
340                 }
341
342         case LDB_OP_SUBSTRING:
343
344                 wild_card_string = talloc_strdup(mem_ctx,
345                                         (t->u.substring.start_with_wildcard)?"*":"");
346                 if (wild_card_string == NULL) return NULL;
347
348                 for (i = 0; t->u.substring.chunks[i]; i++) {
349                         wild_card_string = talloc_asprintf_append(wild_card_string, "%s*",
350                                                         t->u.substring.chunks[i]->data);
351                         if (wild_card_string == NULL) return NULL;
352                 }
353
354                 if ( ! t->u.substring.end_with_wildcard ) {
355                         /* remove last wildcard */
356                         wild_card_string[strlen(wild_card_string) - 1] = '\0';
357                 }
358
359                 attr = ldb_attr_casefold(mem_ctx, t->u.substring.attr);
360                 if (attr == NULL) return NULL;
361                 a = ldb_schema_attribute_by_name(ldb, attr);
362
363                 subval.data = (void *)wild_card_string;
364                 subval.length = strlen(wild_card_string) + 1;
365
366                 /* Get a canonicalised copy of the data */
367                 a->syntax->canonicalise_fn(ldb, mem_ctx, &(subval), &value);
368                 if (value.data == NULL) {
369                         return NULL;
370                 }
371
372                 return lsqlite3_tprintf(mem_ctx,
373                                         "SELECT eid FROM ldb_attribute_values "
374                                         "WHERE norm_attr_name = '%q' "
375                                         "AND norm_attr_value GLOB '%q'",
376                                         attr,
377                                         value.data);
378
379         case LDB_OP_GREATER:
380                 attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
381                 if (attr == NULL) return NULL;
382                 a = ldb_schema_attribute_by_name(ldb, attr);
383
384                 /* Get a canonicalised copy of the data */
385                 a->syntax->canonicalise_fn(ldb, mem_ctx, &(t->u.equality.value), &value);
386                 if (value.data == NULL) {
387                         return NULL;
388                 }
389
390                 return lsqlite3_tprintf(mem_ctx,
391                                         "SELECT eid FROM ldb_attribute_values "
392                                         "WHERE norm_attr_name = '%q' "
393                                         "AND ldap_compare(norm_attr_value, '>=', '%q', '%q') ",
394                                         attr,
395                                         value.data,
396                                         attr);
397
398         case LDB_OP_LESS:
399                 attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
400                 if (attr == NULL) return NULL;
401                 a = ldb_schema_attribute_by_name(ldb, attr);
402
403                 /* Get a canonicalised copy of the data */
404                 a->syntax->canonicalise_fn(ldb, mem_ctx, &(t->u.equality.value), &value);
405                 if (value.data == NULL) {
406                         return NULL;
407                 }
408
409                 return lsqlite3_tprintf(mem_ctx,
410                                         "SELECT eid FROM ldb_attribute_values "
411                                         "WHERE norm_attr_name = '%q' "
412                                         "AND ldap_compare(norm_attr_value, '<=', '%q', '%q') ",
413                                         attr,
414                                         value.data,
415                                         attr);
416
417         case LDB_OP_PRESENT:
418                 if (strcasecmp(t->u.present.attr, "dn") == 0) {
419                         return talloc_strdup(mem_ctx, "SELECT eid FROM ldb_entry");
420                 }
421
422                 attr = ldb_attr_casefold(mem_ctx, t->u.present.attr);
423                 if (attr == NULL) return NULL;
424
425                 return lsqlite3_tprintf(mem_ctx,
426                                         "SELECT eid FROM ldb_attribute_values "
427                                         "WHERE norm_attr_name = '%q' ",
428                                         attr);
429
430         case LDB_OP_APPROX:
431                 attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
432                 if (attr == NULL) return NULL;
433                 a = ldb_schema_attribute_by_name(ldb, attr);
434
435                 /* Get a canonicalised copy of the data */
436                 a->syntax->canonicalise_fn(ldb, mem_ctx, &(t->u.equality.value), &value);
437                 if (value.data == NULL) {
438                         return NULL;
439                 }
440
441                 return lsqlite3_tprintf(mem_ctx,
442                                         "SELECT eid FROM ldb_attribute_values "
443                                         "WHERE norm_attr_name = '%q' "
444                                         "AND ldap_compare(norm_attr_value, '~%', 'q', '%q') ",
445                                         attr,
446                                         value.data,
447                                         attr);
448
449         case LDB_OP_EXTENDED:
450 #warning  "work out how to handle bitops"
451                 return NULL;
452
453         default:
454                 break;
455         };
456
457         /* should never occur */
458         abort();
459         return NULL;
460 }
461
462 /*
463  * query_int()
464  *
465  * This function is used for the common case of queries that return a single
466  * integer value.
467  *
468  * NOTE: If more than one value is returned by the query, all but the first
469  * one will be ignored.
470  */
471 static int
472 query_int(const struct lsqlite3_private * lsqlite3,
473           long long * pRet,
474           const char * pSql,
475           ...)
476 {
477         int             ret;
478         int             bLoop;
479         char *          p;
480         sqlite3_stmt *  pStmt;
481         va_list         args;
482
483         /* Begin access to variable argument list */
484         va_start(args, pSql);
485
486         /* Format the query */
487         if ((p = sqlite3_vmprintf(pSql, args)) == NULL) {
488                 va_end(args);
489                 return SQLITE_NOMEM;
490         }
491
492         /*
493          * Prepare and execute the SQL statement.  Loop allows retrying on
494          * certain errors, e.g. SQLITE_SCHEMA occurs if the schema changes,
495          * requiring retrying the operation.
496          */
497         for (bLoop = TRUE; bLoop; ) {
498
499                 /* Compile the SQL statement into sqlite virtual machine */
500                 if ((ret = sqlite3_prepare(lsqlite3->sqlite,
501                                            p,
502                                            -1,
503                                            &pStmt,
504                                            NULL)) == SQLITE_SCHEMA) {
505                         if (stmtGetEID != NULL) {
506                                 sqlite3_finalize(stmtGetEID);
507                                 stmtGetEID = NULL;
508                         }
509                         continue;
510                 } else if (ret != SQLITE_OK) {
511                         break;
512                 }
513
514                 /* One row expected */
515                 if ((ret = sqlite3_step(pStmt)) == SQLITE_SCHEMA) {
516                         if (stmtGetEID != NULL) {
517                                 sqlite3_finalize(stmtGetEID);
518                                 stmtGetEID = NULL;
519                         }
520                         (void) sqlite3_finalize(pStmt);
521                         continue;
522                 } else if (ret != SQLITE_ROW) {
523                         (void) sqlite3_finalize(pStmt);
524                         break;
525                 }
526
527                 /* Get the value to be returned */
528                 *pRet = sqlite3_column_int64(pStmt, 0);
529
530                 /* Free the virtual machine */
531                 if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
532                         if (stmtGetEID != NULL) {
533                                 sqlite3_finalize(stmtGetEID);
534                                 stmtGetEID = NULL;
535                         }
536                         continue;
537                 } else if (ret != SQLITE_OK) {
538                         (void) sqlite3_finalize(pStmt);
539                         break;
540                 }
541
542                 /*
543                  * Normal condition is only one time through loop.  Loop is
544                  * rerun in error conditions, via "continue", above.
545                  */
546                 bLoop = FALSE;
547         }
548
549         /* All done with variable argument list */
550         va_end(args);
551
552
553         /* Free the memory we allocated for our query string */
554         sqlite3_free(p);
555
556         return ret;
557 }
558
559 /*
560  * This is a bad hack to support ldap style comparisons whithin sqlite.
561  * val is the attribute in the row currently under test
562  * func is the desired test "<=" ">=" "~" ":"
563  * cmp is the value to compare against (eg: "test")
564  * attr is the attribute name the value of which we want to test
565  */
566
567 static void lsqlite3_compare(sqlite3_context *ctx, int argc,
568                                         sqlite3_value **argv)
569 {
570         struct ldb_context *ldb = (struct ldb_context *)sqlite3_user_data(ctx);
571         const char *val = (const char *)sqlite3_value_text(argv[0]);
572         const char *func = (const char *)sqlite3_value_text(argv[1]);
573         const char *cmp = (const char *)sqlite3_value_text(argv[2]);
574         const char *attr = (const char *)sqlite3_value_text(argv[3]);
575         const struct ldb_schema_attribute *a;
576         struct ldb_val valX;
577         struct ldb_val valY;
578         int ret;
579
580         switch (func[0]) {
581         /* greater */
582         case '>': /* >= */
583                 a = ldb_schema_attribute_by_name(ldb, attr);
584                 valX.data = (uint8_t *)cmp;
585                 valX.length = strlen(cmp);
586                 valY.data = (uint8_t *)val;
587                 valY.length = strlen(val);
588                 ret = a->syntax->comparison_fn(ldb, ldb, &valY, &valX);
589                 if (ret >= 0)
590                         sqlite3_result_int(ctx, 1);
591                 else
592                         sqlite3_result_int(ctx, 0);
593                 return;
594
595         /* lesser */
596         case '<': /* <= */
597                 a = ldb_schema_attribute_by_name(ldb, attr);
598                 valX.data = (uint8_t *)cmp;
599                 valX.length = strlen(cmp);
600                 valY.data = (uint8_t *)val;
601                 valY.length = strlen(val);
602                 ret = a->syntax->comparison_fn(ldb, ldb, &valY, &valX);
603                 if (ret <= 0)
604                         sqlite3_result_int(ctx, 1);
605                 else
606                         sqlite3_result_int(ctx, 0);
607                 return;
608
609         /* approx */
610         case '~':
611                 /* TODO */
612                 sqlite3_result_int(ctx, 0);
613                 return;
614
615         /* bitops */
616         case ':':
617                 /* TODO */
618                 sqlite3_result_int(ctx, 0);
619                 return;
620
621         default:
622                 break;
623         }
624
625         sqlite3_result_error(ctx, "Value must start with a special operation char (<>~:)!", -1);
626         return;
627 }
628
629
630 /* rename a record */
631 static int lsqlite3_safe_rollback(sqlite3 *sqlite)
632 {
633         char *errmsg;
634         int ret;
635
636         /* execute */
637         ret = sqlite3_exec(sqlite, "ROLLBACK;", NULL, NULL, &errmsg);
638         if (ret != SQLITE_OK) {
639                 if (errmsg) {
640                         printf("lsqlite3_safe_rollback: Error: %s\n", errmsg);
641                         free(errmsg);
642                 }
643                 return -1;
644         }
645
646         return 0;
647 }
648
649 /* return an eid as result */
650 static int lsqlite3_eid_callback(void *result, int col_num, char **cols, char **names)
651 {
652         long long *eid = (long long *)result;
653
654         if (col_num != 1) return SQLITE_ABORT;
655         if (strcasecmp(names[0], "eid") != 0) return SQLITE_ABORT;
656
657         *eid = atoll(cols[0]);
658         return SQLITE_OK;
659 }
660
661 /*
662  * add a single set of ldap message values to a ldb_message
663  */
664 static int lsqlite3_search_callback(void *result, int col_num, char **cols, char **names)
665 {
666         struct ldb_context *ldb;
667         struct lsql_context *ac;
668         struct ldb_message *msg;
669         long long eid;
670         int i, ret;
671
672         ac = talloc_get_type(result, struct lsql_context);
673         ldb = ldb_module_get_ctx(ac->module);
674
675         /* eid, dn, attr_name, attr_value */
676         if (col_num != 4) return SQLITE_ABORT;
677
678         eid = atoll(cols[0]);
679
680         if (ac->ares) {
681                 msg = ac->ares->message;
682         }
683
684         if (eid != ac->current_eid) { /* here begin a new entry */
685
686                 /* call the async callback for the last entry
687                  * except the first time */
688                 if (ac->current_eid != 0) {
689                         msg = ldb_msg_canonicalize(ldb, msg);
690                         if (!msg) return SQLITE_ABORT;
691
692                         ret = ldb_module_send_entry(ac->req, msg, NULL);
693                         if (ret != LDB_SUCCESS) {
694                                 ac->callback_failed = true;
695                                 return SQLITE_ABORT;
696                         }
697                 }
698
699                 /* start over */
700                 ac->ares = talloc_zero(ac, struct ldb_reply);
701                 if (!ac->ares) return SQLITE_ABORT;
702
703                 msg = ldb_msg_new(ac->ares);
704                 if (!msg) return SQLITE_ABORT;
705
706                 ac->ares->type = LDB_REPLY_ENTRY;
707                 ac->current_eid = eid;
708         }
709
710         if (msg->dn == NULL) {
711                 msg->dn = ldb_dn_new(msg, ldb, cols[1]);
712                 if (msg->dn == NULL)
713                         return SQLITE_ABORT;
714         }
715
716         if (ac->attrs) {
717                 int found = 0;
718                 for (i = 0; ac->attrs[i]; i++) {
719                         if (strcasecmp(cols[2], ac->attrs[i]) == 0) {
720                                 found = 1;
721                                 break;
722                         }
723                 }
724                 if (!found) goto done;
725         }
726
727         if (ldb_msg_add_string(msg, cols[2], cols[3]) != 0) {
728                 return SQLITE_ABORT;
729         }
730
731 done:
732         ac->ares->message = msg;
733         return SQLITE_OK;
734 }
735
736
737 /*
738  * lsqlite3_get_eid()
739  * lsqlite3_get_eid_ndn()
740  *
741  * These functions are used for the very common case of retrieving an EID value
742  * given a (normalized) DN.
743  */
744
745 static long long lsqlite3_get_eid_ndn(sqlite3 *sqlite, void *mem_ctx, const char *norm_dn)
746 {
747         char *errmsg;
748         char *query;
749         long long eid = -1;
750         long long ret;
751
752         /* get object eid */
753         query = lsqlite3_tprintf(mem_ctx, "SELECT eid "
754                                           "FROM ldb_entry "
755                                           "WHERE norm_dn = '%q';", norm_dn);
756         if (query == NULL) return -1;
757
758         ret = sqlite3_exec(sqlite, query, lsqlite3_eid_callback, &eid, &errmsg);
759         if (ret != SQLITE_OK) {
760                 if (errmsg) {
761                         printf("lsqlite3_get_eid: Fatal Error: %s\n", errmsg);
762                         free(errmsg);
763                 }
764                 return -1;
765         }
766
767         return eid;
768 }
769
770 static long long lsqlite3_get_eid(struct lsqlite3_private *lsqlite3,
771                                   struct ldb_dn *dn)
772 {
773         TALLOC_CTX *local_ctx;
774         long long eid = -1;
775         char *cdn;
776
777         /* ignore ltdb specials */
778         if (ldb_dn_is_special(dn)) {
779                 return -1;
780         }
781
782         /* create a local ctx */
783         local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_get_eid local context");
784         if (local_ctx == NULL) {
785                 return -1;
786         }
787
788         cdn = ldb_dn_alloc_casefold(local_ctx, dn);
789         if (!cdn) goto done;
790
791         eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, local_ctx, cdn);
792
793 done:
794         talloc_free(local_ctx);
795         return eid;
796 }
797
798 /*
799  * Interface functions referenced by lsqlite3_ops
800  */
801
802 /* search for matching records, by tree */
803 int lsql_search(struct lsql_context *ctx)
804 {
805         struct ldb_module *module = ctx->module;
806         struct ldb_request *req = ctx->req;
807         struct lsqlite3_private *lsqlite3;
808         struct ldb_context *ldb;
809         char *norm_basedn;
810         char *sqlfilter;
811         char *errmsg;
812         char *query = NULL;
813         int ret;
814
815         ldb = ldb_module_get_ctx(module);
816         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
817                                    struct lsqlite3_private);
818
819         if ((( ! ldb_dn_is_valid(req->op.search.base)) ||
820              ldb_dn_is_null(req->op.search.base)) &&
821             (req->op.search.scope == LDB_SCOPE_BASE ||
822              req->op.search.scope == LDB_SCOPE_ONELEVEL)) {
823                 return LDB_ERR_OPERATIONS_ERROR;
824         }
825
826         if (req->op.search.base) {
827                 norm_basedn = ldb_dn_alloc_casefold(ctx, req->op.search.base);
828                 if (norm_basedn == NULL) {
829                         return LDB_ERR_OPERATIONS_ERROR;
830                 }
831         } else norm_basedn = talloc_strdup(ctx, "");
832
833         /* Convert filter into a series of SQL conditions (constraints) */
834         sqlfilter = parsetree_to_sql(module, ctx, req->op.search.tree);
835
836         switch(req->op.search.scope) {
837         case LDB_SCOPE_DEFAULT:
838         case LDB_SCOPE_SUBTREE:
839                 if (*norm_basedn != '\0') {
840                         query = lsqlite3_tprintf(ctx,
841                                 "SELECT entry.eid,\n"
842                                 "       entry.dn,\n"
843                                 "       av.attr_name,\n"
844                                 "       av.attr_value\n"
845                                 "  FROM ldb_entry AS entry\n"
846
847                                 "  LEFT OUTER JOIN ldb_attribute_values AS av\n"
848                                 "    ON av.eid = entry.eid\n"
849
850                                 "  WHERE entry.eid IN\n"
851                                 "    (SELECT DISTINCT ldb_entry.eid\n"
852                                 "       FROM ldb_entry\n"
853                                 "       WHERE (ldb_entry.norm_dn GLOB('*,%q')\n"
854                                 "       OR ldb_entry.norm_dn = '%q')\n"
855                                 "       AND ldb_entry.eid IN\n"
856                                 "         (%s)\n"
857                                 "    )\n"
858
859                                 "  ORDER BY entry.eid ASC;",
860                                 norm_basedn,
861                                 norm_basedn,
862                                 sqlfilter);
863                 } else {
864                         query = lsqlite3_tprintf(ctx,
865                                 "SELECT entry.eid,\n"
866                                 "       entry.dn,\n"
867                                 "       av.attr_name,\n"
868                                 "       av.attr_value\n"
869                                 "  FROM ldb_entry AS entry\n"
870
871                                 "  LEFT OUTER JOIN ldb_attribute_values AS av\n"
872                                 "    ON av.eid = entry.eid\n"
873
874                                 "  WHERE entry.eid IN\n"
875                                 "    (SELECT DISTINCT ldb_entry.eid\n"
876                                 "       FROM ldb_entry\n"
877                                 "       WHERE ldb_entry.eid IN\n"
878                                 "         (%s)\n"
879                                 "    )\n"
880
881                                 "  ORDER BY entry.eid ASC;",
882                                 sqlfilter);
883                 }
884
885                 break;
886
887         case LDB_SCOPE_BASE:
888                 query = lsqlite3_tprintf(ctx,
889                         "SELECT entry.eid,\n"
890                         "       entry.dn,\n"
891                         "       av.attr_name,\n"
892                         "       av.attr_value\n"
893                         "  FROM ldb_entry AS entry\n"
894
895                         "  LEFT OUTER JOIN ldb_attribute_values AS av\n"
896                         "    ON av.eid = entry.eid\n"
897
898                         "  WHERE entry.eid IN\n"
899                         "    (SELECT DISTINCT ldb_entry.eid\n"
900                         "       FROM ldb_entry\n"
901                         "       WHERE ldb_entry.norm_dn = '%q'\n"
902                         "         AND ldb_entry.eid IN\n"
903                         "           (%s)\n"
904                         "    )\n"
905
906                         "  ORDER BY entry.eid ASC;",
907                         norm_basedn,
908                         sqlfilter);
909                 break;
910
911         case LDB_SCOPE_ONELEVEL:
912                 query = lsqlite3_tprintf(ctx,
913                         "SELECT entry.eid,\n"
914                         "       entry.dn,\n"
915                         "       av.attr_name,\n"
916                         "       av.attr_value\n"
917                         "  FROM ldb_entry AS entry\n"
918
919                         "  LEFT OUTER JOIN ldb_attribute_values AS av\n"
920                         "    ON av.eid = entry.eid\n"
921
922                         "  WHERE entry.eid IN\n"
923                         "    (SELECT DISTINCT ldb_entry.eid\n"
924                         "       FROM ldb_entry\n"
925                         "       WHERE norm_dn GLOB('*,%q')\n"
926                         "         AND NOT norm_dn GLOB('*,*,%q')\n"
927                         "         AND ldb_entry.eid IN\n(%s)\n"
928                         "    )\n"
929
930                         "  ORDER BY entry.eid ASC;",
931                         norm_basedn,
932                         norm_basedn,
933                         sqlfilter);
934                 break;
935         }
936
937         if (query == NULL) {
938                 return LDB_ERR_OPERATIONS_ERROR;
939         }
940
941         /* * /
942         printf ("%s\n", query);
943         / * */
944
945         ctx->current_eid = 0;
946         ctx->attrs = req->op.search.attrs;
947         ctx->ares = NULL;
948
949         ldb_request_set_state(req, LDB_ASYNC_PENDING);
950
951         ret = sqlite3_exec(lsqlite3->sqlite, query, lsqlite3_search_callback, ctx, &errmsg);
952         if (ret != SQLITE_OK) {
953                 if (errmsg) {
954                         ldb_set_errstring(ldb, errmsg);
955                         free(errmsg);
956                 }
957                 return LDB_ERR_OPERATIONS_ERROR;
958         }
959
960         /* complete the last message if any */
961         if (ctx->ares) {
962                 ctx->ares->message = ldb_msg_canonicalize(ldb, ctx->ares->message);
963                 if (ctx->ares->message == NULL) {
964                         return LDB_ERR_OPERATIONS_ERROR;
965                 }
966
967                 ret = ldb_module_send_entry(req, ctx->ares->message, NULL);
968                 if (ret != LDB_SUCCESS) {
969                         return ret;
970                 }
971         }
972
973
974         return LDB_SUCCESS;
975 }
976
977 /* add a record */
978 static int lsql_add(struct lsql_context *ctx)
979 {
980         struct ldb_module *module = ctx->module;
981         struct ldb_request *req = ctx->req;
982         struct lsqlite3_private *lsqlite3;
983         struct ldb_context *ldb;
984         struct ldb_message *msg = req->op.add.message;
985         long long eid;
986         char *dn, *ndn;
987         char *errmsg;
988         char *query;
989         int i;
990         int ret;
991
992         ldb = ldb_module_get_ctx(module);
993         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
994                                    struct lsqlite3_private);
995
996         /* See if this is an ltdb special */
997         if (ldb_dn_is_special(msg->dn)) {
998 /*
999                 struct ldb_dn *c;
1000                 c = ldb_dn_new(local_ctx, ldb, "@INDEXLIST");
1001                 if (ldb_dn_compare(ldb, msg->dn, c) == 0) {
1002 #warning "should we handle indexes somehow ?"
1003                         ret = LDB_ERR_UNWILLING_TO_PERFORM;
1004                         goto done;
1005                 }
1006 */
1007                 /* Others return an error */
1008                 return LDB_ERR_UNWILLING_TO_PERFORM;
1009         }
1010
1011         /* create linearized and normalized dns */
1012         dn = ldb_dn_alloc_linearized(ctx, msg->dn);
1013         ndn = ldb_dn_alloc_casefold(ctx, msg->dn);
1014         if (dn == NULL || ndn == NULL) {
1015                 return LDB_ERR_OPERATIONS_ERROR;
1016         }
1017
1018         query = lsqlite3_tprintf(ctx,
1019                                    /* Add new entry */
1020                                    "INSERT OR ABORT INTO ldb_entry "
1021                                    "('dn', 'norm_dn') "
1022                                    "VALUES ('%q', '%q');",
1023                                 dn, ndn);
1024         if (query == NULL) {
1025                 return LDB_ERR_OPERATIONS_ERROR;
1026         }
1027
1028         ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
1029         if (ret != SQLITE_OK) {
1030                 if (errmsg) {
1031                         ldb_set_errstring(ldb, errmsg);
1032                         free(errmsg);
1033                 }
1034                 return LDB_ERR_OPERATIONS_ERROR;
1035         }
1036
1037         eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, ctx, ndn);
1038         if (eid == -1) {
1039                 return LDB_ERR_OPERATIONS_ERROR;
1040         }
1041
1042         for (i = 0; i < msg->num_elements; i++) {
1043                 const struct ldb_message_element *el = &msg->elements[i];
1044                 const struct ldb_schema_attribute *a;
1045                 char *attr;
1046                 int j;
1047
1048                 /* Get a case-folded copy of the attribute name */
1049                 attr = ldb_attr_casefold(ctx, el->name);
1050                 if (attr == NULL) {
1051                         return LDB_ERR_OPERATIONS_ERROR;
1052                 }
1053
1054                 a = ldb_schema_attribute_by_name(ldb, el->name);
1055
1056                 /* For each value of the specified attribute name... */
1057                 for (j = 0; j < el->num_values; j++) {
1058                         struct ldb_val value;
1059                         char *insert;
1060
1061                         /* Get a canonicalised copy of the data */
1062                         a->syntax->canonicalise_fn(ldb, ctx, &(el->values[j]), &value);
1063                         if (value.data == NULL) {
1064                                 return LDB_ERR_OPERATIONS_ERROR;
1065                         }
1066
1067                         insert = lsqlite3_tprintf(ctx,
1068                                         "INSERT OR ROLLBACK INTO ldb_attribute_values "
1069                                         "('eid', 'attr_name', 'norm_attr_name',"
1070                                         " 'attr_value', 'norm_attr_value') "
1071                                         "VALUES ('%lld', '%q', '%q', '%q', '%q');",
1072                                         eid, el->name, attr,
1073                                         el->values[j].data, value.data);
1074                         if (insert == NULL) {
1075                                 return LDB_ERR_OPERATIONS_ERROR;
1076                         }
1077
1078                         ret = sqlite3_exec(lsqlite3->sqlite, insert, NULL, NULL, &errmsg);
1079                         if (ret != SQLITE_OK) {
1080                                 if (errmsg) {
1081                                         ldb_set_errstring(ldb, errmsg);
1082                                         free(errmsg);
1083                                 }
1084                                 return LDB_ERR_OPERATIONS_ERROR;
1085                         }
1086                 }
1087         }
1088
1089         return LDB_SUCCESS;
1090 }
1091
1092 /* modify a record */
1093 static int lsql_modify(struct lsql_context *ctx)
1094 {
1095         struct ldb_module *module = ctx->module;
1096         struct ldb_request *req = ctx->req;
1097         struct lsqlite3_private *lsqlite3;
1098         struct ldb_context *ldb;
1099         struct ldb_message *msg = req->op.mod.message;
1100         long long eid;
1101         char *errmsg;
1102         int i;
1103         int ret;
1104
1105         ldb = ldb_module_get_ctx(module);
1106         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
1107                                    struct lsqlite3_private);
1108
1109         /* See if this is an ltdb special */
1110         if (ldb_dn_is_special(msg->dn)) {
1111                 /* Others return an error */
1112                 return LDB_ERR_UNWILLING_TO_PERFORM;
1113         }
1114
1115         eid = lsqlite3_get_eid(lsqlite3, msg->dn);
1116         if (eid == -1) {
1117                 return LDB_ERR_OPERATIONS_ERROR;
1118         }
1119
1120         for (i = 0; i < msg->num_elements; i++) {
1121                 const struct ldb_message_element *el = &msg->elements[i];
1122                 const struct ldb_schema_attribute *a;
1123                 int flags = el->flags & LDB_FLAG_MOD_MASK;
1124                 char *attr;
1125                 char *mod;
1126                 int j;
1127
1128                 /* Get a case-folded copy of the attribute name */
1129                 attr = ldb_attr_casefold(ctx, el->name);
1130                 if (attr == NULL) {
1131                         return LDB_ERR_OPERATIONS_ERROR;
1132                 }
1133
1134                 a = ldb_schema_attribute_by_name(ldb, el->name);
1135
1136                 switch (flags) {
1137
1138                 case LDB_FLAG_MOD_REPLACE:
1139
1140                         /* remove all attributes before adding the replacements */
1141                         mod = lsqlite3_tprintf(ctx,
1142                                                 "DELETE FROM ldb_attribute_values "
1143                                                 "WHERE eid = '%lld' "
1144                                                 "AND norm_attr_name = '%q';",
1145                                                 eid, attr);
1146                         if (mod == NULL) {
1147                                 return LDB_ERR_OPERATIONS_ERROR;
1148                         }
1149
1150                         ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
1151                         if (ret != SQLITE_OK) {
1152                                 if (errmsg) {
1153                                         ldb_set_errstring(ldb, errmsg);
1154                                         free(errmsg);
1155                                 }
1156                                 return LDB_ERR_OPERATIONS_ERROR;
1157                         }
1158
1159                         /* MISSING break is INTENTIONAL */
1160
1161                 case LDB_FLAG_MOD_ADD:
1162 #warning "We should throw an error if no value is provided!"
1163                         /* For each value of the specified attribute name... */
1164                         for (j = 0; j < el->num_values; j++) {
1165                                 struct ldb_val value;
1166
1167                                 /* Get a canonicalised copy of the data */
1168                                 a->syntax->canonicalise_fn(ldb, ctx, &(el->values[j]), &value);
1169                                 if (value.data == NULL) {
1170                                         return LDB_ERR_OPERATIONS_ERROR;
1171                                 }
1172
1173                                 mod = lsqlite3_tprintf(ctx,
1174                                         "INSERT OR ROLLBACK INTO ldb_attribute_values "
1175                                         "('eid', 'attr_name', 'norm_attr_name',"
1176                                         " 'attr_value', 'norm_attr_value') "
1177                                         "VALUES ('%lld', '%q', '%q', '%q', '%q');",
1178                                         eid, el->name, attr,
1179                                         el->values[j].data, value.data);
1180
1181                                 if (mod == NULL) {
1182                                         return LDB_ERR_OPERATIONS_ERROR;
1183                                 }
1184
1185                                 ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
1186                                 if (ret != SQLITE_OK) {
1187                                         if (errmsg) {
1188                                                 ldb_set_errstring(ldb, errmsg);
1189                                                 free(errmsg);
1190                                         }
1191                                         return LDB_ERR_OPERATIONS_ERROR;
1192                                 }
1193                         }
1194
1195                         break;
1196
1197                 case LDB_FLAG_MOD_DELETE:
1198 #warning "We should throw an error if the attribute we are trying to delete does not exist!"
1199                         if (el->num_values == 0) {
1200                                 mod = lsqlite3_tprintf(ctx,
1201                                                         "DELETE FROM ldb_attribute_values "
1202                                                         "WHERE eid = '%lld' "
1203                                                         "AND norm_attr_name = '%q';",
1204                                                         eid, attr);
1205                                 if (mod == NULL) {
1206                                         return LDB_ERR_OPERATIONS_ERROR;
1207                                 }
1208
1209                                 ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
1210                                 if (ret != SQLITE_OK) {
1211                                         if (errmsg) {
1212                                                 ldb_set_errstring(ldb, errmsg);
1213                                                 free(errmsg);
1214                                         }
1215                                         return LDB_ERR_OPERATIONS_ERROR;
1216                                 }
1217                         }
1218
1219                         /* For each value of the specified attribute name... */
1220                         for (j = 0; j < el->num_values; j++) {
1221                                 struct ldb_val value;
1222
1223                                 /* Get a canonicalised copy of the data */
1224                                 a->syntax->canonicalise_fn(ldb, ctx, &(el->values[j]), &value);
1225                                 if (value.data == NULL) {
1226                                         return LDB_ERR_OPERATIONS_ERROR;
1227                                 }
1228
1229                                 mod = lsqlite3_tprintf(ctx,
1230                                         "DELETE FROM ldb_attribute_values "
1231                                         "WHERE eid = '%lld' "
1232                                         "AND norm_attr_name = '%q' "
1233                                         "AND norm_attr_value = '%q';",
1234                                         eid, attr, value.data);
1235
1236                                 if (mod == NULL) {
1237                                         return LDB_ERR_OPERATIONS_ERROR;
1238                                 }
1239
1240                                 ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
1241                                 if (ret != SQLITE_OK) {
1242                                         if (errmsg) {
1243                                                 ldb_set_errstring(ldb, errmsg);
1244                                                 free(errmsg);
1245                                         }
1246                                         return LDB_ERR_OPERATIONS_ERROR;
1247                                 }
1248                         }
1249
1250                         break;
1251                 }
1252         }
1253
1254         return LDB_SUCCESS;
1255 }
1256
1257 /* delete a record */
1258 static int lsql_delete(struct lsql_context *ctx)
1259 {
1260         struct ldb_module *module = ctx->module;
1261         struct ldb_request *req = ctx->req;
1262         struct lsqlite3_private *lsqlite3;
1263         struct ldb_context *ldb;
1264         long long eid;
1265         char *errmsg;
1266         char *query;
1267         int ret;
1268
1269         ldb = ldb_module_get_ctx(module);
1270         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
1271                                    struct lsqlite3_private);
1272
1273         eid = lsqlite3_get_eid(lsqlite3, req->op.del.dn);
1274         if (eid == -1) {
1275                 return LDB_ERR_OPERATIONS_ERROR;
1276         }
1277
1278         query = lsqlite3_tprintf(ctx,
1279                                    /* Delete entry */
1280                                    "DELETE FROM ldb_entry WHERE eid = %lld; "
1281                                    /* Delete attributes */
1282                                    "DELETE FROM ldb_attribute_values WHERE eid = %lld; ",
1283                                 eid, eid);
1284         if (query == NULL) {
1285                 return LDB_ERR_OPERATIONS_ERROR;
1286         }
1287
1288         ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
1289         if (ret != SQLITE_OK) {
1290                 if (errmsg) {
1291                         ldb_set_errstring(ldb, errmsg);
1292                         free(errmsg);
1293                 }
1294                 return LDB_ERR_OPERATIONS_ERROR;
1295         }
1296
1297         return LDB_SUCCESS;
1298 }
1299
1300 /* rename a record */
1301 static int lsql_rename(struct lsql_context *ctx)
1302 {
1303         struct ldb_module *module = ctx->module;
1304         struct ldb_request *req = ctx->req;
1305         struct lsqlite3_private *lsqlite3;
1306         struct ldb_context *ldb;
1307         char *new_dn, *new_cdn, *old_cdn;
1308         char *errmsg;
1309         char *query;
1310         int ret;
1311
1312         ldb = ldb_module_get_ctx(module);
1313         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
1314                                    struct lsqlite3_private);
1315
1316         /* create linearized and normalized dns */
1317         old_cdn = ldb_dn_alloc_casefold(ctx, req->op.rename.olddn);
1318         new_cdn = ldb_dn_alloc_casefold(ctx, req->op.rename.newdn);
1319         new_dn = ldb_dn_alloc_linearized(ctx, req->op.rename.newdn);
1320         if (old_cdn == NULL || new_cdn == NULL || new_dn == NULL) {
1321                 return LDB_ERR_OPERATIONS_ERROR;
1322         }
1323
1324         /* build the SQL query */
1325         query = lsqlite3_tprintf(ctx,
1326                                  "UPDATE ldb_entry SET dn = '%q', norm_dn = '%q' "
1327                                  "WHERE norm_dn = '%q';",
1328                                  new_dn, new_cdn, old_cdn);
1329         if (query == NULL) {
1330                 return LDB_ERR_OPERATIONS_ERROR;
1331         }
1332
1333         /* execute */
1334         ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
1335         if (ret != SQLITE_OK) {
1336                 if (errmsg) {
1337                         ldb_set_errstring(ldb, errmsg);
1338                         free(errmsg);
1339                 }
1340                 return LDB_ERR_OPERATIONS_ERROR;
1341         }
1342
1343         return LDB_SUCCESS;
1344 }
1345
1346 static int lsql_start_trans(struct ldb_module * module)
1347 {
1348         int ret;
1349         char *errmsg;
1350         struct lsqlite3_private *lsqlite3;
1351
1352         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
1353                                    struct lsqlite3_private);
1354
1355         if (lsqlite3->trans_count == 0) {
1356                 ret = sqlite3_exec(lsqlite3->sqlite, "BEGIN IMMEDIATE;", NULL, NULL, &errmsg);
1357                 if (ret != SQLITE_OK) {
1358                         if (errmsg) {
1359                                 printf("lsqlite3_start_trans: error: %s\n", errmsg);
1360                                 free(errmsg);
1361                         }
1362                         return -1;
1363                 }
1364         };
1365
1366         lsqlite3->trans_count++;
1367
1368         return 0;
1369 }
1370
1371 static int lsql_end_trans(struct ldb_module *module)
1372 {
1373         int ret;
1374         char *errmsg;
1375         struct lsqlite3_private *lsqlite3;
1376
1377         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
1378                                    struct lsqlite3_private);
1379
1380         if (lsqlite3->trans_count > 0) {
1381                 lsqlite3->trans_count--;
1382         } else return -1;
1383
1384         if (lsqlite3->trans_count == 0) {
1385                 ret = sqlite3_exec(lsqlite3->sqlite, "COMMIT;", NULL, NULL, &errmsg);
1386                 if (ret != SQLITE_OK) {
1387                         if (errmsg) {
1388                                 printf("lsqlite3_end_trans: error: %s\n", errmsg);
1389                                 free(errmsg);
1390                         }
1391                         return -1;
1392                 }
1393         }
1394
1395         return 0;
1396 }
1397
1398 static int lsql_del_trans(struct ldb_module *module)
1399 {
1400         struct lsqlite3_private *lsqlite3;
1401
1402         lsqlite3 = talloc_get_type(ldb_module_get_private(module),
1403                                    struct lsqlite3_private);
1404
1405         if (lsqlite3->trans_count > 0) {
1406                 lsqlite3->trans_count--;
1407         } else return -1;
1408
1409         if (lsqlite3->trans_count == 0) {
1410                 return lsqlite3_safe_rollback(lsqlite3->sqlite);
1411         }
1412
1413         return -1;
1414 }
1415
1416 static int destructor(struct lsqlite3_private *lsqlite3)
1417 {
1418         if (lsqlite3->sqlite) {
1419                 sqlite3_close(lsqlite3->sqlite);
1420         }
1421         return 0;
1422 }
1423
1424 static void lsql_request_done(struct lsql_context *ctx, int error)
1425 {
1426         struct ldb_context *ldb;
1427         struct ldb_request *req;
1428         struct ldb_reply *ares;
1429
1430         ldb = ldb_module_get_ctx(ctx->module);
1431         req = ctx->req;
1432
1433         /* if we already returned an error just return */
1434         if (ldb_request_get_status(req) != LDB_SUCCESS) {
1435                 return;
1436         }
1437
1438         ares = talloc_zero(req, struct ldb_reply);
1439         if (!ares) {
1440                 ldb_oom(ldb);
1441                 req->callback(req, NULL);
1442                 return;
1443         }
1444         ares->type = LDB_REPLY_DONE;
1445         ares->error = error;
1446
1447         req->callback(req, ares);
1448 }
1449
1450 static void lsql_timeout(struct tevent_context *ev,
1451                          struct tevent_timer *te,
1452                          struct timeval t,
1453                          void *private_data)
1454 {
1455         struct lsql_context *ctx;
1456         ctx = talloc_get_type(private_data, struct lsql_context);
1457
1458         lsql_request_done(ctx, LDB_ERR_TIME_LIMIT_EXCEEDED);
1459 }
1460
1461 static void lsql_callback(struct tevent_context *ev,
1462                           struct tevent_timer *te,
1463                           struct timeval t,
1464                           void *private_data)
1465 {
1466         struct lsql_context *ctx;
1467         int ret;
1468
1469         ctx = talloc_get_type(private_data, struct lsql_context);
1470
1471         switch (ctx->req->operation) {
1472         case LDB_SEARCH:
1473                 ret = lsql_search(ctx);
1474                 break;
1475         case LDB_ADD:
1476                 ret = lsql_add(ctx);
1477                 break;
1478         case LDB_MODIFY:
1479                 ret = lsql_modify(ctx);
1480                 break;
1481         case LDB_DELETE:
1482                 ret = lsql_delete(ctx);
1483                 break;
1484         case LDB_RENAME:
1485                 ret = lsql_rename(ctx);
1486                 break;
1487 /* TODO:
1488         case LDB_EXTENDED:
1489                 ret = lsql_extended(ctx);
1490                 break;
1491  */
1492         default:
1493                 /* no other op supported */
1494                 ret = LDB_ERR_UNWILLING_TO_PERFORM;
1495         }
1496
1497         if (!ctx->callback_failed) {
1498                 /* Once we are done, we do not need timeout events */
1499                 talloc_free(ctx->timeout_event);
1500                 lsql_request_done(ctx, ret);
1501         }
1502 }
1503
1504 static int lsql_handle_request(struct ldb_module *module, struct ldb_request *req)
1505 {
1506         struct ldb_context *ldb;
1507         struct tevent_context *ev;
1508         struct lsql_context *ac;
1509         struct tevent_timer *te;
1510         struct timeval tv;
1511
1512         if (check_critical_controls(req->controls)) {
1513                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
1514         }
1515
1516         if (req->starttime == 0 || req->timeout == 0) {
1517                 ldb_set_errstring(ldb, "Invalid timeout settings");
1518                 return LDB_ERR_TIME_LIMIT_EXCEEDED;
1519         }
1520
1521         ldb = ldb_module_get_ctx(module);
1522         ev = ldb_get_event_context(ldb);
1523
1524         ac = talloc_zero(req, struct lsql_context);
1525         if (ac == NULL) {
1526                 ldb_set_errstring(ldb, "Out of Memory");
1527                 return LDB_ERR_OPERATIONS_ERROR;
1528         }
1529
1530         ac->module = module;
1531         ac->req = req;
1532
1533         tv.tv_sec = 0;
1534         tv.tv_usec = 0;
1535         te = tevent_add_timer(ev, ac, tv, lsql_callback, ac);
1536         if (NULL == te) {
1537                 return LDB_ERR_OPERATIONS_ERROR;
1538         }
1539
1540         tv.tv_sec = req->starttime + req->timeout;
1541         ac->timeout_event = tevent_add_timer(ev, ac, tv, lsql_timeout, ac);
1542         if (NULL == ac->timeout_event) {
1543                 return LDB_ERR_OPERATIONS_ERROR;
1544         }
1545
1546         return LDB_SUCCESS;
1547 }
1548
1549 /*
1550  * Table of operations for the sqlite3 backend
1551  */
1552 static const struct ldb_module_ops lsqlite3_ops = {
1553         .name              = "sqlite",
1554         .search            = lsql_handle_request,
1555         .add               = lsql_handle_request,
1556         .modify            = lsql_handle_request,
1557         .del               = lsql_handle_request,
1558         .rename            = lsql_handle_request,
1559         .extended          = lsql_handle_request,
1560         .start_transaction = lsql_start_trans,
1561         .end_transaction   = lsql_end_trans,
1562         .del_transaction   = lsql_del_trans,
1563 };
1564
1565 /*
1566  * Static functions
1567  */
1568
1569 static int initialize(struct lsqlite3_private *lsqlite3,
1570                       struct ldb_context *ldb, const char *url, int flags)
1571 {
1572         TALLOC_CTX *local_ctx;
1573         long long queryInt;
1574         int rollback = 0;
1575         char *errmsg;
1576         char *schema;
1577         int ret;
1578
1579         /* create a local ctx */
1580         local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_rename local context");
1581         if (local_ctx == NULL) {
1582                 return -1;
1583         }
1584
1585         schema = lsqlite3_tprintf(local_ctx,
1586
1587
1588                 "CREATE TABLE ldb_info AS "
1589                 "  SELECT 'LDB' AS database_type,"
1590                 "         '1.0' AS version;"
1591
1592                 /*
1593                  * The entry table holds the information about an entry.
1594                  * This table is used to obtain the EID of the entry and to
1595                  * support scope=one and scope=base.  The parent and child
1596                  * table is included in the entry table since all the other
1597                  * attributes are dependent on EID.
1598                  */
1599                 "CREATE TABLE ldb_entry "
1600                 "("
1601                 "  eid     INTEGER PRIMARY KEY AUTOINCREMENT,"
1602                 "  dn      TEXT UNIQUE NOT NULL,"
1603                 "  norm_dn TEXT UNIQUE NOT NULL"
1604                 ");"
1605
1606
1607                 "CREATE TABLE ldb_object_classes"
1608                 "("
1609                 "  class_name            TEXT PRIMARY KEY,"
1610                 "  parent_class_name     TEXT,"
1611                 "  tree_key              TEXT UNIQUE,"
1612                 "  max_child_num         INTEGER DEFAULT 0"
1613                 ");"
1614
1615                 /*
1616                  * We keep a full listing of attribute/value pairs here
1617                  */
1618                 "CREATE TABLE ldb_attribute_values"
1619                 "("
1620                 "  eid             INTEGER REFERENCES ldb_entry,"
1621                 "  attr_name       TEXT,"
1622                 "  norm_attr_name  TEXT,"
1623                 "  attr_value      TEXT,"
1624                 "  norm_attr_value TEXT "
1625                 ");"
1626
1627
1628                 /*
1629                  * Indexes
1630                  */
1631                 "CREATE INDEX ldb_attribute_values_eid_idx "
1632                 "  ON ldb_attribute_values (eid);"
1633
1634                 "CREATE INDEX ldb_attribute_values_name_value_idx "
1635                 "  ON ldb_attribute_values (attr_name, norm_attr_value);"
1636
1637
1638
1639                 /*
1640                  * Triggers
1641                  */
1642
1643                 "CREATE TRIGGER ldb_object_classes_insert_tr"
1644                 "  AFTER INSERT"
1645                 "  ON ldb_object_classes"
1646                 "  FOR EACH ROW"
1647                 "    BEGIN"
1648                 "      UPDATE ldb_object_classes"
1649                 "        SET tree_key = COALESCE(tree_key, "
1650                 "              ("
1651                 "                SELECT tree_key || "
1652                 "                       (SELECT base160(max_child_num + 1)"
1653                 "                                FROM ldb_object_classes"
1654                 "                                WHERE class_name = "
1655                 "                                      new.parent_class_name)"
1656                 "                  FROM ldb_object_classes "
1657                 "                  WHERE class_name = new.parent_class_name "
1658                 "              ));"
1659                 "      UPDATE ldb_object_classes "
1660                 "        SET max_child_num = max_child_num + 1"
1661                 "        WHERE class_name = new.parent_class_name;"
1662                 "    END;"
1663
1664                 /*
1665                  * Table initialization
1666                  */
1667
1668                 "INSERT INTO ldb_object_classes "
1669                 "    (class_name, tree_key) "
1670                 "  VALUES "
1671                 "    ('TOP', '0001');");
1672
1673         /* Skip protocol indicator of url  */
1674         if (strncmp(url, "sqlite3://", 10) != 0) {
1675                 return SQLITE_MISUSE;
1676         }
1677
1678         /* Update pointer to just after the protocol indicator */
1679         url += 10;
1680
1681         /* Try to open the (possibly empty/non-existent) database */
1682         if ((ret = sqlite3_open(url, &lsqlite3->sqlite)) != SQLITE_OK) {
1683                 return ret;
1684         }
1685
1686         /* In case this is a new database, enable auto_vacuum */
1687         ret = sqlite3_exec(lsqlite3->sqlite, "PRAGMA auto_vacuum = 1;", NULL, NULL, &errmsg);
1688         if (ret != SQLITE_OK) {
1689                 if (errmsg) {
1690                         printf("lsqlite3 initializaion error: %s\n", errmsg);
1691                         free(errmsg);
1692                 }
1693                 goto failed;
1694         }
1695
1696         if (flags & LDB_FLG_NOSYNC) {
1697                 /* DANGEROUS */
1698                 ret = sqlite3_exec(lsqlite3->sqlite, "PRAGMA synchronous = OFF;", NULL, NULL, &errmsg);
1699                 if (ret != SQLITE_OK) {
1700                         if (errmsg) {
1701                                 printf("lsqlite3 initializaion error: %s\n", errmsg);
1702                                 free(errmsg);
1703                         }
1704                         goto failed;
1705                 }
1706         }
1707
1708         /* */
1709
1710         /* Establish a busy timeout of 30 seconds */
1711         if ((ret = sqlite3_busy_timeout(lsqlite3->sqlite,
1712                                         30000)) != SQLITE_OK) {
1713                 return ret;
1714         }
1715
1716         /* Create a function, callable from sql, to increment a tree_key */
1717         if ((ret =
1718              sqlite3_create_function(lsqlite3->sqlite,/* handle */
1719                                      "base160_next",  /* function name */
1720                                      1,               /* number of args */
1721                                      SQLITE_ANY,      /* preferred text type */
1722                                      NULL,            /* user data */
1723                                      base160next_sql, /* called func */
1724                                      NULL,            /* step func */
1725                                      NULL             /* final func */
1726                      )) != SQLITE_OK) {
1727                 return ret;
1728         }
1729
1730         /* Create a function, callable from sql, to convert int to base160 */
1731         if ((ret =
1732              sqlite3_create_function(lsqlite3->sqlite,/* handle */
1733                                      "base160",       /* function name */
1734                                      1,               /* number of args */
1735                                      SQLITE_ANY,      /* preferred text type */
1736                                      NULL,            /* user data */
1737                                      base160_sql,     /* called func */
1738                                      NULL,            /* step func */
1739                                      NULL             /* final func */
1740                      )) != SQLITE_OK) {
1741                 return ret;
1742         }
1743
1744         /* Create a function, callable from sql, to perform various comparisons */
1745         if ((ret =
1746              sqlite3_create_function(lsqlite3->sqlite, /* handle */
1747                                      "ldap_compare",   /* function name */
1748                                      4,                /* number of args */
1749                                      SQLITE_ANY,       /* preferred text type */
1750                                      ldb  ,            /* user data */
1751                                      lsqlite3_compare, /* called func */
1752                                      NULL,             /* step func */
1753                                      NULL              /* final func */
1754                      )) != SQLITE_OK) {
1755                 return ret;
1756         }
1757
1758         /* Begin a transaction */
1759         ret = sqlite3_exec(lsqlite3->sqlite, "BEGIN EXCLUSIVE;", NULL, NULL, &errmsg);
1760         if (ret != SQLITE_OK) {
1761                 if (errmsg) {
1762                         printf("lsqlite3: initialization error: %s\n", errmsg);
1763                         free(errmsg);
1764                 }
1765                 goto failed;
1766         }
1767         rollback = 1;
1768
1769         /* Determine if this is a new database.  No tables means it is. */
1770         if (query_int(lsqlite3,
1771                       &queryInt,
1772                       "SELECT COUNT(*)\n"
1773                       "  FROM sqlite_master\n"
1774                       "  WHERE type = 'table';") != 0) {
1775                 goto failed;
1776         }
1777
1778         if (queryInt == 0) {
1779                 /*
1780                  * Create the database schema
1781                  */
1782                 ret = sqlite3_exec(lsqlite3->sqlite, schema, NULL, NULL, &errmsg);
1783                 if (ret != SQLITE_OK) {
1784                         if (errmsg) {
1785                                 printf("lsqlite3 initializaion error: %s\n", errmsg);
1786                                 free(errmsg);
1787                         }
1788                         goto failed;
1789                 }
1790         } else {
1791                 /*
1792                  * Ensure that the database we opened is one of ours
1793                  */
1794                 if (query_int(lsqlite3,
1795                               &queryInt,
1796                               "SELECT "
1797                               "  (SELECT COUNT(*) = 2"
1798                               "     FROM sqlite_master "
1799                               "     WHERE type = 'table' "
1800                               "       AND name IN "
1801                               "         ("
1802                               "           'ldb_entry', "
1803                               "           'ldb_object_classes' "
1804                               "         ) "
1805                               "  ) "
1806                               "  AND "
1807                               "  (SELECT 1 "
1808                               "     FROM ldb_info "
1809                               "     WHERE database_type = 'LDB' "
1810                               "       AND version = '1.0'"
1811                               "  );") != 0 ||
1812                     queryInt != 1) {
1813
1814                         /* It's not one that we created.  See ya! */
1815                         goto failed;
1816                 }
1817         }
1818
1819         /* Commit the transaction */
1820         ret = sqlite3_exec(lsqlite3->sqlite, "COMMIT;", NULL, NULL, &errmsg);
1821         if (ret != SQLITE_OK) {
1822                 if (errmsg) {
1823                         printf("lsqlite3: iniialization error: %s\n", errmsg);
1824                         free(errmsg);
1825                 }
1826                 goto failed;
1827         }
1828
1829         return SQLITE_OK;
1830
1831 failed:
1832         if (rollback) lsqlite3_safe_rollback(lsqlite3->sqlite);
1833         sqlite3_close(lsqlite3->sqlite);
1834         return -1;
1835 }
1836
1837 /*
1838  * connect to the database
1839  */
1840 static int lsqlite3_connect(struct ldb_context *ldb,
1841                             const char *url,
1842                             unsigned int flags,
1843                             const char *options[],
1844                             struct ldb_module **_module)
1845 {
1846         struct ldb_module *module;
1847         struct lsqlite3_private *lsqlite3;
1848         int i, ret;
1849
1850         module = ldb_module_new(ldb, ldb, "ldb_sqlite3 backend", &lsqlite3_ops);
1851         if (!module) return -1;
1852
1853         lsqlite3 = talloc(module, struct lsqlite3_private);
1854         if (!lsqlite3) {
1855                 goto failed;
1856         }
1857
1858         lsqlite3->sqlite = NULL;
1859         lsqlite3->options = NULL;
1860         lsqlite3->trans_count = 0;
1861
1862         ret = initialize(lsqlite3, ldb, url, flags);
1863         if (ret != SQLITE_OK) {
1864                 goto failed;
1865         }
1866
1867         talloc_set_destructor(lsqlite3, destructor);
1868
1869         ldb_module_set_private(module, lsqlite3);
1870
1871         if (options) {
1872                 /*
1873                  * take a copy of the options array, so we don't have to rely
1874                  * on the caller keeping it around (it might be dynamic)
1875                  */
1876                 for (i=0;options[i];i++) ;
1877
1878                 lsqlite3->options = talloc_array(lsqlite3, char *, i+1);
1879                 if (!lsqlite3->options) {
1880                         goto failed;
1881                 }
1882
1883                 for (i=0;options[i];i++) {
1884
1885                         lsqlite3->options[i+1] = NULL;
1886                         lsqlite3->options[i] =
1887                                 talloc_strdup(lsqlite3->options, options[i]);
1888                         if (!lsqlite3->options[i]) {
1889                                 goto failed;
1890                         }
1891                 }
1892         }
1893
1894         *_module = module;
1895         return 0;
1896
1897 failed:
1898         if (lsqlite3 && lsqlite3->sqlite != NULL) {
1899                 (void) sqlite3_close(lsqlite3->sqlite);
1900         }
1901         talloc_free(lsqlite3);
1902         return -1;
1903 }
1904
1905 const struct ldb_backend_ops ldb_sqlite3_backend_ops = {
1906         .name = "sqlite3",
1907         .connect_fn = lsqlite3_connect
1908 };