?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r19955: I'll leave that to others. I *knew* I should not have touchec this
[Samba.git] / source / lib / ldb / common / ldb_msg.c
blob65d1ecacb7a98ee502a5e94ccd99587371af9bfd
1 /*
2 ldb database library
3
4 Copyright (C) Andrew Tridgell 2004
5
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
8 ** under the LGPL
9
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 2 of the License, or (at your option) any later version.
14
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.
19
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 /*
26 * Name: ldb
27 *
28 * Component: ldb message component utility functions
29 *
30 * Description: functions for manipulating ldb_message structures
31 *
32 * Author: Andrew Tridgell
33 */
34
35 #include "includes.h"
36 #include "ldb/include/includes.h"
37
38 /*
39 create a new ldb_message in a given memory context (NULL for top level)
40 */
41 struct ldb_message *ldb_msg_new(void *mem_ctx)
42 {
43 return talloc_zero(mem_ctx, struct ldb_message);
44 }
45
46 /*
47 find an element in a message by attribute name
48 */
49 struct ldb_message_element *ldb_msg_find_element(const struct ldb_message *msg,
50 const char *attr_name)
51 {
52 unsigned int i;
53 for (i=0;i<msg->num_elements;i++) {
54 if (ldb_attr_cmp(msg->elements[i].name, attr_name) == 0) {
55 return &msg->elements[i];
56 }
57 }
58 return NULL;
59 }
60
61 /*
62 see if two ldb_val structures contain exactly the same data
63 return 1 for a match, 0 for a mis-match
64 */
65 int ldb_val_equal_exact(const struct ldb_val *v1, const struct ldb_val *v2)
66 {
67 if (v1->length != v2->length) return 0;
68
69 if (v1->length == 0) return 1;
70
71 if (memcmp(v1->data, v2->data, v1->length) == 0) {
72 return 1;
73 }
74
75 return 0;
76 }
77
78 /*
79 find a value in an element
80 assumes case sensitive comparison
81 */
82 struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
83 struct ldb_val *val)
84 {
85 unsigned int i;
86 for (i=0;i<el->num_values;i++) {
87 if (ldb_val_equal_exact(val, &el->values[i])) {
88 return &el->values[i];
89 }
90 }
91 return NULL;
92 }
93
94 /*
95 duplicate a ldb_val structure
96 */
97 struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v)
98 {
99 struct ldb_val v2;
100 v2.length = v->length;
101 if (v->data == NULL) {
102 v2.data = NULL;
103 return v2;
104 }
105
106 /* the +1 is to cope with buggy C library routines like strndup
107 that look one byte beyond */
108 v2.data = talloc_array(mem_ctx, uint8_t, v->length+1);
109 if (!v2.data) {
110 v2.length = 0;
111 return v2;
112 }
113
114 memcpy(v2.data, v->data, v->length);
115 ((char *)v2.data)[v->length] = 0;
116 return v2;
117 }
118
119 /*
120 add an empty element to a message
121 */
122 int ldb_msg_add_empty( struct ldb_message *msg,
123 const char *attr_name,
124 int flags,
125 struct ldb_message_element **return_el)
126 {
127 struct ldb_message_element *els;
128
129 if (! ldb_valid_attr_name(attr_name)) {
130 return LDB_ERR_OPERATIONS_ERROR;
131 }
132
133 els = talloc_realloc(msg, msg->elements,
134 struct ldb_message_element, msg->num_elements+1);
135 if (!els) {
136 errno = ENOMEM;
137 return LDB_ERR_OPERATIONS_ERROR;
138 }
139
140 els[msg->num_elements].values = NULL;
141 els[msg->num_elements].num_values = 0;
142 els[msg->num_elements].flags = flags;
143 els[msg->num_elements].name = talloc_strdup(els, attr_name);
144 if (!els[msg->num_elements].name) {
145 errno = ENOMEM;
146 return LDB_ERR_OPERATIONS_ERROR;
147 }
148
149 msg->elements = els;
150 msg->num_elements++;
151
152 if (return_el) {
153 *return_el = &els[msg->num_elements-1];
154 }
155
156 return LDB_SUCCESS;
157 }
158
159 /*
160 add an empty element to a message
161 */
162 int ldb_msg_add(struct ldb_message *msg,
163 const struct ldb_message_element *el,
164 int flags)
165 {
166 if (ldb_msg_add_empty(msg, el->name, flags, NULL) != 0) {
167 return LDB_ERR_OPERATIONS_ERROR;
168 }
169
170 msg->elements[msg->num_elements-1] = *el;
171 msg->elements[msg->num_elements-1].flags = flags;
172
173 return LDB_SUCCESS;
174 }
175
176 /*
177 add a value to a message
178 */
179 int ldb_msg_add_value(struct ldb_message *msg,
180 const char *attr_name,
181 const struct ldb_val *val,
182 struct ldb_message_element **return_el)
183 {
184 struct ldb_message_element *el;
185 struct ldb_val *vals;
186 int ret;
187
188 el = ldb_msg_find_element(msg, attr_name);
189 if (!el) {
190 ret = ldb_msg_add_empty(msg, attr_name, 0, &el);
191 if (ret != LDB_SUCCESS) {
192 return ret;
193 }
194 }
195
196 vals = talloc_realloc(msg, el->values, struct ldb_val, el->num_values+1);
197 if (!vals) {
198 errno = ENOMEM;
199 return LDB_ERR_OPERATIONS_ERROR;
200 }
201 el->values = vals;
202 el->values[el->num_values] = *val;
203 el->num_values++;
204
205 if (return_el) {
206 *return_el = el;
207 }
208
209 return LDB_SUCCESS;
210 }
211
212
213 /*
214 add a value to a message, stealing it into the 'right' place
215 */
216 int ldb_msg_add_steal_value(struct ldb_message *msg,
217 const char *attr_name,
218 struct ldb_val *val)
219 {
220 int ret;
221 struct ldb_message_element *el;
222
223 ret = ldb_msg_add_value(msg, attr_name, val, &el);
224 if (ret == LDB_SUCCESS) {
225 talloc_steal(el->values, val->data);
226 }
227 return ret;
228 }
229
230
231 /*
232 add a string element to a message
233 */
234 int ldb_msg_add_string(struct ldb_message *msg,
235 const char *attr_name, const char *str)
236 {
237 struct ldb_val val;
238
239 val.data = discard_const_p(uint8_t, str);
240 val.length = strlen(str);
241
242 if (val.length == 0) {
243 /* allow empty strings as non-existant attributes */
244 return LDB_SUCCESS;
245 }
246
247 return ldb_msg_add_value(msg, attr_name, &val, NULL);
248 }
249
250 /*
251 add a string element to a message, stealing it into the 'right' place
252 */
253 int ldb_msg_add_steal_string(struct ldb_message *msg,
254 const char *attr_name, char *str)
255 {
256 struct ldb_val val;
257
258 val.data = (uint8_t *)str;
259 val.length = strlen(str);
260
261 return ldb_msg_add_steal_value(msg, attr_name, &val);
262 }
263
264 /*
265 add a printf formatted element to a message
266 */
267 int ldb_msg_add_fmt(struct ldb_message *msg,
268 const char *attr_name, const char *fmt, ...)
269 {
270 struct ldb_val val;
271 va_list ap;
272 char *str;
273
274 va_start(ap, fmt);
275 str = talloc_vasprintf(msg, fmt, ap);
276 va_end(ap);
277
278 if (str == NULL) return LDB_ERR_OPERATIONS_ERROR;
279
280 val.data = (uint8_t *)str;
281 val.length = strlen(str);
282
283 return ldb_msg_add_steal_value(msg, attr_name, &val);
284 }
285
286 /*
287 compare two ldb_message_element structures
288 assumes case senistive comparison
289 */
290 int ldb_msg_element_compare(struct ldb_message_element *el1,
291 struct ldb_message_element *el2)
292 {
293 unsigned int i;
294
295 if (el1->num_values != el2->num_values) {
296 return el1->num_values - el2->num_values;
297 }
298
299 for (i=0;i<el1->num_values;i++) {
300 if (!ldb_msg_find_val(el2, &el1->values[i])) {
301 return -1;
302 }
303 }
304
305 return 0;
306 }
307
308 /*
309 compare two ldb_message_element structures
310 comparing by element name
311 */
312 int ldb_msg_element_compare_name(struct ldb_message_element *el1,
313 struct ldb_message_element *el2)
314 {
315 return ldb_attr_cmp(el1->name, el2->name);
316 }
317
318 /*
319 convenience functions to return common types from a message
320 these return the first value if the attribute is multi-valued
321 */
322 const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, const char *attr_name)
323 {
324 struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
325 if (!el || el->num_values == 0) {
326 return NULL;
327 }
328 return &el->values[0];
329 }
330
331 int ldb_msg_find_attr_as_int(const struct ldb_message *msg,
332 const char *attr_name,
333 int default_value)
334 {
335 const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
336 if (!v || !v->data) {
337 return default_value;
338 }
339 return strtol((const char *)v->data, NULL, 0);
340 }
341
342 unsigned int ldb_msg_find_attr_as_uint(const struct ldb_message *msg,
343 const char *attr_name,
344 unsigned int default_value)
345 {
346 const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
347 if (!v || !v->data) {
348 return default_value;
349 }
350 return strtoul((const char *)v->data, NULL, 0);
351 }
352
353 int64_t ldb_msg_find_attr_as_int64(const struct ldb_message *msg,
354 const char *attr_name,
355 int64_t default_value)
356 {
357 const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
358 if (!v || !v->data) {
359 return default_value;
360 }
361 return strtoll((const char *)v->data, NULL, 0);
362 }
363
364 uint64_t ldb_msg_find_attr_as_uint64(const struct ldb_message *msg,
365 const char *attr_name,
366 uint64_t default_value)
367 {
368 const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
369 if (!v || !v->data) {
370 return default_value;
371 }
372 return strtoull((const char *)v->data, NULL, 0);
373 }
374
375 double ldb_msg_find_attr_as_double(const struct ldb_message *msg,
376 const char *attr_name,
377 double default_value)
378 {
379 const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
380 if (!v || !v->data) {
381 return default_value;
382 }
383 return strtod((const char *)v->data, NULL);
384 }
385
386 int ldb_msg_find_attr_as_bool(const struct ldb_message *msg,
387 const char *attr_name,
388 int default_value)
389 {
390 const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
391 if (!v || !v->data) {
392 return default_value;
393 }
394 if (strcasecmp((const char *)v->data, "FALSE") == 0) {
395 return 0;
396 }
397 if (strcasecmp((const char *)v->data, "TRUE") == 0) {
398 return 1;
399 }
400 return default_value;
401 }
402
403 const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg,
404 const char *attr_name,
405 const char *default_value)
406 {
407 const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
408 if (!v || !v->data) {
409 return default_value;
410 }
411 return (const char *)v->data;
412 }
413
414 struct ldb_dn *ldb_msg_find_attr_as_dn(void *mem_ctx,
415 const struct ldb_message *msg,
416 const char *attr_name)
417 {
418 const struct ldb_val *v;
419
420 v = ldb_msg_find_ldb_val(msg, attr_name);
421 if (!v || !v->data) {
422 return NULL;
423 }
424 return ldb_dn_explode(mem_ctx, (const char *)v->data);
425 }
426
427 /*
428 sort the elements of a message by name
429 */
430 void ldb_msg_sort_elements(struct ldb_message *msg)
431 {
432 qsort(msg->elements, msg->num_elements, sizeof(struct ldb_message_element),
433 (comparison_fn_t)ldb_msg_element_compare_name);
434 }
435
436 /*
437 shallow copy a message - copying only the elements array so that the caller
438 can safely add new elements without changing the message
439 */
440 struct ldb_message *ldb_msg_copy_shallow(TALLOC_CTX *mem_ctx,
441 const struct ldb_message *msg)
442 {
443 struct ldb_message *msg2;
444 int i;
445
446 msg2 = talloc(mem_ctx, struct ldb_message);
447 if (msg2 == NULL) return NULL;
448
449 *msg2 = *msg;
450 msg2->private_data = NULL;
451
452 msg2->elements = talloc_array(msg2, struct ldb_message_element,
453 msg2->num_elements);
454 if (msg2->elements == NULL) goto failed;
455
456 for (i=0;i<msg2->num_elements;i++) {
457 msg2->elements[i] = msg->elements[i];
458 }
459
460 return msg2;
461
462 failed:
463 talloc_free(msg2);
464 return NULL;
465 }
466
467
468 /*
469 copy a message, allocating new memory for all parts
470 */
471 struct ldb_message *ldb_msg_copy(TALLOC_CTX *mem_ctx,
472 const struct ldb_message *msg)
473 {
474 struct ldb_message *msg2;
475 int i, j;
476
477 msg2 = ldb_msg_copy_shallow(mem_ctx, msg);
478 if (msg2 == NULL) return NULL;
479
480 msg2->dn = ldb_dn_copy(msg2, msg2->dn);
481 if (msg2->dn == NULL) goto failed;
482
483 for (i=0;i<msg2->num_elements;i++) {
484 struct ldb_message_element *el = &msg2->elements[i];
485 struct ldb_val *values = el->values;
486 el->name = talloc_strdup(msg2->elements, el->name);
487 if (el->name == NULL) goto failed;
488 el->values = talloc_array(msg2->elements, struct ldb_val, el->num_values);
489 for (j=0;j<el->num_values;j++) {
490 el->values[j] = ldb_val_dup(el->values, &values[j]);
491 if (el->values[j].data == NULL && values[j].length != 0) {
492 goto failed;
493 }
494 }
495 }
496
497 return msg2;
498
499 failed:
500 talloc_free(msg2);
501 return NULL;
502 }
503
504
505 /*
506 canonicalise a message, merging elements of the same name
507 */
508 struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
509 const struct ldb_message *msg)
510 {
511 int i;
512 struct ldb_message *msg2;
513
514 msg2 = ldb_msg_copy(ldb, msg);
515 if (msg2 == NULL) return NULL;
516
517 ldb_msg_sort_elements(msg2);
518
519 for (i=1;i<msg2->num_elements;i++) {
520 struct ldb_message_element *el1 = &msg2->elements[i-1];
521 struct ldb_message_element *el2 = &msg2->elements[i];
522 if (ldb_msg_element_compare_name(el1, el2) == 0) {
523 el1->values = talloc_realloc(msg2->elements, el1->values, struct ldb_val,
524 el1->num_values + el2->num_values);
525 if (el1->values == NULL) {
526 return NULL;
527 }
528 memcpy(el1->values + el1->num_values,
529 el2->values,
530 sizeof(struct ldb_val) * el2->num_values);
531 el1->num_values += el2->num_values;
532 talloc_free(discard_const_p(char, el2->name));
533 if (i+1<msg2->num_elements) {
534 memmove(el2, el2+1, sizeof(struct ldb_message_element) *
535 (msg2->num_elements - (i+1)));
536 }
537 msg2->num_elements--;
538 i--;
539 }
540 }
541
542 return msg2;
543 }
544
545
546 /*
547 return a ldb_message representing the differences between msg1 and msg2. If you
548 then use this in a ldb_modify() call it can be used to save edits to a message
549 */
550 struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
551 struct ldb_message *msg1,
552 struct ldb_message *msg2)
553 {
554 struct ldb_message *mod;
555 struct ldb_message_element *el;
556 unsigned int i;
557
558 mod = ldb_msg_new(ldb);
559
560 mod->dn = msg1->dn;
561 mod->num_elements = 0;
562 mod->elements = NULL;
563
564 msg2 = ldb_msg_canonicalize(ldb, msg2);
565 if (msg2 == NULL) {
566 return NULL;
567 }
568
569 /* look in msg2 to find elements that need to be added
570 or modified */
571 for (i=0;i<msg2->num_elements;i++) {
572 el = ldb_msg_find_element(msg1, msg2->elements[i].name);
573
574 if (el && ldb_msg_element_compare(el, &msg2->elements[i]) == 0) {
575 continue;
576 }
577
578 if (ldb_msg_add(mod,
579 &msg2->elements[i],
580 el?LDB_FLAG_MOD_REPLACE:LDB_FLAG_MOD_ADD) != 0) {
581 return NULL;
582 }
583 }
584
585 /* look in msg1 to find elements that need to be deleted */
586 for (i=0;i<msg1->num_elements;i++) {
587 el = ldb_msg_find_element(msg2, msg1->elements[i].name);
588 if (!el) {
589 if (ldb_msg_add_empty(mod,
590 msg1->elements[i].name,
591 LDB_FLAG_MOD_DELETE, NULL) != 0) {
592 return NULL;
593 }
594 }
595 }
596
597 return mod;
598 }
599
600 int ldb_msg_sanity_check(struct ldb_context *ldb,
601 const struct ldb_message *msg)
602 {
603 int i, j;
604
605 /* basic check on DN */
606 if (msg->dn == NULL) {
607 /* TODO: return also an error string */
608 ldb_set_errstring(ldb, "ldb message lacks a DN!");
609 return LDB_ERR_INVALID_DN_SYNTAX;
610 }
611
612 /* basic syntax checks */
613 for (i = 0; i < msg->num_elements; i++) {
614 for (j = 0; j < msg->elements[i].num_values; j++) {
615 if (msg->elements[i].values[j].length == 0) {
616 TALLOC_CTX *mem_ctx = talloc_new(ldb);
617 /* an attribute cannot be empty */
618 /* TODO: return also an error string */
619 ldb_asprintf_errstring(ldb, "Element %s has empty attribute in ldb message (%s)!",
620 msg->elements[i].name,
621 ldb_dn_linearize(mem_ctx, msg->dn));
622 talloc_free(mem_ctx);
623 return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
624 }
625 }
626 }
627
628 return LDB_SUCCESS;
629 }
630
631
632
633
634 /*
635 copy an attribute list. This only copies the array, not the elements
636 (ie. the elements are left as the same pointers)
637 */
638 const char **ldb_attr_list_copy(TALLOC_CTX *mem_ctx, const char * const *attrs)
639 {
640 const char **ret;
641 int i;
642 for (i=0;attrs[i];i++) /* noop */ ;
643 ret = talloc_array(mem_ctx, const char *, i+1);
644 if (ret == NULL) {
645 return NULL;
646 }
647 for (i=0;attrs[i];i++) {
648 ret[i] = attrs[i];
649 }
650 ret[i] = attrs[i];
651 return ret;
652 }
653
654
655 /*
656 copy an attribute list. This only copies the array, not the elements
657 (ie. the elements are left as the same pointers). The new attribute is added to the list.
658 */
659 const char **ldb_attr_list_copy_add(TALLOC_CTX *mem_ctx, const char * const *attrs, const char *new_attr)
660 {
661 const char **ret;
662 int i;
663 for (i=0;attrs[i];i++) /* noop */ ;
664 ret = talloc_array(mem_ctx, const char *, i+2);
665 if (ret == NULL) {
666 return NULL;
667 }
668 for (i=0;attrs[i];i++) {
669 ret[i] = attrs[i];
670 }
671 ret[i] = new_attr;
672 ret[i+1] = NULL;
673 return ret;
674 }
675
676
677 /*
678 return 1 if an attribute is in a list of attributes, or 0 otherwise
679 */
680 int ldb_attr_in_list(const char * const *attrs, const char *attr)
681 {
682 int i;
683 for (i=0;attrs[i];i++) {
684 if (ldb_attr_cmp(attrs[i], attr) == 0) {
685 return 1;
686 }
687 }
688 return 0;
689 }
690
691
692 /*
693 rename the specified attribute in a search result
694 */
695 int ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *replace)
696 {
697 struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
698 if (el == NULL) {
699 return LDB_SUCCESS;
700 }
701 el->name = talloc_strdup(msg->elements, replace);
702 if (el->name == NULL) {
703 return LDB_ERR_OPERATIONS_ERROR;
704 }
705 return LDB_SUCCESS;
706 }
707
708
709 /*
710 copy the specified attribute in a search result to a new attribute
711 */
712 int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *replace)
713 {
714 struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
715 if (el == NULL) {
716 return LDB_SUCCESS;
717 }
718 if (ldb_msg_add(msg, el, 0) != 0) {
719 return LDB_ERR_OPERATIONS_ERROR;
720 }
721 return ldb_msg_rename_attr(msg, attr, replace);
722 }
723
724
725 /*
726 remove the specified attribute in a search result
727 */
728 void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
729 {
730 struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
731 if (el) {
732 int n = (el - msg->elements);
733 if (n != msg->num_elements-1) {
734 memmove(el, el+1, ((msg->num_elements-1) - n)*sizeof(*el));
735 }
736 msg->num_elements--;
737 }
738 }
739
740 /*
741 remove the specified element in a search result
742 */
743 void ldb_msg_remove_element(struct ldb_message *msg, struct ldb_message_element *el)
744 {
745 int n = (el - msg->elements);
746 if (n != msg->num_elements-1) {
747 memmove(el, el+1, ((msg->num_elements-1) - n)*sizeof(*el));
748 }
749 msg->num_elements--;
750 }
751
752 /*
753 return a LDAP formatted time string
754 */
755 char *ldb_timestring(TALLOC_CTX *mem_ctx, time_t t)
756 {
757 struct tm *tm = gmtime(&t);
758
759 if (!tm) {
760 return NULL;
761 }
762
763 /* formatted like: 20040408072012.0Z */
764 return talloc_asprintf(mem_ctx,
765 "%04u%02u%02u%02u%02u%02u.0Z",
766 tm->tm_year+1900, tm->tm_mon+1,
767 tm->tm_mday, tm->tm_hour, tm->tm_min,
768 tm->tm_sec);
769 }
770
771
772 /*
773 convert a LDAP time string to a time_t. Return 0 if unable to convert
774 */
775 time_t ldb_string_to_time(const char *s)
776 {
777 struct tm tm;
778
779 if (s == NULL) return 0;
780
781 memset(&tm, 0, sizeof(tm));
782 if (sscanf(s, "%04u%02u%02u%02u%02u%02u",
783 &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
784 &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
785 return 0;
786 }
787 tm.tm_year -= 1900;
788 tm.tm_mon -= 1;
789
790 return timegm(&tm);
791 }
792
793
794 /*
795 dump a set of results to a file. Useful from within gdb
796 */
797 void ldb_dump_results(struct ldb_context *ldb, struct ldb_result *result, FILE *f)
798 {
799 int i;
800
801 for (i = 0; i < result->count; i++) {
802 struct ldb_ldif ldif;
803 fprintf(f, "# record %d\n", i+1);
804 ldif.changetype = LDB_CHANGETYPE_NONE;
805 ldif.msg = result->msgs[i];
806 ldb_ldif_write_file(ldb, f, &ldif);
807 }
808 }
809
810 int ldb_msg_check_string_attribute(const struct ldb_message *msg, const char *name, const char *value)
811 {
812 struct ldb_message_element *el;
813 struct ldb_val val;
814
815 el = ldb_msg_find_element(msg, name);
816 if (el == NULL)
817 return 0;
818
819 val.data = discard_const_p(uint8_t, value);
820 val.length = strlen(value);
821
822 if (ldb_msg_find_val(el, &val))
823 return 1;
824
825 return 0;
826 }
Samba GIT mirror