4 Copyright (C) Simo Sorce 2005
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 2 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, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 * Component: ldb dn explode and utility functions
30 * Description: - explode a dn into it's own basic elements
31 * and put them in a structure
32 * - manipulate ldb_dn structures
38 #include "ldb/include/includes.h"
40 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
42 #define LDB_SPECIAL "@SPECIAL"
44 int ldb_dn_is_special(const struct ldb_dn *dn)
46 if (dn == NULL || dn->comp_num != 1) return 0;
48 return ! strcmp(dn->components[0].name, LDB_SPECIAL);
51 int ldb_dn_check_special(const struct ldb_dn *dn, const char *check)
53 if (dn == NULL || dn->comp_num != 1) return 0;
55 return ! strcmp((char *)dn->components[0].value.data, check);
58 char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
60 const char *p, *s, *src;
67 p = s = src = (const char *)value.data;
70 /* allocate destination string, it will be at most 3 times the source */
71 dst = d = talloc_array(mem_ctx, char, len * 3 + 1);
72 LDB_DN_NULL_FAILED(dst);
74 while (p - src < len) {
76 p += strcspn(p, ",=\n+<>#;\\\"");
78 if (p - src == len) /* found no escapable chars */
81 memcpy(d, s, p - s); /* copy the part of the string before the stop */
82 d += (p - s); /* move to current position */
84 if (*p) { /* it is a normal escapable character */
87 } else { /* we have a zero byte in the string */
88 strncpy(d, "\00", 3); /* escape the zero */
90 p++; /* skip the zero */
92 s = p; /* move forward */
95 /* copy the last part (with zero) and return */
96 memcpy(d, s, &src[len] - s + 1);
105 static struct ldb_val ldb_dn_unescape_value(void *mem_ctx, const char *src)
107 struct ldb_val value;
109 char *p, *dst = NULL, *end;
111 memset(&value, 0, sizeof(value));
113 LDB_DN_NULL_FAILED(src);
115 dst = p = talloc_memdup(mem_ctx, src, strlen(src) + 1);
116 LDB_DN_NULL_FAILED(dst);
118 end = &dst[strlen(dst)];
121 p += strcspn(p, ",=\n+<>#;\\\"");
124 if (strchr(",=\n+<>#;\\\"", p[1])) {
125 memmove(p, p + 1, end - (p + 1) + 1);
131 if (sscanf(p + 1, "%02x", &x) == 1) {
132 *p = (unsigned char)x;
133 memmove(p + 1, p + 3, end - (p + 3) + 1);
140 /* a string with not escaped specials is invalid (tested) */
146 value.length = end - dst;
147 value.data = (uint8_t *)dst;
155 /* check if the string contains quotes
156 * skips leading and trailing spaces
157 * - returns 0 if no quotes found
158 * - returns 1 if quotes are found and put their position
159 * in *quote_start and *quote_end parameters
160 * - return -1 if there are open quotes
163 static int get_quotes_position(const char *source, int *quote_start, int *quote_end)
167 if (source == NULL || quote_start == NULL || quote_end == NULL) return -1;
171 /* check if there are quotes surrounding the value */
172 p += strspn(p, " \n"); /* skip white spaces */
175 *quote_start = p - source;
180 LDB_DN_NULL_FAILED(p);
182 if (*(p - 1) == '\\')
186 *quote_end = p - source;
196 static char *seek_to_separator(char *string, const char *separators)
199 int ret, qs, qe, escaped;
201 if (string == NULL || separators == NULL) return NULL;
203 p = strchr(string, '=');
204 LDB_DN_NULL_FAILED(p);
208 /* check if there are quotes surrounding the value */
210 ret = get_quotes_position(p, &qs, &qe);
214 if (ret == 1) { /* quotes found */
216 p += qe; /* positioning after quotes */
217 p += strspn(p, " \n"); /* skip white spaces after the quote */
219 if (strcspn(p, separators) != 0) /* if there are characters between quotes */
220 return NULL; /* and separators, the dn is invalid */
222 return p; /* return on the separator */
225 /* no quotes found seek to separators */
229 ret = strcspn(q, separators);
231 if (q[ret - 1] == '\\') {
237 if (ret == 0 && p == q) /* no separators ?! bail out */
246 static char *ldb_dn_trim_string(char *string, const char *edge)
250 /* seek out edge from start of string */
251 s = string + strspn(string, edge);
253 /* backwards skip from end of string */
254 p = &s[strlen(s) - 1];
255 while (p > s && strchr(edge, *p)) {
263 /* we choosed to not support multpile valued components */
264 static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw_component)
266 struct ldb_dn_component dc;
270 memset(&dc, 0, sizeof(dc));
272 if (raw_component == NULL) {
276 /* find attribute type/value separator */
277 p = strchr(raw_component, '=');
278 LDB_DN_NULL_FAILED(p);
280 *p++ = '\0'; /* terminate name and point to value */
282 /* copy and trim name in the component */
283 dc.name = talloc_strdup(mem_ctx, ldb_dn_trim_string(raw_component, " \n"));
287 if (! ldb_valid_attr_name(dc.name)) {
291 ret = get_quotes_position(p, &qs, &qe);
294 case 0: /* no quotes trim the string */
295 p = ldb_dn_trim_string(p, " \n");
296 dc.value = ldb_dn_unescape_value(mem_ctx, p);
299 case 1: /* quotes found get the unquoted string */
302 dc.value.length = strlen(p);
303 dc.value.data = talloc_memdup(mem_ctx, p, dc.value.length + 1);
306 default: /* mismatched quotes ot other error, bail out */
310 if (dc.value.length == 0) {
317 talloc_free(dc.name);
322 struct ldb_dn *ldb_dn_new(void *mem_ctx)
326 edn = talloc(mem_ctx, struct ldb_dn);
327 LDB_DN_NULL_FAILED(edn);
329 /* Initially there are no components */
331 edn->components = NULL;
339 struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
341 struct ldb_dn *edn; /* the exploded dn */
344 if (dn == NULL) return NULL;
346 /* Allocate a structure to hold the exploded DN */
347 edn = ldb_dn_new(mem_ctx);
359 /* Special DNs case */
362 edn->components = talloc(edn, struct ldb_dn_component);
363 if (edn->components == NULL) goto failed;
364 edn->components[0].name = talloc_strdup(edn->components, LDB_SPECIAL);
365 if (edn->components[0].name == NULL) goto failed;
366 edn->components[0].value.data = (uint8_t *)talloc_strdup(edn->components, dn);
367 if (edn->components[0].value.data== NULL) goto failed;
368 edn->components[0].value.length = strlen(dn);
372 pdn = p = talloc_strdup(edn, dn);
373 LDB_DN_NULL_FAILED(pdn);
375 /* get the components */
379 /* terminate the current component and return pointer to the next one */
380 t = seek_to_separator(p, ",;");
381 LDB_DN_NULL_FAILED(t);
383 if (*t) { /* here there is a separator */
384 *t = '\0'; /*terminate */
385 t++; /* a separtor means another component follows */
388 /* allocate space to hold the dn component */
389 edn->components = talloc_realloc(edn, edn->components,
390 struct ldb_dn_component,
392 if (edn->components == NULL)
395 /* store the exploded component in the main structure */
396 edn->components[edn->comp_num] = ldb_dn_explode_component(edn, p);
397 LDB_DN_NULL_FAILED(edn->components[edn->comp_num].name);
401 /* jump to the next component if any */
415 struct ldb_dn *ldb_dn_explode_or_special(void *mem_ctx, const char *dn)
417 struct ldb_dn *edn; /* the exploded dn */
419 if (dn == NULL) return NULL;
421 if (strncasecmp(dn, "<GUID=", 6) == 0) {
422 /* this is special DN returned when the
423 * exploded_dn control is used
426 /* Allocate a structure to hold the exploded DN */
427 edn = ldb_dn_new(mem_ctx);
430 edn->components = talloc(edn, struct ldb_dn_component);
431 if (edn->components == NULL) goto failed;
432 edn->components[0].name = talloc_strdup(edn->components, LDB_SPECIAL);
433 if (edn->components[0].name == NULL) goto failed;
434 edn->components[0].value.data = (uint8_t *)talloc_strdup(edn->components, dn);
435 if (edn->components[0].value.data== NULL) goto failed;
436 edn->components[0].value.length = strlen(dn);
441 return ldb_dn_explode(mem_ctx, dn);
448 char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
453 if (edn == NULL) return NULL;
456 if (ldb_dn_is_special(edn)) {
457 dn = talloc_strdup(mem_ctx, (char *)edn->components[0].value.data);
461 dn = talloc_strdup(mem_ctx, "");
462 LDB_DN_NULL_FAILED(dn);
464 for (i = 0; i < edn->comp_num; i++) {
465 value = ldb_dn_escape_value(dn, edn->components[i].value);
466 LDB_DN_NULL_FAILED(value);
469 dn = talloc_asprintf_append(dn, "%s=%s", edn->components[i].name, value);
471 dn = talloc_asprintf_append(dn, ",%s=%s", edn->components[i].name, value);
473 LDB_DN_NULL_FAILED(dn);
485 /* Determine if dn is below base, in the ldap tree. Used for
486 * evaluating a subtree search.
487 * 0 if they match, otherwise non-zero
490 int ldb_dn_compare_base(struct ldb_context *ldb,
491 const struct ldb_dn *base,
492 const struct ldb_dn *dn)
497 if (base == NULL || base->comp_num == 0) return 0;
498 if (dn == NULL || dn->comp_num == 0) return -1;
500 /* if the base has more componts than the dn, then they differ */
501 if (base->comp_num > dn->comp_num) {
502 return (dn->comp_num - base->comp_num);
505 n0 = base->comp_num - 1;
506 n1 = dn->comp_num - 1;
507 while (n0 >= 0 && n1 >= 0) {
508 const struct ldb_attrib_handler *h;
510 /* compare names (attribute names are guaranteed to be ASCII only) */
511 ret = ldb_attr_cmp(base->components[n0].name,
512 dn->components[n1].name);
517 /* names match, compare values */
518 h = ldb_attrib_handler(ldb, base->components[n0].name);
519 ret = h->comparison_fn(ldb, ldb, &(base->components[n0].value),
520 &(dn->components[n1].value));
531 /* compare DNs using casefolding compare functions.
533 If they match, then return 0
536 int ldb_dn_compare(struct ldb_context *ldb,
537 const struct ldb_dn *edn0,
538 const struct ldb_dn *edn1)
540 if (edn0 == NULL || edn1 == NULL) return edn1 - edn0;
542 if (edn0->comp_num != edn1->comp_num)
543 return (edn1->comp_num - edn0->comp_num);
545 return ldb_dn_compare_base(ldb, edn0, edn1);
548 int ldb_dn_cmp(struct ldb_context *ldb, const char *dn0, const char *dn1)
554 if (dn0 == NULL || dn1 == NULL) return dn1 - dn0;
556 edn0 = ldb_dn_explode_casefold(ldb, dn0);
557 if (edn0 == NULL) return 1;
559 edn1 = ldb_dn_explode_casefold(ldb, dn1);
565 ret = ldb_dn_compare(ldb, edn0, edn1);
574 casefold a dn. We need to casefold the attribute names, and canonicalize
575 attribute values of case insensitive attributes.
577 struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn)
582 if (edn == NULL) return NULL;
584 cedn = ldb_dn_new(ldb);
589 cedn->comp_num = edn->comp_num;
590 cedn->components = talloc_array(cedn, struct ldb_dn_component, edn->comp_num);
591 if (!cedn->components) {
596 for (i = 0; i < edn->comp_num; i++) {
597 struct ldb_dn_component dc;
598 const struct ldb_attrib_handler *h;
600 dc.name = ldb_attr_casefold(cedn, edn->components[i].name);
606 h = ldb_attrib_handler(ldb, dc.name);
607 if (h->canonicalise_fn(ldb, cedn, &(edn->components[i].value), &(dc.value)) != 0) {
612 cedn->components[i] = dc;
618 struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn)
620 struct ldb_dn *edn, *cdn;
622 if (dn == NULL) return NULL;
624 edn = ldb_dn_explode(ldb, dn);
625 if (edn == NULL) return NULL;
627 cdn = ldb_dn_casefold(ldb, edn);
633 char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *edn)
638 if (edn == NULL) return NULL;
641 if (ldb_dn_is_special(edn)) {
642 dn = talloc_strdup(ldb, (char *)edn->components[0].value.data);
646 cdn = ldb_dn_casefold(ldb, edn);
647 if (cdn == NULL) return NULL;
649 dn = ldb_dn_linearize(ldb, cdn);
659 static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_dn_component *src)
661 struct ldb_dn_component dst;
663 memset(&dst, 0, sizeof(dst));
669 dst.value = ldb_val_dup(mem_ctx, &(src->value));
670 if (dst.value.data == NULL) {
674 dst.name = talloc_strdup(mem_ctx, src->name);
675 if (dst.name == NULL) {
676 talloc_free(dst.value.data);
677 dst.value.data = NULL;
683 /* copy specified number of elements of a dn into a new one
684 element are copied from top level up to the unique rdn
685 num_el may be greater than dn->comp_num (see ldb_dn_make_child)
687 struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el)
689 struct ldb_dn *newdn;
692 if (dn == NULL) return NULL;
693 if (num_el <= 0) return NULL;
695 newdn = ldb_dn_new(mem_ctx);
696 LDB_DN_NULL_FAILED(newdn);
698 newdn->comp_num = num_el;
699 n = newdn->comp_num - 1;
700 newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
702 if (dn->comp_num == 0) return newdn;
703 e = dn->comp_num - 1;
705 for (i = 0; i < newdn->comp_num; i++) {
706 newdn->components[n - i] = ldb_dn_copy_component(newdn->components,
707 &(dn->components[e - i]));
720 struct ldb_dn *ldb_dn_copy(void *mem_ctx, const struct ldb_dn *dn)
722 if (dn == NULL) return NULL;
723 return ldb_dn_copy_partial(mem_ctx, dn, dn->comp_num);
726 struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, const struct ldb_dn *dn)
728 if (dn == NULL) return NULL;
729 return ldb_dn_copy_partial(mem_ctx, dn, dn->comp_num - 1);
732 struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
735 struct ldb_dn_component *dc;
737 if (attr == NULL || val == NULL) return NULL;
739 dc = talloc(mem_ctx, struct ldb_dn_component);
740 if (dc == NULL) return NULL;
742 dc->name = talloc_strdup(dc, attr);
743 if (dc->name == NULL) {
748 dc->value.data = (uint8_t *)talloc_strdup(dc, val);
749 if (dc->value.data == NULL) {
754 dc->value.length = strlen(val);
759 struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
761 const struct ldb_dn *base)
763 struct ldb_dn *newdn;
764 if (! ldb_valid_attr_name(attr)) return NULL;
765 if (value == NULL || value == '\0') return NULL;
768 newdn = ldb_dn_copy_partial(mem_ctx, base, base->comp_num + 1);
769 LDB_DN_NULL_FAILED(newdn);
771 newdn = ldb_dn_new(mem_ctx);
772 LDB_DN_NULL_FAILED(newdn);
775 newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
778 newdn->components[0].name = talloc_strdup(newdn->components, attr);
779 LDB_DN_NULL_FAILED(newdn->components[0].name);
781 newdn->components[0].value.data = (uint8_t *)talloc_strdup(newdn->components, value);
782 LDB_DN_NULL_FAILED(newdn->components[0].value.data);
783 newdn->components[0].value.length = strlen((char *)newdn->components[0].value.data);
793 struct ldb_dn *ldb_dn_make_child(void *mem_ctx, const struct ldb_dn_component *component,
794 const struct ldb_dn *base)
796 if (component == NULL) return NULL;
798 return ldb_dn_build_child(mem_ctx, component->name,
799 (char *)component->value.data, base);
802 struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2)
805 struct ldb_dn *newdn;
807 if (dn2 == NULL && dn1 == NULL) {
812 newdn = ldb_dn_new(mem_ctx);
813 LDB_DN_NULL_FAILED(newdn);
815 newdn->comp_num = dn1->comp_num;
816 newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
818 int comp_num = dn2->comp_num;
819 if (dn1 != NULL) comp_num += dn1->comp_num;
820 newdn = ldb_dn_copy_partial(mem_ctx, dn2, comp_num);
827 for (i = 0; i < dn1->comp_num; i++) {
828 newdn->components[i] = ldb_dn_copy_component(newdn->components,
829 &(dn1->components[i]));
830 if (newdn->components[i].value.data == NULL) {
842 struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, const char *child_fmt, ...)
848 if (child_fmt == NULL) return NULL;
850 va_start(ap, child_fmt);
851 child_str = talloc_vasprintf(mem_ctx, child_fmt, ap);
854 if (child_str == NULL) return NULL;
856 dn = ldb_dn_compose(mem_ctx, ldb_dn_explode(mem_ctx, child_str), base);
858 talloc_free(child_str);
863 struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn)
865 struct ldb_dn_component *rdn;
867 if (dn == NULL) return NULL;
869 if (dn->comp_num < 1) {
873 rdn = talloc(mem_ctx, struct ldb_dn_component);
874 if (rdn == NULL) return NULL;
876 *rdn = ldb_dn_copy_component(mem_ctx, &dn->components[0]);
877 if (rdn->name == NULL) {
885 /* Create a 'canonical name' string from a DN:
887 ie dc=samba,dc=org -> samba.org/
888 uid=administrator,ou=users,dc=samba,dc=org = samba.org/users/administrator
890 There are two formats, the EX format has the last / replaced with a newline (\n).
893 static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_format) {
895 char *cracked = NULL;
897 /* Walk backwards down the DN, grabbing 'dc' components at first */
898 for (i = dn->comp_num - 1 ; i >= 0; i--) {
899 if (ldb_attr_cmp(dn->components[i].name, "dc") != 0) {
903 cracked = talloc_asprintf(mem_ctx, "%s.%s",
904 ldb_dn_escape_value(mem_ctx, dn->components[i].value),
907 cracked = ldb_dn_escape_value(mem_ctx, dn->components[i].value);
914 /* Only domain components? Finish here */
917 cracked = talloc_asprintf(mem_ctx, "%s\n", cracked);
919 cracked = talloc_asprintf(mem_ctx, "%s/", cracked);
924 /* Now walk backwards appending remaining components */
926 cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked,
927 ldb_dn_escape_value(mem_ctx, dn->components[i].value));
933 /* Last one, possibly a newline for the 'ex' format */
935 cracked = talloc_asprintf(mem_ctx, "%s\n%s", cracked,
936 ldb_dn_escape_value(mem_ctx, dn->components[i].value));
938 cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked,
939 ldb_dn_escape_value(mem_ctx, dn->components[i].value));
944 /* Wrapper functions for the above, for the two different string formats */
945 char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn) {
946 return ldb_dn_canonical(mem_ctx, dn, 0);
950 char *ldb_dn_canonical_ex_string(void *mem_ctx, const struct ldb_dn *dn) {
951 return ldb_dn_canonical(mem_ctx, dn, 1);