dlls/adsldp/schema.c

   1 /*
   2  * Copyright 2020 Dmitry Timoshkov
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "iads.h"
  24 #include "winldap.h"
  25
  26 #include "adsldp_private.h"
  27
  28 #include "wine/heap.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(adsldp);
  32
  33 static const struct attribute_type *find_schema_type_sorted(const WCHAR *name, const struct attribute_type *at, ULONG count)
  34 {
  35     int idx, min, max, res;
  36
  37     if (!count) return NULL;
  38
  39     min = 0;
  40     max = count - 1;
  41
  42     while (min <= max)
  43     {
  44         idx = (min + max) / 2;
  45         res = wcsicmp(name, at[idx].name);
  46         if (!res) return &at[idx];
  47         if (res > 0) min = idx + 1;
  48         else max = idx - 1;
  49     }
  50
  51     return NULL;
  52 }
  53
  54
  55 static const struct attribute_type *find_schema_type(const WCHAR *name, const struct attribute_type *at, ULONG single, ULONG multiple)
  56 {
  57     const struct attribute_type *found;
  58     ULONG i, n, off;
  59
  60     /* Perform binary search within definitions with single name */
  61     found = find_schema_type_sorted(name, at, single);
  62     if (found) return found;
  63
  64     /* Perform linear search within definitions with multiple names */
  65     at += single;
  66
  67     for (i = 0; i < multiple; i++)
  68     {
  69         off = 0;
  70
  71         for (n = 0; n < at[i].name_count; n++)
  72         {
  73             if (!wcsicmp(at[i].name + off, name)) return &at[i];
  74             off += wcslen(at[i].name + off) + 1;
  75         }
  76     }
  77
  78     FIXME("%s not found\n", debugstr_w(name));
  79     return NULL;
  80 }
  81
  82 /* RFC 4517 */
  83 ADSTYPEENUM get_schema_type(const WCHAR *name, const struct attribute_type *at, ULONG single, ULONG multiple)
  84 {
  85     const struct attribute_type *type;
  86
  87     type = find_schema_type(name, at, single, multiple);
  88     if (!type || !type->syntax) return ADSTYPE_CASE_IGNORE_STRING;
  89
  90     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.7"))
  91         return ADSTYPE_BOOLEAN;
  92     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.12"))
  93         return ADSTYPE_DN_STRING;
  94     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.15"))
  95         return ADSTYPE_CASE_IGNORE_STRING;
  96     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.24"))
  97         return ADSTYPE_UTC_TIME;
  98     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.26"))
  99         return ADSTYPE_CASE_IGNORE_STRING;
 100     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.27"))
 101         return ADSTYPE_INTEGER;
 102     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.38"))
 103         return ADSTYPE_CASE_IGNORE_STRING;
 104     if (!wcscmp(type->syntax, L"1.3.6.1.4.1.1466.115.121.1.40"))
 105         return ADSTYPE_OCTET_STRING;
 106     if (!wcscmp(type->syntax, L"1.2.840.113556.1.4.903"))
 107         return ADSTYPE_DN_WITH_BINARY;
 108     if (!wcscmp(type->syntax, L"1.2.840.113556.1.4.906"))
 109         return ADSTYPE_LARGE_INTEGER;
 110     if (!wcscmp(type->syntax, L"1.2.840.113556.1.4.907"))
 111         return ADSTYPE_NT_SECURITY_DESCRIPTOR;
 112
 113     FIXME("not handled type syntax %s for %s\n", debugstr_w(type->syntax), debugstr_w(name));
 114     return ADSTYPE_CASE_IGNORE_STRING;
 115 }
 116
 117 static void free_attribute_type(struct attribute_type *at)
 118 {
 119     heap_free(at->oid);
 120     heap_free(at->name);
 121     heap_free(at->syntax);
 122 }
 123
 124 void free_attribute_types(struct attribute_type *at, ULONG count)
 125 {
 126     ULONG i;
 127
 128     for (i = 0; i < count; i++)
 129         free_attribute_type(&at[i]);
 130
 131     heap_free(at);
 132 }
 133
 134 static BOOL is_space(WCHAR c)
 135 {
 136     return c == ' ' || c == '\t' || c == '\r' || c == '\n';
 137 }
 138
 139 static WCHAR *parse_oid(WCHAR **str)
 140 {
 141     WCHAR *oid, *p = *str, *end;
 142     int count;
 143
 144     while (is_space(*p)) p++;
 145
 146     if (*p == '\'')
 147     {
 148         p++;
 149         end = wcschr(p, '\'');
 150         if (!end) return NULL;
 151     }
 152     else
 153     {
 154         end = p;
 155         while (!is_space(*end)) end++;
 156     }
 157
 158     count = end - p;
 159     oid = heap_alloc((count + 1) * sizeof(WCHAR));
 160     if (!oid) return NULL;
 161
 162     memcpy(oid, p, count * sizeof(WCHAR));
 163     oid[count] = 0;
 164
 165     *str = end + 1;
 166
 167     return oid;
 168 }
 169
 170 static WCHAR *parse_name(WCHAR **str, ULONG *name_count)
 171 {
 172     WCHAR *name, *p = *str, *end;
 173     int count;
 174
 175     *name_count = 0;
 176
 177     while (is_space(*p)) p++;
 178
 179     if (*p == '(')
 180     {
 181         int total_count = 0;
 182
 183         p++;
 184         name = NULL;
 185
 186         while (*p)
 187         {
 188             WCHAR *tmp_name, *new_name;
 189             ULONG dummy;
 190
 191             while (is_space(*p)) p++;
 192             if (*p == ')')
 193             {
 194                 *str = p + 1;
 195                 return name;
 196             }
 197
 198             tmp_name = parse_name(&p, &dummy);
 199             if (!tmp_name) break;
 200
 201             TRACE("NAME[%u] %s\n", *name_count, debugstr_w(tmp_name));
 202
 203             count = wcslen(tmp_name);
 204
 205             if (!name)
 206                 new_name = heap_alloc((count + 1) * sizeof(WCHAR));
 207             else
 208                 new_name = heap_realloc(name, (total_count + count + 1) * sizeof(WCHAR));
 209
 210             if (!new_name) break;
 211
 212             memcpy(new_name + total_count, tmp_name, (count + 1) * sizeof(WCHAR));
 213
 214             name = new_name;
 215             heap_free(tmp_name);
 216             total_count += count + 1;
 217
 218             *name_count += 1;
 219             *str = p;
 220         }
 221
 222         *str = *p ? p + 1 : p;
 223
 224         heap_free(name);
 225         return NULL;
 226     }
 227
 228     if (*p != '\'')
 229     {
 230         FIXME("not supported NAME start at %s\n", debugstr_w(p));
 231         return NULL;
 232     }
 233
 234     p++;
 235     end = wcschr(p, '\'');
 236     if (!end) return NULL;
 237
 238     count = end - p;
 239     name = heap_alloc((count + 1) * sizeof(WCHAR));
 240     if (!name) return NULL;
 241
 242     memcpy(name, p, count * sizeof(WCHAR));
 243     name[count] = 0;
 244
 245     *name_count = 1;
 246
 247     *str = end + 1;
 248
 249     return name;
 250 }
 251
 252 static void skip_token(WCHAR **str)
 253 {
 254     WCHAR *p = *str;
 255
 256     while (is_space(*p)) p++;
 257
 258     if (*p == '\'')
 259     {
 260         p++;
 261         while (*p && *p != '\'') p++;
 262     }
 263     else
 264     {
 265         while (*p && !is_space(*p)) p++;
 266     }
 267
 268     *str = *p ? p + 1 : p;
 269 }
 270
 271 static BOOL parse_attribute_type(WCHAR *str, struct attribute_type *at)
 272 {
 273     static const WCHAR * const not_supported[] = { L"DESC", L"EQUALITY",
 274         L"ORDERING", L"SUBSTR", L"SUP", L"USAGE", L"X-ORDERED" };
 275     int i;
 276     WCHAR *p = str;
 277
 278     at->oid = NULL;
 279     at->name = NULL;
 280     at->name_count = 0;
 281     at->syntax = NULL;
 282     at->single_value = 0;
 283
 284     while (is_space(*p)) p++;
 285     if (*p++ != '(') return FALSE;
 286
 287     at->oid = parse_oid(&p);
 288     if (!at->oid) return FALSE;
 289
 290     while (*p)
 291     {
 292         while (is_space(*p)) p++;
 293         if (*p == ')') return TRUE;
 294
 295         if (!wcsnicmp(p, L"NAME", 4))
 296         {
 297             p += 4;
 298             at->name = parse_name(&p, &at->name_count);
 299         }
 300         else if (!wcsnicmp(p, L"SYNTAX", 6))
 301         {
 302             p += 6;
 303             at->syntax = parse_oid(&p);
 304         }
 305         else if (!wcsnicmp(p, L"SINGLE-VALUE", 12))
 306         {
 307             p += 12;
 308             at->single_value = 1;
 309         }
 310         else if (!wcsnicmp(p, L"NO-USER-MODIFICATION", 20))
 311         {
 312             p += 20;
 313         }
 314         else
 315         {
 316             BOOL recognized = FALSE;
 317
 318             for (i = 0; i < ARRAY_SIZE(not_supported); i++)
 319             {
 320                 if (!wcsnicmp(p, not_supported[i], wcslen(not_supported[i])))
 321                 {
 322                     p += wcslen(not_supported[i]);
 323                     skip_token(&p);
 324                     recognized = TRUE;
 325                     break;
 326                 }
 327             }
 328
 329             if (!recognized)
 330             {
 331                 FIXME("not supported token at %s\n", debugstr_w(p));
 332                 free_attribute_type(at);
 333                 return FALSE;
 334             }
 335         }
 336     }
 337
 338     WARN("attribute definition is not terminated\n");
 339
 340     free_attribute_type(at);
 341     return FALSE;
 342 }
 343
 344 static int __cdecl at_cmp(const void *a1, const void *a2)
 345 {
 346     const struct attribute_type *at1 = a1;
 347     const struct attribute_type *at2 = a2;
 348
 349     if (at1->name_count == 1 && at2->name_count == 1)
 350         return wcsicmp(at1->name, at2->name);
 351
 352     /* put definitions with multiple names at the end */
 353     return at1->name_count - at2->name_count;
 354 }
 355
 356 struct attribute_type *load_schema(LDAP *ld, ULONG *at_single_count, ULONG *at_multiple_count)
 357 {
 358     WCHAR *subschema[] = { (WCHAR *)L"subschemaSubentry", NULL };
 359     WCHAR *attribute_types[] = { (WCHAR *)L"attributeTypes", NULL };
 360     ULONG err, count, multiple_count;
 361     LDAPMessage *res, *entry;
 362     WCHAR **schema = NULL;
 363     struct attribute_type *at = NULL;
 364
 365     *at_single_count = 0;
 366     *at_multiple_count = 0;
 367
 368     err = ldap_search_sW(ld, NULL, LDAP_SCOPE_BASE, (WCHAR *)L"(objectClass=*)", subschema, FALSE, &res);
 369     if (err != LDAP_SUCCESS)
 370     {
 371         TRACE("ldap_search_sW error %#x\n", err);
 372         return NULL;
 373     }
 374
 375     entry = ldap_first_entry(ld, res);
 376     if (entry)
 377         schema = ldap_get_valuesW(ld, entry, subschema[0]);
 378
 379     ldap_msgfree(res);
 380     if (!schema) return NULL;
 381
 382     err = ldap_search_sW(ld, schema[0], LDAP_SCOPE_BASE, (WCHAR *)L"(objectClass=*)", attribute_types, FALSE, &res);
 383     if (err != LDAP_SUCCESS)
 384     {
 385         TRACE("ldap_search_sW error %#x\n", err);
 386         ldap_value_freeW(schema);
 387         return NULL;
 388     }
 389
 390     count = 0;
 391     multiple_count = 0;
 392
 393     entry = ldap_first_entry(ld, res);
 394     if (entry)
 395     {
 396         WCHAR **types;
 397
 398         types = ldap_get_valuesW(ld, entry, attribute_types[0]);
 399         if (types)
 400         {
 401             ULONG i, total = ldap_count_valuesW(types);
 402
 403             at = heap_alloc(total * sizeof(*at));
 404             if (!at) goto exit;
 405
 406             for (i = 0; i < total; i++)
 407             {
 408                 TRACE("%s\n", debugstr_w(types[i]));
 409
 410                 if (!parse_attribute_type(types[i], &at[count]))
 411                 {
 412                     WARN("parse_attribute_type failed\n");
 413                     continue;
 414                 }
 415
 416                 if (!at[count].name)
 417                 {
 418                     free_attribute_type(&at[count]);
 419                     continue;
 420                 }
 421
 422                 TRACE("oid %s, name %s, name_count %u, syntax %s, single-value %d\n", debugstr_w(at[count].oid),
 423                       debugstr_w(at[count].name), at[count].name_count, debugstr_w(at[count].syntax), at[count].single_value);
 424
 425                 if (at[count].name_count > 1)
 426                     multiple_count++;
 427
 428                 count++;
 429             }
 430
 431             ldap_value_freeW(types);
 432         }
 433     }
 434
 435 exit:
 436     ldap_value_freeW(schema);
 437     ldap_msgfree(res);
 438     if (at)
 439     {
 440         *at_single_count = count - multiple_count;
 441         *at_multiple_count = multiple_count;
 442
 443         qsort(at, count, sizeof(at[0]), at_cmp);
 444     }
 445
 446     return at;
 447 }