r15356: Remove unused 'flags' argument from socket_send() and friends.
[bbaumbach/samba-autobuild/.git] / source4 / ldap_server / ldap_parse.c
1 /* 
2    Unix SMB/CIFS implementation.
3    LDAP server
4    Copyright (C) Simo Sorce 2004
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22 #include "ldap_parse.h"
23
24 static char char_from_hex(char a, char b) {
25         char m, l;
26
27         if ('0' <= a  && a <= '9') {
28                 m = a - '0';
29         } else if ('A' <= a && a <= 'F') {
30                 m = 10 + (a - 'A');
31         } else if ('a' <= a && a <= 'f') {
32                 m = 10 + (a - 'a');
33         } else {
34                 return a;
35         }
36
37         if ('0' <= b  && b <= '9') {
38                 l = b - '0';
39         } else if ('A' <= b && b <= 'F') {
40                 l = 10 + (b - 'A');
41         } else if ('a' <= b && b <= 'f') {
42                 l = 10 + (b - 'a');
43         } else {
44                 return a;
45         }
46
47         return ((m << 4) + l);
48 }
49
50 static char *parse_slash(char *p, char *end) {
51         switch (*(p + 1)) {
52         case ',':
53         case '=':
54         case '\n':
55         case '+':
56         case '<':
57         case '>':
58         case '#':
59         case ';':
60         case '\\':
61         case '"':
62                 memmove(p, p + 1, end - (p + 1));
63                 return (end - 1);
64         default:
65                 *p = char_from_hex(*(p + 1), *(p + 2));
66                 memmove(p + 1, p + 3, end - (p + 3));
67                 return (end - 2);
68         }
69 }
70
71 #define LDAP_PARSE_DN_INVALID(x) do {\
72         if (x) { \
73                 dn->comp_num = -1; \
74                 return dn; \
75         } \
76 } while(0)
77
78 #if 0
79 static void ldap_parse_attributetypedescription(struct ldap_schema *schema, DATA_BLOB *data)
80 {
81         char *desc;
82
83         desc = talloc_array(schema, char, data->lenght + 1);
84         memcpy(desc, data->data, data->lenght);
85         desc[data->lenght] = '\0';
86
87 }
88
89 static void ldap_parse_objectclassdescription(struct ldap_schema *schema, DATA_BLOB *data)
90 {
91         char *desc;
92
93         desc = talloc_array(schema, char, data->lenght + 1);
94         memcpy(desc, data->data, data->lenght);
95         desc[data->lenght] = '\0';
96
97 }
98
99 static struct ldap_schema *ldap_get_schema(void *mem_ctx, struct ldap_schema *schema, struct ldb_context *ldb)
100 {
101         NTSTATUS status;
102         struct ldap_schema *local_schema;
103         struct ldb_message **res;
104         const char *errstr;
105         const char *schema_dn = "cn=schema";
106         const char *attr_filter = "attributeTypeDescription=*";
107         const char *class_filter = "objectClassDescription=*";
108         const char *attrs = "attributeTypeDescription";
109         const char *classes = "objectClassDescription";
110         enum ldb_scope scope = LDAP_SCOPE_SUBTREE;
111         int count, i, j, k;
112
113         local_schema = schema;
114         if (local_schema == NULL) {
115                 local_schema = talloc(mem_ctx, struct ldap_schema);
116                 ALLOC_CHECK(local_schema);
117         }
118
119         count = ldb_search(ldb, schema_dn, scope, attr_filter, attrs, &res);
120
121         for (i = 0; i < count; i++) {
122                 if (res[i]->num_elements == 0) {
123                         goto attr_done;
124                 }
125                 for (j = 0; j < res[i]->num_elements; j++) {
126                         for (k = 0; res[i]->elements[j].num_values; k++) {
127                                 ldap_parse_attributetypedescription(local_schema, &(res[i]->elements[j].values[k]));
128                         }
129                 }
130 attr_done:
131         }
132
133         count = ldb_search(ldb, schema_dn, scope, class_filter, classes, &res);
134
135         for (i = 0; i < count; i++) {
136                 if (res[i]->num_elements == 0) {
137                         goto class_done;
138                 }
139                 for (j = 0; j < res[i]->num_elements; j++) {
140                         for (k = 0; res[i]->elements[j].num_values; k++) {
141                                 ldap_parse_objectclassdescription(local_schema, &(res[i]->elements[j].values[k]));
142                         }
143                 }
144 class_done:
145         }
146
147         return local_schema;
148 }
149 #endif
150
151 struct ldap_dn *ldap_parse_dn(void *mem_ctx, const char *orig_dn)
152 {
153         struct ldap_dn *dn;
154         struct dn_component *component;
155         struct dn_attribute *attribute;
156         char *p, *start, *separator, *src, *dest, *dn_copy, *dn_end;
157         int i, size, orig_len;
158
159         dn = talloc(mem_ctx, struct ldap_dn);
160         dn->comp_num = 0;
161         dn->components = talloc_array(dn, struct dn_component *, 1);
162         component = talloc(dn, struct dn_component);
163         component->attr_num = 0;
164
165         orig_len = strlen(orig_dn);
166         if (orig_len == 0) {
167                 dn->dn = talloc_strdup(dn, orig_dn);
168                 return dn;
169         }
170
171         dn_copy = p = talloc_strdup(mem_ctx, orig_dn);
172         dn_end = dn_copy + orig_len + 1;
173         do {
174                 component->attributes = talloc_array(component, struct dn_attribute *, 1);
175                 attribute = talloc(component, struct dn_attribute);
176
177                 /* skip "spaces" */
178                 while (*p == ' ' || *p == '\n') {
179                         p++;
180                 }
181
182                 /* start parsing this component */
183                 do {
184                         start = p;
185
186                         /* find out key separator '=' */
187                         while (*p && *p != '=') {
188                                 if (*p == '\\') {
189                                         dn_end = parse_slash(p, dn_end);
190                                 }
191                                 p++;
192                         }
193                         separator = p;
194
195                         /* remove spaces */
196                         while (*(p - 1) == ' ' || *(p - 1) == '\n') {
197                                 p--;
198                         }
199
200                         /* save key name */
201                         LDAP_PARSE_DN_INVALID((p - start) < 1);
202                         attribute->name = talloc_strndup(attribute, start, p - start);
203                         DEBUG(10, ("attribute name: [%s]\n", attribute->name));
204
205                         p = separator + 1;
206
207                         /* skip spaces past the separator */
208                         p = separator + strspn(p, " \n") + 1;
209                         start = p;
210
211                         /* check if the value is enclosed in QUOTATION */
212                         if (*p == '"') {
213                                 start = p + 1;
214                                 while (*p && *p != '"') {
215                                         if (*p == '\\') {
216                                                 dn_end = parse_slash(p, dn_end);
217                                         }
218                                         p++;
219                                 }
220
221                                 /* skip spaces until the separator */
222                                 separator = p + strspn(p, " \n");
223
224                                 if (*separator != ',' && *separator != ';' && *separator != '+') { /* there must be a separator here */
225                                         /* Error Malformed DN */
226                                         DEBUG (0, ("Error: Malformed DN!\n"));
227                                         break;
228                                 }
229                         } else {
230                                 while (*p && !(*p == ',' || *p == ';' || *p == '+')) {
231                                         if (*p == '\\') {
232                                                 dn_end = parse_slash(p, dn_end);
233                                         }
234                                         p++;
235                                 } /* found separator */
236
237                                 separator = p;
238
239                                 /* remove spaces */
240                                 while (*(p - 1) == ' ' || *(p - 1) == '\n') {
241                                         p--;
242                                 }
243                         }
244
245                         /* save the value */
246                         LDAP_PARSE_DN_INVALID((p - start) < 1);
247                         attribute->value = talloc_strndup(attribute, start, p - start);
248                         DEBUG(10, ("attribute value: [%s]\n", attribute->value));
249
250                         attribute->attribute = talloc_asprintf(attribute,"%s=%s", attribute->name, attribute->value);
251                         DEBUG(10, ("attribute: [%s]\n", attribute->attribute));
252
253                         /* save the attribute */
254                         component->attributes[component->attr_num] = attribute;
255                         component->attr_num++;
256
257                         if (*separator == '+') { /* expect other attributes in this component */
258                                 component->attributes = talloc_realloc(component, component->attributes, struct dn_attribute *, component->attr_num + 1);
259
260                                 /* allocate new attribute structure */
261                                 attribute = talloc(component, struct dn_attribute);
262
263                                 /* skip spaces past the separator */
264                                 p = separator + strspn(p, " \n");
265                         }
266
267                 } while (*separator == '+');
268
269                 /* found component bounds */
270                 for (i = 0, size = 0; i < component->attr_num; i++) {
271                         size = size + strlen(component->attributes[i]->attribute) + 1;
272                 }
273
274                 /* rebuild the normlaized component and put it here */
275                 component->component = dest = talloc_size(component, size);
276                 for (i = 0; i < component->attr_num; i++) {
277                         if (i != 0) {
278                                 *dest = '+';
279                                 dest++;
280                         }
281                         src = component->attributes[i]->attribute;
282                         do {
283                                 *(dest++) = *(src++);
284                         } while(*src);
285                         *dest = '\0';
286                 }
287                 DEBUG(10, ("component: [%s]\n", component->component));
288
289                 dn->components[dn->comp_num] = component;
290                 dn->comp_num++;
291
292                 if (*separator == ',' || *separator == ';') {
293                         dn->components = talloc_realloc(dn, dn->components, struct dn_component *, dn->comp_num + 1);
294                         component = talloc(dn, struct dn_component);
295                         component->attr_num = 0;
296                 }
297                 p = separator + 1;
298
299         } while(*separator == ',' || *separator == ';');
300
301         for (i = 0, size = 0; i < dn->comp_num; i++) {
302                 size = size + strlen(dn->components[i]->component) + 1;
303         }
304
305         /* rebuild the normlaized dn and put it here */
306         dn->dn = dest = talloc_size(dn, size);
307         for (i = 0; i < dn->comp_num; i++) {
308                 if (i != 0) {
309                         *dest = ',';
310                         dest++;
311                 }
312                 src = dn->components[i]->component;
313                 do {
314                         *(dest++) = *(src++);
315                 } while(*src);
316                 *dest = '\0';
317         }
318         DEBUG(10, ("dn: [%s]\n", dn->dn));
319
320         talloc_free(dn_copy);
321
322         return dn;
323 }