4 Copyright (C) Andrew Tridgell 2004
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 3 of the License, or (at your option) any later version.
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 * Component: ldb tdb cache functions
29 * Description: cache special records in a ldb/tdb
31 * Author: Andrew Tridgell
36 #define LTDB_FLAG_CASE_INSENSITIVE (1<<0)
37 #define LTDB_FLAG_INTEGER (1<<1)
38 #define LTDB_FLAG_HIDDEN (1<<2)
40 /* valid attribute flags */
44 } ltdb_valid_attr_flags[] = {
45 { "CASE_INSENSITIVE", LTDB_FLAG_CASE_INSENSITIVE },
46 { "INTEGER", LTDB_FLAG_INTEGER },
47 { "HIDDEN", LTDB_FLAG_HIDDEN },
54 de-register any special handlers for @ATTRIBUTES
56 static void ltdb_attributes_unload(struct ldb_module *module)
58 struct ldb_context *ldb;
59 void *data = ldb_module_get_private(module);
60 struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
61 struct ldb_message *msg;
64 ldb = ldb_module_get_ctx(module);
66 if (ltdb->cache->attributes == NULL) {
67 /* no previously loaded attributes */
71 msg = ltdb->cache->attributes;
72 for (i=0;i<msg->num_elements;i++) {
73 ldb_schema_attribute_remove(ldb, msg->elements[i].name);
76 talloc_free(ltdb->cache->attributes);
77 ltdb->cache->attributes = NULL;
81 add up the attrib flags for a @ATTRIBUTES element
83 static int ltdb_attributes_flags(struct ldb_message_element *el, unsigned *v)
87 for (i=0;i<el->num_values;i++) {
89 for (j=0;ltdb_valid_attr_flags[j].name;j++) {
90 if (strcmp(ltdb_valid_attr_flags[j].name,
91 (char *)el->values[i].data) == 0) {
92 value |= ltdb_valid_attr_flags[j].value;
96 if (ltdb_valid_attr_flags[j].name == NULL) {
105 register any special handlers from @ATTRIBUTES
107 static int ltdb_attributes_load(struct ldb_module *module)
109 struct ldb_context *ldb;
110 void *data = ldb_module_get_private(module);
111 struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
112 struct ldb_message *msg = ltdb->cache->attributes;
116 ldb = ldb_module_get_ctx(module);
118 dn = ldb_dn_new(module, ldb, LTDB_ATTRIBUTES);
119 if (dn == NULL) goto failed;
121 r = ltdb_search_dn1(module, dn, msg);
123 if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
126 if (r == LDB_ERR_NO_SUCH_OBJECT) {
129 /* mapping these flags onto ldap 'syntaxes' isn't strictly correct,
130 but its close enough for now */
131 for (i=0;i<msg->num_elements;i++) {
134 const struct ldb_schema_syntax *s;
136 if (ltdb_attributes_flags(&msg->elements[i], &flags) != 0) {
137 ldb_debug(ldb, LDB_DEBUG_ERROR, "Invalid @ATTRIBUTES element for '%s'\n", msg->elements[i].name);
140 switch (flags & ~LTDB_FLAG_HIDDEN) {
142 syntax = LDB_SYNTAX_OCTET_STRING;
144 case LTDB_FLAG_CASE_INSENSITIVE:
145 syntax = LDB_SYNTAX_DIRECTORY_STRING;
147 case LTDB_FLAG_INTEGER:
148 syntax = LDB_SYNTAX_INTEGER;
151 ldb_debug(ldb, LDB_DEBUG_ERROR,
152 "Invalid flag combination 0x%x for '%s' in @ATTRIBUTES\n",
153 flags, msg->elements[i].name);
157 s = ldb_standard_syntax_by_name(ldb, syntax);
159 ldb_debug(ldb, LDB_DEBUG_ERROR,
160 "Invalid attribute syntax '%s' for '%s' in @ATTRIBUTES\n",
161 syntax, msg->elements[i].name);
165 flags |= LDB_ATTR_FLAG_ALLOCATED;
166 if (ldb_schema_attribute_add_with_syntax(ldb, msg->elements[i].name, flags, s) != 0) {
178 initialise the baseinfo record
180 static int ltdb_baseinfo_init(struct ldb_module *module)
182 struct ldb_context *ldb;
183 void *data = ldb_module_get_private(module);
184 struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
185 struct ldb_message *msg;
186 struct ldb_message_element el;
189 /* the initial sequence number must be different from the one
190 set in ltdb_cache_free(). Thanks to Jon for pointing this
192 const char *initial_sequence_number = "1";
194 ldb = ldb_module_get_ctx(module);
196 ltdb->sequence_number = atof(initial_sequence_number);
198 msg = talloc(ltdb, struct ldb_message);
203 msg->num_elements = 1;
205 msg->dn = ldb_dn_new(msg, ldb, LTDB_BASEINFO);
209 el.name = talloc_strdup(msg, LTDB_SEQUENCE_NUMBER);
216 val.data = (uint8_t *)talloc_strdup(msg, initial_sequence_number);
222 ret = ltdb_store(module, msg, TDB_INSERT);
231 return LDB_ERR_OPERATIONS_ERROR;
235 free any cache records
237 static void ltdb_cache_free(struct ldb_module *module)
239 void *data = ldb_module_get_private(module);
240 struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
242 ltdb->sequence_number = 0;
243 talloc_free(ltdb->cache);
250 int ltdb_cache_reload(struct ldb_module *module)
252 ltdb_attributes_unload(module);
253 ltdb_cache_free(module);
254 return ltdb_cache_load(module);
258 load the cache records
260 int ltdb_cache_load(struct ldb_module *module)
262 struct ldb_context *ldb;
263 void *data = ldb_module_get_private(module);
264 struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
265 struct ldb_dn *baseinfo_dn = NULL, *options_dn = NULL;
266 struct ldb_dn *indexlist_dn = NULL;
268 struct ldb_message *baseinfo = NULL, *options = NULL;
271 ldb = ldb_module_get_ctx(module);
273 /* a very fast check to avoid extra database reads */
274 if (ltdb->cache != NULL &&
275 tdb_get_seqnum(ltdb->tdb) == ltdb->tdb_seqnum) {
279 if (ltdb->cache == NULL) {
280 ltdb->cache = talloc_zero(ltdb, struct ltdb_cache);
281 if (ltdb->cache == NULL) goto failed;
282 ltdb->cache->indexlist = talloc_zero(ltdb->cache, struct ldb_message);
283 ltdb->cache->attributes = talloc_zero(ltdb->cache, struct ldb_message);
284 if (ltdb->cache->indexlist == NULL ||
285 ltdb->cache->attributes == NULL) {
290 baseinfo = talloc(ltdb->cache, struct ldb_message);
291 if (baseinfo == NULL) goto failed;
293 baseinfo_dn = ldb_dn_new(module, ldb, LTDB_BASEINFO);
294 if (baseinfo_dn == NULL) goto failed;
296 r= ltdb_search_dn1(module, baseinfo_dn, baseinfo);
297 if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
301 /* possibly initialise the baseinfo */
302 if (r == LDB_ERR_NO_SUCH_OBJECT) {
303 if (ltdb_baseinfo_init(module) != LDB_SUCCESS) {
306 if (ltdb_search_dn1(module, baseinfo_dn, baseinfo) != LDB_SUCCESS) {
311 ltdb->tdb_seqnum = tdb_get_seqnum(ltdb->tdb);
313 /* if the current internal sequence number is the same as the one
314 in the database then assume the rest of the cache is OK */
315 seq = ldb_msg_find_attr_as_uint64(baseinfo, LTDB_SEQUENCE_NUMBER, 0);
316 if (seq == ltdb->sequence_number) {
319 ltdb->sequence_number = seq;
321 /* Read an interpret database options */
322 options = talloc(ltdb->cache, struct ldb_message);
323 if (options == NULL) goto failed;
325 options_dn = ldb_dn_new(options, ldb, LTDB_OPTIONS);
326 if (options_dn == NULL) goto failed;
328 r= ltdb_search_dn1(module, options_dn, options);
329 if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
333 /* set flag for checking base DN on searches */
334 if (r == LDB_SUCCESS) {
335 ltdb->check_base = ldb_msg_find_attr_as_bool(options, LTDB_CHECK_BASE, false);
337 ltdb->check_base = false;
340 talloc_free(ltdb->cache->last_attribute.name);
341 memset(<db->cache->last_attribute, 0, sizeof(ltdb->cache->last_attribute));
343 ltdb_attributes_unload(module);
345 talloc_free(ltdb->cache->indexlist);
347 ltdb->cache->indexlist = talloc_zero(ltdb->cache, struct ldb_message);
348 ltdb->cache->attributes = talloc_zero(ltdb->cache, struct ldb_message);
349 if (ltdb->cache->indexlist == NULL ||
350 ltdb->cache->attributes == NULL) {
354 indexlist_dn = ldb_dn_new(module, ldb, LTDB_INDEXLIST);
355 if (indexlist_dn == NULL) goto failed;
357 r = ltdb_search_dn1(module, indexlist_dn, ltdb->cache->indexlist);
358 if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
362 if (ltdb_attributes_load(module) == -1) {
367 talloc_free(options);
368 talloc_free(baseinfo);
369 talloc_free(baseinfo_dn);
370 talloc_free(indexlist_dn);
374 talloc_free(options);
375 talloc_free(baseinfo);
376 talloc_free(baseinfo_dn);
377 talloc_free(indexlist_dn);
383 increase the sequence number to indicate a database change
385 int ltdb_increase_sequence_number(struct ldb_module *module)
387 struct ldb_context *ldb;
388 void *data = ldb_module_get_private(module);
389 struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
390 struct ldb_message *msg;
391 struct ldb_message_element el[2];
393 struct ldb_val val_time;
394 time_t t = time(NULL);
398 ldb = ldb_module_get_ctx(module);
400 msg = talloc(ltdb, struct ldb_message);
403 return LDB_ERR_OPERATIONS_ERROR;
406 s = talloc_asprintf(msg, "%llu", ltdb->sequence_number+1);
409 return LDB_ERR_OPERATIONS_ERROR;
412 msg->num_elements = ARRAY_SIZE(el);
414 msg->dn = ldb_dn_new(msg, ldb, LTDB_BASEINFO);
415 if (msg->dn == NULL) {
418 return LDB_ERR_OPERATIONS_ERROR;
420 el[0].name = talloc_strdup(msg, LTDB_SEQUENCE_NUMBER);
421 if (el[0].name == NULL) {
424 return LDB_ERR_OPERATIONS_ERROR;
427 el[0].num_values = 1;
428 el[0].flags = LDB_FLAG_MOD_REPLACE;
429 val.data = (uint8_t *)s;
430 val.length = strlen(s);
432 el[1].name = talloc_strdup(msg, LTDB_MOD_TIMESTAMP);
433 if (el[1].name == NULL) {
436 return LDB_ERR_OPERATIONS_ERROR;
438 el[1].values = &val_time;
439 el[1].num_values = 1;
440 el[1].flags = LDB_FLAG_MOD_REPLACE;
442 s = ldb_timestring(msg, t);
444 return LDB_ERR_OPERATIONS_ERROR;
447 val_time.data = (uint8_t *)s;
448 val_time.length = strlen(s);
450 ret = ltdb_modify_internal(module, msg);
454 if (ret == LDB_SUCCESS) {
455 ltdb->sequence_number += 1;
458 /* updating the tdb_seqnum here avoids us reloading the cache
459 records due to our own modification */
460 ltdb->tdb_seqnum = tdb_get_seqnum(ltdb->tdb);
465 int ltdb_check_at_attributes_values(const struct ldb_val *value)
469 for (i = 0; ltdb_valid_attr_flags[i].name != NULL; i++) {
470 if ((strcmp(ltdb_valid_attr_flags[i].name, (char *)value->data) == 0)) {