From 7fc1c3553cd3666c234ec302a54ebd331589c934 Mon Sep 17 00:00:00 2001 From: Derrell Lipman Date: Wed, 8 Jun 2005 19:49:49 +0000 Subject: r7408: added DN explode function, based on simo's ldap_parse_dn() function. simo, when you get a chance, please change your license so this can be linked with ldb. (This used to be commit 588a1d1451d4117cb6e427a293455f2a5657b604) --- source4/lib/ldb/common/ldb_explode_dn.c | 461 ++++++++++++++++++++++++++++++++ 1 file changed, 461 insertions(+) create mode 100644 source4/lib/ldb/common/ldb_explode_dn.c (limited to 'source4/lib/ldb/common') diff --git a/source4/lib/ldb/common/ldb_explode_dn.c b/source4/lib/ldb/common/ldb_explode_dn.c new file mode 100644 index 0000000000..db8e8f2a85 --- /dev/null +++ b/source4/lib/ldb/common/ldb_explode_dn.c @@ -0,0 +1,461 @@ +/* + Unix SMB/CIFS implementation. + LDAP server + Copyright (C) Simo Sorce 2004 + Copyright (C) Derrell Lipman 2005 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "includes.h" +#include "ldb/include/ldb.h" +#include "ldb/include/ldb_explode_dn.h" + +#define LDB_PARSE_DN_INVALID(x) do { \ + if (x) { \ + goto failed; \ + } \ +} while(0) + + + +static char +octet_from_hex(char * p, + char * ret) +{ + unsigned char low_char; + unsigned char high_char; + + unsigned char low_binary; + unsigned char high_binary; + + if (p[0] == '\0' || p[1] == '\0') { + return -1; + } + + high_char = p[0]; + low_char = p[1]; + + if (high_char >= '0' && high_char <= '9') { + high_binary = high_char - '0'; + } else if (high_char >= 'A' && high_char <= 'F') { + high_binary = 10 + (high_char - 'A'); + } else if (high_char >= 'a' && high_char <= 'f') { + high_binary = 10 + (high_char - 'a'); + } else { + return -1; + } + + if (low_char >= '0' && low_char <= '9') { + low_binary = low_char - '0'; + } else if (low_char >= 'A' && low_char <= 'F') { + low_binary = 10 + (low_char - 'A'); + } else if (low_char >= 'a' && low_char <= 'f') { + low_binary = 10 + (low_char - 'a'); + } else { + return -1; + } + + *ret = (char) ((high_binary << 4) | low_binary); + return 0; +} + +static char * +parse_slash(char *p, + char *end) +{ + switch (*(p + 1)) { + case ',': + case '=': + case '\n': + case '+': + case '<': + case '>': + case '#': + case ';': + case '\\': + case '"': + memmove(p, p + 1, end - (p + 1)); + return (end - 1); + + default: + if (*(p + 1) != '\0' && *(p + 2) != '\0') { + if (octet_from_hex(p + 1, p) < 0) { + return NULL; + } + memmove(p + 1, p + 3, end - (p + 3)); + return (end - 2); + } else { + return NULL; + } + } +} + +struct ldb_dn * +ldb_explode_dn(void *mem_ctx, + const char *orig_dn) +{ + struct ldb_dn * dn; + struct ldb_dn_component * component; + struct ldb_dn_attribute * attribute; + char * p; + char * start; + char * separator; + char * src; + char * dest; + char * dn_copy; + char * dn_end; + int i; + int size; + int orig_len; + + /* Allocate a structure to hold the exploded DN */ + if ((dn = talloc(mem_ctx, struct ldb_dn)) == NULL) { + return NULL; + } + + /* Initially there are no components */ + dn->comp_num = 0; + + /* Allocate the component array, with space for one component */ + if ((dn->components = + talloc_array(dn, struct ldb_dn_component *, 1)) == NULL) { + + goto failed; + } + + /* Allocate the first component */ + if ((component = talloc(dn, struct ldb_dn_component)) == NULL) { + goto failed; + } + + /* This component has no attributes yet */ + component->attr_num = 0; + + /* Get the length of the provided DN */ + if ((orig_len = strlen(orig_dn)) == 0) { + + /* We found a zero-length DN. Return it. */ + if ((dn->dn = talloc_strdup(dn, orig_dn)) == NULL) { + goto failed; + } + return dn; + } + + /* Copy the provided DN so we can manipulate it */ + if ((dn_copy = p = talloc_strdup(mem_ctx, orig_dn)) == NULL) { + goto failed; + } + + /* Our copy may end shorter than the original as we unescape chars */ + dn_end = dn_copy + orig_len + 1; + + /* For each attribute/value pair... */ + do { + /* Allocate an array to hold the attributes, initially len 1 */ + if ((component->attributes = + talloc_array(component, + struct ldb_dn_attribute *, 1)) == NULL) { + goto failed; + } + + /* Allocate this attribute */ + if ((attribute = + talloc(component, struct ldb_dn_attribute)) == NULL) { + goto failed; + } + + /* skip white space */ + while (*p == ' ' || *p == '\n') { + p++; + } + + /* start parsing this component */ + do { + /* Save pointer to beginning of attribute name */ + start = p; + + /* find our attribute/value separator '=' */ + while (*p != '\0' && *p != '=') { + if (*p == '\\') { + if ((dn_end = + parse_slash(p, dn_end)) == NULL) { + goto failed; + } + } + p++; + } + + /* Ensure we found the attribute/value separator */ + if (*p != '=') { + goto failed; + } + + /* Save pointer to separator */ + separator = p; + + /* remove trailing white space from attribute name */ + while (p > start && + (*(p - 1) == ' ' || *(p - 1) == '\n')) { + + p--; + } + LDB_PARSE_DN_INVALID((p - start) < 1); + + /* save attribute name */ + if ((attribute->name = + talloc_strndup(attribute, + start, + p - start)) == NULL) { + goto failed; + } + + ldb_debug(mem_ctx, + LDB_DEBUG_TRACE, + "attribute name: [%s]\n", attribute->name); + + /* skip white space after the separator */ + p = separator + 1; + p += strspn(p, " \n"); + + /* ensure there's a value here */ + if (*p == '\0') { + goto failed; + } + + /* check if the value is enclosed in QUOTATION */ + if (*p == '"') { + /* save pointer to beginning of attr value */ + start = p + 1; + + /* find the trailing QUOTE */ + while (*p != '\0' && *p != '"') { + if (*p == '\\') { + if ((dn_end = + parse_slash(p, dn_end)) == NULL) { + goto failed; + } + } + + p++; + } + + /* skip spaces until the separator */ + if (*p == '\0') { + /* We're already at end of string */ + separator = p; + } else { + /* Skip spaces */ + separator = p + 1 + strspn(p+1, " \n"); + } + + /* must be end of string or a separator here */ + if (*separator != '\0' && + *separator != ',' && + *separator != ';' && + *separator != '+') { + /* Error Malformed DN */ + goto failed; + } + } else { + /* + * Value is not quouted. + */ + + /* save pointer to beginning of value */ + start = p; + + /* find end of value */ + while (*p != '\0' && + *p != ',' && + *p != ';' && + *p != '+') { + + if (*p == '\\') { + if ((dn_end = + parse_slash(p, dn_end)) == NULL) { + goto failed; + } + } + + p++; + } + + /* save pointer to the terminating separator */ + separator = p; + + /* remove trailing whitespace */ + while (p > start && + (*(p - 1) == ' ' || + *(p - 1) == '\n')) { + + p--; + } + } + LDB_PARSE_DN_INVALID((p - start) < 1); + + /* save the value */ + if ((attribute->value = + talloc_strndup(attribute, + start, + p - start)) == NULL) { + goto failed; + } + + ldb_debug(mem_ctx, + LDB_DEBUG_TRACE, + "attribute value: [%s]\n", attribute->value); + + /* save the entire RDN */ + if ((attribute->rdn = + talloc_asprintf(attribute, + "%s=%s", + attribute->name, + attribute->value)) == NULL) { + goto failed; + } + + ldb_debug(mem_ctx, + LDB_DEBUG_TRACE, + "attribute: [%s]\n", attribute->rdn); + + /* add this attribute to the attribute list */ + component->attributes[component->attr_num] = attribute; + component->attr_num++; + + /* is this a multi-valued attribute? */ + if (*separator == '+') { + /* Yup. prepare for the next value. */ + if ((component->attributes = + talloc_realloc(component, + component->attributes, + struct ldb_dn_attribute *, + component->attr_num + 1)) == NULL) { + goto failed; + } + + /* allocate new attribute structure */ + if ((attribute = + talloc(component, + struct ldb_dn_attribute)) == NULL) { + goto failed; + } + } + + /* if we're not at end of string, skip white space */ + if (*separator != '\0') { + /* skip spaces past the separator */ + p = separator + 1; + p += strspn(p, " \n"); + } + + } while (*separator == '+'); + + /* find total length of all attributes */ + for (i = 0, size = 0; i < component->attr_num; i++) { + size += strlen(component->attributes[i]->rdn) + 1; + } + + /* + * rebuild the normalized component + */ + + /* allocate space for the normalized component */ + if ((component->component = + dest = talloc_size(component, size)) == NULL) { + + goto failed; + } + + /* copy each of the attributes to the normalized component */ + for (i = 0; i < component->attr_num; i++) { + if (i != 0) { + *dest = '+'; + dest++; + } + src = component->attributes[i]->rdn; + do { + *(dest++) = *(src++); + } while(*src); + *dest = '\0'; + } + + ldb_debug(mem_ctx, + LDB_DEBUG_TRACE, + "component: [%s]\n", component->component); + + /* insert the component into the component list */ + dn->components[dn->comp_num] = component; + dn->comp_num++; + + /* if there are additional components... */ + if (*separator == ',' || *separator == ';') { + /* ... then prepare to parse them */ + if ((dn->components = + talloc_realloc(dn, + dn->components, + struct ldb_dn_component *, + dn->comp_num + 1)) == NULL || + (component = + talloc(dn, struct ldb_dn_component)) == NULL) { + + goto failed; + } + + component->attr_num = 0; + } + + /* update pointer to after the separator */ + p = separator + 1; + + } while(*separator == ',' || *separator == ';'); + + /* find total length of all components */ + for (i = 0, size = 0; i < dn->comp_num; i++) { + size = size + strlen(dn->components[i]->component) + 1; + } + + /* rebuild the normalized DN */ + if ((dn->dn = dest = talloc_size(dn, size)) == NULL) { + goto failed; + } + + /* copy the normalized components into the DN */ + for (i = 0; i < dn->comp_num; i++) { + if (i != 0) { + *dest = ','; + dest++; + } + src = dn->components[i]->component; + do { + *(dest++) = *(src++); + } while(*src); + *dest = '\0'; + } + + ldb_debug(mem_ctx, LDB_DEBUG_TRACE, "dn: [%s]\n", dn->dn); + + /* we don't need the copy of the DN any more */ + talloc_free(dn_copy); + + /* give 'em what they came for! */ + return dn; + +failed: + /* something went wrong. free memory and tell 'em it failed */ + talloc_free(dn); + ldb_debug(mem_ctx, LDB_DEBUG_TRACE, "Failed to parse %s\n", orig_dn); + return NULL; +} -- cgit