source4/lib/ldb-samba/ldif_handlers.c

   1 /*
   2    ldb database library - ldif handlers for Samba
   3
   4    Copyright (C) Andrew Tridgell 2005
   5    Copyright (C) Andrew Bartlett 2006-2007
   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 3 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, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "lib/ldb/include/ldb_includes.h"
  26 #include "dsdb/samdb/samdb.h"
  27 #include "librpc/gen_ndr/ndr_security.h"
  28 #include "librpc/gen_ndr/ndr_misc.h"
  29 #include "librpc/gen_ndr/ndr_drsblobs.h"
  30 #include "libcli/security/security.h"
  31 #include "param/param.h"
  32
  33 /*
  34   convert a ldif formatted objectSid to a NDR formatted blob
  35 */
  36 static int ldif_read_objectSid(struct ldb_context *ldb, void *mem_ctx,
  37                                const struct ldb_val *in, struct ldb_val *out)
  38 {
  39         enum ndr_err_code ndr_err;
  40         struct dom_sid *sid;
  41         sid = dom_sid_parse_length(mem_ctx, in);
  42         if (sid == NULL) {
  43                 return -1;
  44         }
  45         ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, sid,
  46                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
  47         talloc_free(sid);
  48         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  49                 return -1;
  50         }
  51         return 0;
  52 }
  53
  54 /*
  55   convert a NDR formatted blob to a ldif formatted objectSid
  56 */
  57 static int ldif_write_objectSid(struct ldb_context *ldb, void *mem_ctx,
  58                                 const struct ldb_val *in, struct ldb_val *out)
  59 {
  60         struct dom_sid *sid;
  61         enum ndr_err_code ndr_err;
  62
  63         sid = talloc(mem_ctx, struct dom_sid);
  64         if (sid == NULL) {
  65                 return -1;
  66         }
  67         ndr_err = ndr_pull_struct_blob(in, sid, NULL, sid,
  68                                        (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
  69         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  70                 talloc_free(sid);
  71                 return -1;
  72         }
  73         *out = data_blob_string_const(dom_sid_string(mem_ctx, sid));
  74         talloc_free(sid);
  75         if (out->data == NULL) {
  76                 return -1;
  77         }
  78         return 0;
  79 }
  80
  81 static bool ldb_comparision_objectSid_isString(const struct ldb_val *v)
  82 {
  83         if (v->length < 3) {
  84                 return false;
  85         }
  86
  87         if (strncmp("S-", (const char *)v->data, 2) != 0) return false;
  88
  89         return true;
  90 }
  91
  92 /*
  93   compare two objectSids
  94 */
  95 static int ldb_comparison_objectSid(struct ldb_context *ldb, void *mem_ctx,
  96                                     const struct ldb_val *v1, const struct ldb_val *v2)
  97 {
  98         if (ldb_comparision_objectSid_isString(v1) && ldb_comparision_objectSid_isString(v2)) {
  99                 return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 100         } else if (ldb_comparision_objectSid_isString(v1)
 101                    && !ldb_comparision_objectSid_isString(v2)) {
 102                 struct ldb_val v;
 103                 int ret;
 104                 if (ldif_read_objectSid(ldb, mem_ctx, v1, &v) != 0) {
 105                         /* Perhaps not a string after all */
 106                         return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 107                 }
 108                 ret = ldb_comparison_binary(ldb, mem_ctx, &v, v2);
 109                 talloc_free(v.data);
 110                 return ret;
 111         } else if (!ldb_comparision_objectSid_isString(v1)
 112                    && ldb_comparision_objectSid_isString(v2)) {
 113                 struct ldb_val v;
 114                 int ret;
 115                 if (ldif_read_objectSid(ldb, mem_ctx, v2, &v) != 0) {
 116                         /* Perhaps not a string after all */
 117                         return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 118                 }
 119                 ret = ldb_comparison_binary(ldb, mem_ctx, v1, &v);
 120                 talloc_free(v.data);
 121                 return ret;
 122         }
 123         return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 124 }
 125
 126 /*
 127   canonicalise a objectSid
 128 */
 129 static int ldb_canonicalise_objectSid(struct ldb_context *ldb, void *mem_ctx,
 130                                       const struct ldb_val *in, struct ldb_val *out)
 131 {
 132         if (ldb_comparision_objectSid_isString(in)) {
 133                 if (ldif_read_objectSid(ldb, mem_ctx, in, out) != 0) {
 134                         /* Perhaps not a string after all */
 135                         return ldb_handler_copy(ldb, mem_ctx, in, out);
 136                 }
 137                 return 0;
 138         }
 139         return ldb_handler_copy(ldb, mem_ctx, in, out);
 140 }
 141
 142 /*
 143   convert a ldif formatted objectGUID to a NDR formatted blob
 144 */
 145 static int ldif_read_objectGUID(struct ldb_context *ldb, void *mem_ctx,
 146                                 const struct ldb_val *in, struct ldb_val *out)
 147 {
 148         struct GUID guid;
 149         char *guid_string;
 150         NTSTATUS status;
 151         enum ndr_err_code ndr_err;
 152         guid_string = talloc_strndup(mem_ctx, (const char *)in->data, in->length);
 153         if (!guid_string) {
 154                 return -1;
 155         }
 156
 157         status = GUID_from_string(guid_string, &guid);
 158         talloc_free(guid_string);
 159         if (!NT_STATUS_IS_OK(status)) {
 160                 return -1;
 161         }
 162
 163         ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, &guid,
 164                                        (ndr_push_flags_fn_t)ndr_push_GUID);
 165         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 166                 return -1;
 167         }
 168         return 0;
 169 }
 170
 171 /*
 172   convert a NDR formatted blob to a ldif formatted objectGUID
 173 */
 174 static int ldif_write_objectGUID(struct ldb_context *ldb, void *mem_ctx,
 175                                  const struct ldb_val *in, struct ldb_val *out)
 176 {
 177         struct GUID guid;
 178         enum ndr_err_code ndr_err;
 179         ndr_err = ndr_pull_struct_blob(in, mem_ctx, NULL, &guid,
 180                                        (ndr_pull_flags_fn_t)ndr_pull_GUID);
 181         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 182                 return -1;
 183         }
 184         out->data = (uint8_t *)GUID_string(mem_ctx, &guid);
 185         if (out->data == NULL) {
 186                 return -1;
 187         }
 188         out->length = strlen((const char *)out->data);
 189         return 0;
 190 }
 191
 192 static bool ldb_comparision_objectGUID_isString(const struct ldb_val *v)
 193 {
 194         struct GUID guid;
 195         NTSTATUS status;
 196
 197         if (v->length < 33) return false;
 198
 199         /* see if the input if null-terninated (safety check for the below) */
 200         if (v->data[v->length] != '\0') return false;
 201
 202         status = GUID_from_string((const char *)v->data, &guid);
 203         if (!NT_STATUS_IS_OK(status)) {
 204                 return false;
 205         }
 206
 207         return true;
 208 }
 209
 210 /*
 211   compare two objectGUIDs
 212 */
 213 static int ldb_comparison_objectGUID(struct ldb_context *ldb, void *mem_ctx,
 214                                      const struct ldb_val *v1, const struct ldb_val *v2)
 215 {
 216         if (ldb_comparision_objectGUID_isString(v1) && ldb_comparision_objectGUID_isString(v2)) {
 217                 return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 218         } else if (ldb_comparision_objectGUID_isString(v1)
 219                    && !ldb_comparision_objectGUID_isString(v2)) {
 220                 struct ldb_val v;
 221                 int ret;
 222                 if (ldif_read_objectGUID(ldb, mem_ctx, v1, &v) != 0) {
 223                         /* Perhaps it wasn't a valid string after all */
 224                         return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 225                 }
 226                 ret = ldb_comparison_binary(ldb, mem_ctx, &v, v2);
 227                 talloc_free(v.data);
 228                 return ret;
 229         } else if (!ldb_comparision_objectGUID_isString(v1)
 230                    && ldb_comparision_objectGUID_isString(v2)) {
 231                 struct ldb_val v;
 232                 int ret;
 233                 if (ldif_read_objectGUID(ldb, mem_ctx, v2, &v) != 0) {
 234                         /* Perhaps it wasn't a valid string after all */
 235                         return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 236                 }
 237                 ret = ldb_comparison_binary(ldb, mem_ctx, v1, &v);
 238                 talloc_free(v.data);
 239                 return ret;
 240         }
 241         return ldb_comparison_binary(ldb, mem_ctx, v1, v2);
 242 }
 243
 244 /*
 245   canonicalise a objectGUID
 246 */
 247 static int ldb_canonicalise_objectGUID(struct ldb_context *ldb, void *mem_ctx,
 248                                        const struct ldb_val *in, struct ldb_val *out)
 249 {
 250         if (ldb_comparision_objectGUID_isString(in)) {
 251                 if (ldif_read_objectGUID(ldb, mem_ctx, in, out) != 0) {
 252                         /* Perhaps it wasn't a valid string after all */
 253                         return ldb_handler_copy(ldb, mem_ctx, in, out);
 254                 }
 255                 return 0;
 256         }
 257         return ldb_handler_copy(ldb, mem_ctx, in, out);
 258 }
 259
 260
 261 /*
 262   convert a ldif (SDDL) formatted ntSecurityDescriptor to a NDR formatted blob
 263 */
 264 static int ldif_read_ntSecurityDescriptor(struct ldb_context *ldb, void *mem_ctx,
 265                                           const struct ldb_val *in, struct ldb_val *out)
 266 {
 267         struct security_descriptor *sd;
 268         enum ndr_err_code ndr_err;
 269
 270         sd = sddl_decode(mem_ctx, (const char *)in->data, NULL);
 271         if (sd == NULL) {
 272                 return -1;
 273         }
 274         ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, sd,
 275                                        (ndr_push_flags_fn_t)ndr_push_security_descriptor);
 276         talloc_free(sd);
 277         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 278                 return -1;
 279         }
 280         return 0;
 281 }
 282
 283 /*
 284   convert a NDR formatted blob to a ldif formatted ntSecurityDescriptor (SDDL format)
 285 */
 286 static int ldif_write_ntSecurityDescriptor(struct ldb_context *ldb, void *mem_ctx,
 287                                            const struct ldb_val *in, struct ldb_val *out)
 288 {
 289         struct security_descriptor *sd;
 290         enum ndr_err_code ndr_err;
 291
 292         sd = talloc(mem_ctx, struct security_descriptor);
 293         if (sd == NULL) {
 294                 return -1;
 295         }
 296         ndr_err = ndr_pull_struct_blob(in, sd, NULL, sd,
 297                                        (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
 298         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 299                 talloc_free(sd);
 300                 return -1;
 301         }
 302         out->data = (uint8_t *)sddl_encode(mem_ctx, sd, NULL);
 303         talloc_free(sd);
 304         if (out->data == NULL) {
 305                 return -1;
 306         }
 307         out->length = strlen((const char *)out->data);
 308         return 0;
 309 }
 310
 311 /*
 312    canonicalise an objectCategory.  We use the short form as the cannoical form:
 313    cn=Person,cn=Schema,cn=Configuration,<basedn> becomes 'person'
 314 */
 315
 316 static int ldif_canonicalise_objectCategory(struct ldb_context *ldb, void *mem_ctx,
 317                                             const struct ldb_val *in, struct ldb_val *out)
 318 {
 319         struct ldb_dn *dn1 = NULL;
 320         const struct dsdb_schema *schema = dsdb_get_schema(ldb);
 321         const struct dsdb_class *class;
 322         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 323         if (!tmp_ctx) {
 324                 return LDB_ERR_OPERATIONS_ERROR;
 325         }
 326
 327         if (!schema) {
 328                 *out = data_blob_talloc(mem_ctx, in->data, in->length);
 329                 if (in->data && !out->data) {
 330                         return LDB_ERR_OPERATIONS_ERROR;
 331                 }
 332                 return LDB_SUCCESS;
 333         }
 334         dn1 = ldb_dn_from_ldb_val(tmp_ctx, ldb, in);
 335         if ( ! ldb_dn_validate(dn1)) {
 336                 const char *lDAPDisplayName = talloc_strndup(tmp_ctx, (char *)in->data, in->length);
 337                 class = dsdb_class_by_lDAPDisplayName(schema, lDAPDisplayName);
 338                 if (class) {
 339                         struct ldb_dn *dn = ldb_dn_new(mem_ctx, ldb,
 340                                                        class->defaultObjectCategory);
 341                         *out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn));
 342                         talloc_free(tmp_ctx);
 343
 344                         if (!out->data) {
 345                                 return LDB_ERR_OPERATIONS_ERROR;
 346                         }
 347                         return LDB_SUCCESS;
 348                 } else {
 349                         *out = data_blob_talloc(mem_ctx, in->data, in->length);
 350                         talloc_free(tmp_ctx);
 351
 352                         if (in->data && !out->data) {
 353                                 return LDB_ERR_OPERATIONS_ERROR;
 354                         }
 355                         return LDB_SUCCESS;
 356                 }
 357         }
 358         *out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn1));
 359         talloc_free(tmp_ctx);
 360
 361         if (!out->data) {
 362                 return LDB_ERR_OPERATIONS_ERROR;
 363         }
 364         return LDB_SUCCESS;
 365 }
 366
 367 static int ldif_comparison_objectCategory(struct ldb_context *ldb, void *mem_ctx,
 368                                           const struct ldb_val *v1,
 369                                           const struct ldb_val *v2)
 370 {
 371
 372         int ret, ret1, ret2;
 373         struct ldb_val v1_canon, v2_canon;
 374         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 375
 376         /* I could try and bail if tmp_ctx was NULL, but what return
 377          * value would I use?
 378          *
 379          * It seems easier to continue on the NULL context
 380          */
 381         ret1 = ldif_canonicalise_objectCategory(ldb, tmp_ctx, v1, &v1_canon);
 382         ret2 = ldif_canonicalise_objectCategory(ldb, tmp_ctx, v2, &v2_canon);
 383
 384         if (ret1 == LDB_SUCCESS && ret2 == LDB_SUCCESS) {
 385                 ret = data_blob_cmp(&v1_canon, &v2_canon);
 386         } else {
 387                 ret = data_blob_cmp(v1, v2);
 388         }
 389         talloc_free(tmp_ctx);
 390         return ret;
 391 }
 392
 393 /*
 394   convert a ldif formatted prefixMap to a NDR formatted blob
 395 */
 396 static int ldif_read_prefixMap(struct ldb_context *ldb, void *mem_ctx,
 397                                const struct ldb_val *in, struct ldb_val *out)
 398 {
 399         struct prefixMapBlob *blob;
 400         enum ndr_err_code ndr_err;
 401         char *string, *line, *p, *oid;
 402
 403         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 404
 405         if (tmp_ctx == NULL) {
 406                 return -1;
 407         }
 408
 409         blob = talloc_zero(tmp_ctx, struct prefixMapBlob);
 410         if (blob == NULL) {
 411                 talloc_free(blob);
 412                 return -1;
 413         }
 414
 415         blob->version = PREFIX_MAP_VERSION_DSDB;
 416
 417         string = talloc_strndup(mem_ctx, (const char *)in->data, in->length);
 418         if (string == NULL) {
 419                 talloc_free(blob);
 420                 return -1;
 421         }
 422
 423         line = string;
 424         while (line && line[0]) {
 425                 p=strchr(line, ';');
 426                 if (p) {
 427                         p[0] = '\0';
 428                 } else {
 429                         p=strchr(line, '\n');
 430                         if (p) {
 431                                 p[0] = '\0';
 432                         }
 433                 }
 434                 /* allow a traling seperator */
 435                 if (line == p) {
 436                         break;
 437                 }
 438
 439                 blob->ctr.dsdb.mappings = talloc_realloc(blob,
 440                                                          blob->ctr.dsdb.mappings,
 441                                                          struct drsuapi_DsReplicaOIDMapping,
 442                                                          blob->ctr.dsdb.num_mappings+1);
 443                 if (!blob->ctr.dsdb.mappings) {
 444                         talloc_free(tmp_ctx);
 445                         return -1;
 446                 }
 447
 448                 blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].id_prefix = strtoul(line, &oid, 10);
 449
 450                 if (oid[0] != ':') {
 451                         talloc_free(tmp_ctx);
 452                         return -1;
 453                 }
 454
 455                 /* we know there must be at least ":" */
 456                 oid++;
 457
 458                 blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].oid.oid
 459                         = talloc_strdup(blob->ctr.dsdb.mappings, oid);
 460
 461                 blob->ctr.dsdb.num_mappings++;
 462
 463                 /* Now look past the terminator we added above */
 464                 if (p) {
 465                         line = p + 1;
 466                 } else {
 467                         line = NULL;
 468                 }
 469         }
 470
 471         ndr_err = ndr_push_struct_blob(out, mem_ctx,
 472                                        lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
 473                                        blob,
 474                                        (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
 475         talloc_free(tmp_ctx);
 476         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 477                 return -1;
 478         }
 479         return 0;
 480 }
 481
 482 /*
 483   convert a NDR formatted blob to a ldif formatted prefixMap
 484 */
 485 static int ldif_write_prefixMap(struct ldb_context *ldb, void *mem_ctx,
 486                                 const struct ldb_val *in, struct ldb_val *out)
 487 {
 488         struct prefixMapBlob *blob;
 489         enum ndr_err_code ndr_err;
 490         char *string;
 491         uint32_t i;
 492
 493         blob = talloc(mem_ctx, struct prefixMapBlob);
 494         if (blob == NULL) {
 495                 return -1;
 496         }
 497         ndr_err = ndr_pull_struct_blob(in, blob,
 498                                        lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
 499                                        blob,
 500                                        (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
 501         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 502                 talloc_free(blob);
 503                 return -1;
 504         }
 505         if (blob->version != PREFIX_MAP_VERSION_DSDB) {
 506                 return -1;
 507         }
 508         string = talloc_strdup(mem_ctx, "");
 509         if (string == NULL) {
 510                 return -1;
 511         }
 512
 513         for (i=0; i < blob->ctr.dsdb.num_mappings; i++) {
 514                 if (i > 0) {
 515                         string = talloc_asprintf_append(string, ";");
 516                 }
 517                 string = talloc_asprintf_append(string, "%u:%s",
 518                                                    blob->ctr.dsdb.mappings[i].id_prefix,
 519                                                    blob->ctr.dsdb.mappings[i].oid.oid);
 520                 if (string == NULL) {
 521                         return -1;
 522                 }
 523         }
 524
 525         talloc_free(blob);
 526         *out = data_blob_string_const(string);
 527         return 0;
 528 }
 529
 530 static bool ldif_comparision_prefixMap_isString(const struct ldb_val *v)
 531 {
 532         if (v->length < 4) {
 533                 return true;
 534         }
 535
 536         if (IVAL(v->data, 0) == PREFIX_MAP_VERSION_DSDB) {
 537                 return false;
 538         }
 539
 540         return true;
 541 }
 542
 543 /*
 544   canonicalise a prefixMap
 545 */
 546 static int ldif_canonicalise_prefixMap(struct ldb_context *ldb, void *mem_ctx,
 547                                        const struct ldb_val *in, struct ldb_val *out)
 548 {
 549         if (ldif_comparision_prefixMap_isString(in)) {
 550                 return ldif_read_prefixMap(ldb, mem_ctx, in, out);
 551         }
 552         return ldb_handler_copy(ldb, mem_ctx, in, out);
 553 }
 554
 555 static int ldif_comparison_prefixMap(struct ldb_context *ldb, void *mem_ctx,
 556                                      const struct ldb_val *v1,
 557                                      const struct ldb_val *v2)
 558 {
 559
 560         int ret, ret1, ret2;
 561         struct ldb_val v1_canon, v2_canon;
 562         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 563
 564         /* I could try and bail if tmp_ctx was NULL, but what return
 565          * value would I use?
 566          *
 567          * It seems easier to continue on the NULL context
 568          */
 569         ret1 = ldif_canonicalise_prefixMap(ldb, tmp_ctx, v1, &v1_canon);
 570         ret2 = ldif_canonicalise_prefixMap(ldb, tmp_ctx, v2, &v2_canon);
 571
 572         if (ret1 == LDB_SUCCESS && ret2 == LDB_SUCCESS) {
 573                 ret = data_blob_cmp(&v1_canon, &v2_canon);
 574         } else {
 575                 ret = data_blob_cmp(v1, v2);
 576         }
 577         talloc_free(tmp_ctx);
 578         return ret;
 579 }
 580
 581 #define LDB_SYNTAX_SAMBA_GUID                   "LDB_SYNTAX_SAMBA_GUID"
 582 #define LDB_SYNTAX_SAMBA_OBJECT_CATEGORY        "LDB_SYNTAX_SAMBA_OBJECT_CATEGORY"
 583 #define LDB_SYNTAX_SAMBA_PREFIX_MAP     "LDB_SYNTAX_SAMBA_PREFIX_MAP"
 584
 585 static const struct ldb_schema_syntax samba_syntaxes[] = {
 586         {
 587                 .name           = LDB_SYNTAX_SAMBA_SID,
 588                 .ldif_read_fn   = ldif_read_objectSid,
 589                 .ldif_write_fn  = ldif_write_objectSid,
 590                 .canonicalise_fn= ldb_canonicalise_objectSid,
 591                 .comparison_fn  = ldb_comparison_objectSid
 592         },{
 593                 .name           = LDB_SYNTAX_SAMBA_SECURITY_DESCRIPTOR,
 594                 .ldif_read_fn   = ldif_read_ntSecurityDescriptor,
 595                 .ldif_write_fn  = ldif_write_ntSecurityDescriptor,
 596                 .canonicalise_fn= ldb_handler_copy,
 597                 .comparison_fn  = ldb_comparison_binary
 598         },{
 599                 .name           = LDB_SYNTAX_SAMBA_GUID,
 600                 .ldif_read_fn   = ldif_read_objectGUID,
 601                 .ldif_write_fn  = ldif_write_objectGUID,
 602                 .canonicalise_fn= ldb_canonicalise_objectGUID,
 603                 .comparison_fn  = ldb_comparison_objectGUID
 604         },{
 605                 .name           = LDB_SYNTAX_SAMBA_OBJECT_CATEGORY,
 606                 .ldif_read_fn   = ldb_handler_copy,
 607                 .ldif_write_fn  = ldb_handler_copy,
 608                 .canonicalise_fn= ldif_canonicalise_objectCategory,
 609                 .comparison_fn  = ldif_comparison_objectCategory
 610         },{
 611                 .name           = LDB_SYNTAX_SAMBA_PREFIX_MAP,
 612                 .ldif_read_fn   = ldif_read_prefixMap,
 613                 .ldif_write_fn  = ldif_write_prefixMap,
 614                 .canonicalise_fn= ldif_canonicalise_prefixMap,
 615                 .comparison_fn  = ldif_comparison_prefixMap
 616         }
 617 };
 618
 619 static const struct {
 620         const char *name;
 621         const char *syntax;
 622 } samba_attributes[] = {
 623         { "objectSid",                  LDB_SYNTAX_SAMBA_SID },
 624         { "securityIdentifier",         LDB_SYNTAX_SAMBA_SID },
 625         { "ntSecurityDescriptor",       LDB_SYNTAX_SAMBA_SECURITY_DESCRIPTOR },
 626         { "objectGUID",                 LDB_SYNTAX_SAMBA_GUID },
 627         { "invocationId",               LDB_SYNTAX_SAMBA_GUID },
 628         { "schemaIDGUID",               LDB_SYNTAX_SAMBA_GUID },
 629         { "attributeSecurityGUID",      LDB_SYNTAX_SAMBA_GUID },
 630         { "parentGUID",                 LDB_SYNTAX_SAMBA_GUID },
 631         { "siteGUID",                   LDB_SYNTAX_SAMBA_GUID },
 632         { "pKTGUID",                    LDB_SYNTAX_SAMBA_GUID },
 633         { "fRSVersionGUID",             LDB_SYNTAX_SAMBA_GUID },
 634         { "fRSReplicaSetGUID",          LDB_SYNTAX_SAMBA_GUID },
 635         { "netbootGUID",                LDB_SYNTAX_SAMBA_GUID },
 636         { "objectCategory",             LDB_SYNTAX_SAMBA_OBJECT_CATEGORY },
 637         { "prefixMap",                  LDB_SYNTAX_SAMBA_PREFIX_MAP }
 638 };
 639
 640 const struct ldb_schema_syntax *ldb_samba_syntax_by_name(struct ldb_context *ldb, const char *name)
 641 {
 642         uint32_t j;
 643         const struct ldb_schema_syntax *s = NULL;
 644
 645         for (j=0; j < ARRAY_SIZE(samba_syntaxes); j++) {
 646                 if (strcmp(name, samba_syntaxes[j].name) == 0) {
 647                         s = &samba_syntaxes[j];
 648                         break;
 649                 }
 650         }
 651         return s;
 652 }
 653
 654
 655 /*
 656   register the samba ldif handlers
 657 */
 658 int ldb_register_samba_handlers(struct ldb_context *ldb)
 659 {
 660         uint32_t i;
 661
 662         for (i=0; i < ARRAY_SIZE(samba_attributes); i++) {
 663                 int ret;
 664                 const struct ldb_schema_syntax *s = NULL;
 665
 666                 s = ldb_samba_syntax_by_name(ldb, samba_attributes[i].syntax);
 667
 668                 if (!s) {
 669                         s = ldb_standard_syntax_by_name(ldb, samba_attributes[i].syntax);
 670                 }
 671
 672                 if (!s) {
 673                         return -1;
 674                 }
 675
 676                 ret = ldb_schema_attribute_add_with_syntax(ldb, samba_attributes[i].name, LDB_ATTR_FLAG_FIXED, s);
 677                 if (ret != LDB_SUCCESS) {
 678                         return ret;
 679                 }
 680         }
 681
 682         return LDB_SUCCESS;
 683 }