source4/dsdb/samdb/ldb_modules/simple_ldap_map.c

   1 /*
   2    ldb database module
   3
   4    LDAP semantics mapping module
   5
   6    Copyright (C) Jelmer Vernooij 2005
   7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 /*
  24    This module relies on ldb_map to do all the real work, but performs
  25    some of the trivial mappings between AD semantics and that provided
  26    by OpenLDAP and similar servers.
  27 */
  28
  29 #include "includes.h"
  30 #include "ldb/include/ldb.h"
  31 #include "ldb/include/ldb_private.h"
  32 #include "ldb/include/ldb_errors.h"
  33 #include "ldb/ldb_map/ldb_map.h"
  34
  35 #include "librpc/gen_ndr/ndr_misc.h"
  36 #include "librpc/ndr/libndr.h"
  37
  38 struct entryuuid_private {
  39         struct ldb_dn **base_dns;
  40 };
  41
  42 static struct ldb_val encode_guid(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
  43 {
  44         struct GUID guid;
  45         NTSTATUS status = GUID_from_string((char *)val->data, &guid);
  46         enum ndr_err_code ndr_err;
  47         struct ldb_val out = data_blob(NULL, 0);
  48
  49         if (!NT_STATUS_IS_OK(status)) {
  50                 return out;
  51         }
  52         ndr_err = ndr_push_struct_blob(&out, ctx, NULL, &guid,
  53                                        (ndr_push_flags_fn_t)ndr_push_GUID);
  54         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  55                 return out;
  56         }
  57
  58         return out;
  59 }
  60
  61 static struct ldb_val guid_always_string(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
  62 {
  63         struct GUID *guid;
  64         struct ldb_val out = data_blob(NULL, 0);
  65         if (val->length >= 32 && val->data[val->length] == '\0') {
  66                 ldb_handler_copy(module->ldb, ctx, val, &out);
  67         } else {
  68                 enum ndr_err_code ndr_err;
  69
  70                 guid = talloc(ctx, struct GUID);
  71                 if (guid == NULL) {
  72                         return out;
  73                 }
  74                 ndr_err = ndr_pull_struct_blob(val, guid, NULL, guid,
  75                                                (ndr_pull_flags_fn_t)ndr_pull_GUID);
  76                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  77                         talloc_free(guid);
  78                         return out;
  79                 }
  80                 out = data_blob_string_const(GUID_string(ctx, guid));
  81                 talloc_free(guid);
  82         }
  83         return out;
  84 }
  85
  86 static struct ldb_val encode_ns_guid(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
  87 {
  88         struct GUID guid;
  89         NTSTATUS status = NS_GUID_from_string((char *)val->data, &guid);
  90         enum ndr_err_code ndr_err;
  91         struct ldb_val out = data_blob(NULL, 0);
  92
  93         if (!NT_STATUS_IS_OK(status)) {
  94                 return out;
  95         }
  96         ndr_err = ndr_push_struct_blob(&out, ctx, NULL, &guid,
  97                                        (ndr_push_flags_fn_t)ndr_push_GUID);
  98         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  99                 return out;
 100         }
 101
 102         return out;
 103 }
 104
 105 static struct ldb_val guid_ns_string(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 106 {
 107         struct ldb_val out = data_blob(NULL, 0);
 108         if (val->length >= 32 && val->data[val->length] == '\0') {
 109                 struct GUID guid;
 110                 GUID_from_string((char *)val->data, &guid);
 111                 out = data_blob_string_const(NS_GUID_string(ctx, &guid));
 112         } else {
 113                 enum ndr_err_code ndr_err;
 114                 struct GUID *guid_p;
 115                 guid_p = talloc(ctx, struct GUID);
 116                 if (guid_p == NULL) {
 117                         return out;
 118                 }
 119                 ndr_err = ndr_pull_struct_blob(val, guid_p, NULL, guid_p,
 120                                                (ndr_pull_flags_fn_t)ndr_pull_GUID);
 121                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 122                         talloc_free(guid_p);
 123                         return out;
 124                 }
 125                 out = data_blob_string_const(NS_GUID_string(ctx, guid_p));
 126                 talloc_free(guid_p);
 127         }
 128         return out;
 129 }
 130
 131 /* The backend holds binary sids, so just copy them back */
 132 static struct ldb_val val_copy(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 133 {
 134         struct ldb_val out = data_blob(NULL, 0);
 135         ldb_handler_copy(module->ldb, ctx, val, &out);
 136
 137         return out;
 138 }
 139
 140 /* Ensure we always convert sids into binary, so the backend doesn't have to know about both forms */
 141 static struct ldb_val sid_always_binary(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 142 {
 143         struct ldb_val out = data_blob(NULL, 0);
 144         const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(module->ldb, "objectSid");
 145
 146         if (a->syntax->canonicalise_fn(module->ldb, ctx, val, &out) != LDB_SUCCESS) {
 147                 return data_blob(NULL, 0);
 148         }
 149
 150         return out;
 151 }
 152
 153 /* Ensure we always convert objectCategory into a DN */
 154 static struct ldb_val objectCategory_always_dn(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 155 {
 156         struct ldb_val out = data_blob(NULL, 0);
 157         const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(module->ldb, "objectCategory");
 158
 159         if (a->syntax->canonicalise_fn(module->ldb, ctx, val, &out) != LDB_SUCCESS) {
 160                 return data_blob(NULL, 0);
 161         }
 162
 163         return out;
 164 }
 165
 166 static struct ldb_val normalise_to_signed32(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 167 {
 168         long long int signed_ll = strtoll((const char *)val->data, NULL, 10);
 169         if (signed_ll >= 0x80000000LL) {
 170                 union {
 171                         int32_t signed_int;
 172                         uint32_t unsigned_int;
 173                 } u = {
 174                         .unsigned_int = strtoul((const char *)val->data, NULL, 10)
 175                 };
 176
 177                 struct ldb_val out = data_blob_string_const(talloc_asprintf(ctx, "%d", u.signed_int));
 178                 return out;
 179         }
 180         return val_copy(module, ctx, val);
 181 }
 182
 183 static struct ldb_val usn_to_entryCSN(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 184 {
 185         struct ldb_val out;
 186         unsigned long long usn = strtoull((const char *)val->data, NULL, 10);
 187         time_t t = (usn >> 24);
 188         out = data_blob_string_const(talloc_asprintf(ctx, "%s#%06x#00#000000", ldb_timestring(ctx, t), (unsigned int)(usn & 0xFFFFFF)));
 189         return out;
 190 }
 191
 192 static unsigned long long entryCSN_to_usn_int(TALLOC_CTX *ctx, const struct ldb_val *val)
 193 {
 194         char *entryCSN = talloc_strdup(ctx, (const char *)val->data);
 195         char *mod_per_sec;
 196         time_t t;
 197         unsigned long long usn;
 198         char *p;
 199         if (!entryCSN) {
 200                 return 0;
 201         }
 202         p = strchr(entryCSN, '#');
 203         if (!p) {
 204                 return 0;
 205         }
 206         p[0] = '\0';
 207         p++;
 208         mod_per_sec = p;
 209
 210         p = strchr(p, '#');
 211         if (!p) {
 212                 return 0;
 213         }
 214         p[0] = '\0';
 215         p++;
 216
 217         usn = strtol(mod_per_sec, NULL, 16);
 218
 219         t = ldb_string_to_time(entryCSN);
 220
 221         usn = usn | ((unsigned long long)t <<24);
 222         return usn;
 223 }
 224
 225 static struct ldb_val entryCSN_to_usn(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 226 {
 227         struct ldb_val out;
 228         unsigned long long usn = entryCSN_to_usn_int(ctx, val);
 229         out = data_blob_string_const(talloc_asprintf(ctx, "%lld", usn));
 230         return out;
 231 }
 232
 233 static struct ldb_val usn_to_timestamp(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 234 {
 235         struct ldb_val out;
 236         unsigned long long usn = strtoull((const char *)val->data, NULL, 10);
 237         time_t t = (usn >> 24);
 238         out = data_blob_string_const(ldb_timestring(ctx, t));
 239         return out;
 240 }
 241
 242 static struct ldb_val timestamp_to_usn(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
 243 {
 244         struct ldb_val out;
 245         time_t t;
 246         unsigned long long usn;
 247
 248         t = ldb_string_to_time((const char *)val->data);
 249
 250         usn = ((unsigned long long)t <<24);
 251
 252         out = data_blob_string_const(talloc_asprintf(ctx, "%lld", usn));
 253         return out;
 254 }
 255
 256
 257 static const struct ldb_map_attribute entryuuid_attributes[] =
 258 {
 259         /* objectGUID */
 260         {
 261                 .local_name = "objectGUID",
 262                 .type = MAP_CONVERT,
 263                 .u = {
 264                         .convert = {
 265                                 .remote_name = "entryUUID",
 266                                 .convert_local = guid_always_string,
 267                                 .convert_remote = encode_guid,
 268                         },
 269                 },
 270         },
 271         /* invocationId */
 272         {
 273                 .local_name = "invocationId",
 274                 .type = MAP_CONVERT,
 275                 .u = {
 276                         .convert = {
 277                                 .remote_name = "invocationId",
 278                                 .convert_local = guid_always_string,
 279                                 .convert_remote = encode_guid,
 280                         },
 281                 },
 282         },
 283         /* objectSid */
 284         {
 285                 .local_name = "objectSid",
 286                 .type = MAP_CONVERT,
 287                 .u = {
 288                         .convert = {
 289                                 .remote_name = "objectSid",
 290                                 .convert_local = sid_always_binary,
 291                                 .convert_remote = val_copy,
 292                         },
 293                 },
 294         },
 295         {
 296                 .local_name = "name",
 297                 .type = MAP_RENAME,
 298                 .u = {
 299                         .rename = {
 300                                  .remote_name = "samba4RDN"
 301                          }
 302                 }
 303         },
 304         {
 305                 .local_name = "whenCreated",
 306                 .type = MAP_RENAME,
 307                 .u = {
 308                         .rename = {
 309                                  .remote_name = "createTimestamp"
 310                          }
 311                 }
 312         },
 313         {
 314                 .local_name = "whenChanged",
 315                 .type = MAP_RENAME,
 316                 .u = {
 317                         .rename = {
 318                                  .remote_name = "modifyTimestamp"
 319                          }
 320                 }
 321         },
 322         {
 323                 .local_name = "objectClasses",
 324                 .type = MAP_RENAME,
 325                 .u = {
 326                         .rename = {
 327                                  .remote_name = "samba4ObjectClasses"
 328                          }
 329                 }
 330         },
 331         {
 332                 .local_name = "dITContentRules",
 333                 .type = MAP_RENAME,
 334                 .u = {
 335                         .rename = {
 336                                  .remote_name = "samba4DITContentRules"
 337                          }
 338                 }
 339         },
 340         {
 341                 .local_name = "attributeTypes",
 342                 .type = MAP_RENAME,
 343                 .u = {
 344                         .rename = {
 345                                  .remote_name = "samba4AttributeTypes"
 346                          }
 347                 }
 348         },
 349         {
 350                 .local_name = "sambaPassword",
 351                 .type = MAP_RENAME,
 352                 .u = {
 353                         .rename = {
 354                                  .remote_name = "userPassword"
 355                          }
 356                 }
 357         },
 358         {
 359                 .local_name = "objectCategory",
 360                 .type = MAP_CONVERT,
 361                 .u = {
 362                         .convert = {
 363                                 .remote_name = "objectCategory",
 364                                 .convert_local = objectCategory_always_dn,
 365                                 .convert_remote = val_copy,
 366                         },
 367                 },
 368         },
 369         {
 370                 .local_name = "distinguishedName",
 371                 .type = MAP_RENAME,
 372                 .u = {
 373                         .rename = {
 374                                  .remote_name = "entryDN"
 375                          }
 376                 }
 377         },
 378         {
 379                 .local_name = "groupType",
 380                 .type = MAP_CONVERT,
 381                 .u = {
 382                         .convert = {
 383                                  .remote_name = "groupType",
 384                                  .convert_local = normalise_to_signed32,
 385                                  .convert_remote = val_copy,
 386                          },
 387                 }
 388         },
 389         {
 390                 .local_name = "sAMAccountType",
 391                 .type = MAP_CONVERT,
 392                 .u = {
 393                         .convert = {
 394                                  .remote_name = "sAMAccountType",
 395                                  .convert_local = normalise_to_signed32,
 396                                  .convert_remote = val_copy,
 397                          },
 398                 }
 399         },
 400         {
 401                 .local_name = "usnChanged",
 402                 .type = MAP_CONVERT,
 403                 .u = {
 404                         .convert = {
 405                                  .remote_name = "entryCSN",
 406                                  .convert_local = usn_to_entryCSN,
 407                                  .convert_remote = entryCSN_to_usn
 408                          },
 409                 },
 410         },
 411         {
 412                 .local_name = "usnCreated",
 413                 .type = MAP_CONVERT,
 414                 .u = {
 415                         .convert = {
 416                                  .remote_name = "createTimestamp",
 417                                  .convert_local = usn_to_timestamp,
 418                                  .convert_remote = timestamp_to_usn,
 419                          },
 420                 },
 421         },
 422         {
 423                 .local_name = "*",
 424                 .type = MAP_KEEP,
 425         },
 426         {
 427                 .local_name = NULL,
 428         }
 429 };
 430
 431 /* This objectClass conflicts with builtin classes on OpenLDAP */
 432 const struct ldb_map_objectclass entryuuid_objectclasses[] =
 433 {
 434         {
 435                 .local_name = "subSchema",
 436                 .remote_name = "samba4SubSchema"
 437         },
 438         {
 439                 .local_name = NULL
 440         }
 441 };
 442
 443 /* These things do not show up in wildcard searches in OpenLDAP, but
 444  * we need them to show up in the AD-like view */
 445 static const char * const entryuuid_wildcard_attributes[] = {
 446         "objectGUID",
 447         "whenCreated",
 448         "whenChanged",
 449         "usnCreated",
 450         "usnChanged",
 451         NULL
 452 };
 453
 454 static const struct ldb_map_attribute nsuniqueid_attributes[] =
 455 {
 456         /* objectGUID */
 457         {
 458                 .local_name = "objectGUID",
 459                 .type = MAP_CONVERT,
 460                 .u = {
 461                         .convert = {
 462                                 .remote_name = "nsuniqueid",
 463                                 .convert_local = guid_ns_string,
 464                                 .convert_remote = encode_ns_guid,
 465                         },
 466                 },
 467         },
 468         /* objectSid */
 469         {
 470                 .local_name = "objectSid",
 471                 .type = MAP_CONVERT,
 472                 .u = {
 473                         .convert = {
 474                                 .remote_name = "objectSid",
 475                                 .convert_local = sid_always_binary,
 476                                 .convert_remote = val_copy,
 477                         },
 478                 },
 479         },
 480         {
 481                 .local_name = "whenCreated",
 482                 .type = MAP_RENAME,
 483                 .u = {
 484                         .rename = {
 485                                  .remote_name = "createTimestamp"
 486                          }
 487                 }
 488         },
 489         {
 490                 .local_name = "whenChanged",
 491                 .type = MAP_RENAME,
 492                 .u = {
 493                         .rename = {
 494                                  .remote_name = "modifyTimestamp"
 495                          }
 496                 }
 497         },
 498         {
 499                 .local_name = "sambaPassword",
 500                 .type = MAP_RENAME,
 501                 .u = {
 502                         .rename = {
 503                                  .remote_name = "userPassword"
 504                          }
 505                 }
 506         },
 507         {
 508                 .local_name = "objectCategory",
 509                 .type = MAP_CONVERT,
 510                 .u = {
 511                         .convert = {
 512                                 .remote_name = "objectCategory",
 513                                 .convert_local = objectCategory_always_dn,
 514                                 .convert_remote = val_copy,
 515                         },
 516                 },
 517         },
 518         {
 519                 .local_name = "distinguishedName",
 520                 .type = MAP_RENAME,
 521                 .u = {
 522                         .rename = {
 523                                  .remote_name = "entryDN"
 524                          }
 525                 }
 526         },
 527         {
 528                 .local_name = "groupType",
 529                 .type = MAP_CONVERT,
 530                 .u = {
 531                         .convert = {
 532                                  .remote_name = "groupType",
 533                                  .convert_local = normalise_to_signed32,
 534                                  .convert_remote = val_copy,
 535                          },
 536                 }
 537         },
 538         {
 539                 .local_name = "sAMAccountType",
 540                 .type = MAP_CONVERT,
 541                 .u = {
 542                         .convert = {
 543                                  .remote_name = "sAMAccountType",
 544                                  .convert_local = normalise_to_signed32,
 545                                  .convert_remote = val_copy,
 546                          },
 547                 }
 548         },
 549         {
 550                 .local_name = "usnChanged",
 551                 .type = MAP_CONVERT,
 552                 .u = {
 553                         .convert = {
 554                                  .remote_name = "modifyTimestamp",
 555                                  .convert_local = usn_to_timestamp,
 556                                  .convert_remote = timestamp_to_usn,
 557                          },
 558                 },
 559         },
 560         {
 561                 .local_name = "usnCreated",
 562                 .type = MAP_CONVERT,
 563                 .u = {
 564                         .convert = {
 565                                  .remote_name = "createTimestamp",
 566                                  .convert_local = usn_to_timestamp,
 567                                  .convert_remote = timestamp_to_usn,
 568                          },
 569                 },
 570         },
 571         {
 572                 .local_name = "*",
 573                 .type = MAP_KEEP,
 574         },
 575         {
 576                 .local_name = NULL,
 577         }
 578 };
 579
 580 /* These things do not show up in wildcard searches in OpenLDAP, but
 581  * we need them to show up in the AD-like view */
 582 static const char * const nsuniqueid_wildcard_attributes[] = {
 583         "objectGUID",
 584         "whenCreated",
 585         "whenChanged",
 586         "usnCreated",
 587         "usnChanged",
 588         NULL
 589 };
 590
 591 static int get_remote_rootdse(struct ldb_context *ldb, void *context,
 592                        struct ldb_reply *ares)
 593 {
 594         struct entryuuid_private *entryuuid_private;
 595         entryuuid_private = talloc_get_type(context,
 596                                             struct entryuuid_private);
 597         if (ares->type == LDB_REPLY_ENTRY) {
 598                 int i;
 599                 struct ldb_message_element *el = ldb_msg_find_element(ares->message, "namingContexts");
 600                 entryuuid_private->base_dns = talloc_realloc(entryuuid_private, entryuuid_private->base_dns, struct ldb_dn *,
 601                                                              el->num_values + 1);
 602                 for (i=0; i < el->num_values; i++) {
 603                         if (!entryuuid_private->base_dns) {
 604                                 return LDB_ERR_OPERATIONS_ERROR;
 605                         }
 606                         entryuuid_private->base_dns[i] = ldb_dn_new(entryuuid_private->base_dns, ldb, (const char *)el->values[i].data);
 607                         if ( ! ldb_dn_validate(entryuuid_private->base_dns[i])) {
 608                                 return LDB_ERR_OPERATIONS_ERROR;
 609                         }
 610                 }
 611                 entryuuid_private->base_dns[i] = NULL;
 612         }
 613
 614         return LDB_SUCCESS;
 615 }
 616
 617 static int find_base_dns(struct ldb_module *module,
 618                           struct entryuuid_private *entryuuid_private)
 619 {
 620         int ret;
 621         struct ldb_request *req;
 622         const char *naming_context_attr[] = {
 623                 "namingContexts",
 624                 NULL
 625         };
 626         req = talloc(entryuuid_private, struct ldb_request);
 627         if (req == NULL) {
 628                 ldb_set_errstring(module->ldb, "Out of Memory");
 629                 return LDB_ERR_OPERATIONS_ERROR;
 630         }
 631
 632         req->operation = LDB_SEARCH;
 633         req->op.search.base = ldb_dn_new(req, module->ldb, NULL);
 634         req->op.search.scope = LDB_SCOPE_BASE;
 635
 636         req->op.search.tree = ldb_parse_tree(req, "objectClass=*");
 637         if (req->op.search.tree == NULL) {
 638                 ldb_set_errstring(module->ldb, "Unable to parse search expression");
 639                 talloc_free(req);
 640                 return LDB_ERR_OPERATIONS_ERROR;
 641         }
 642
 643         req->op.search.attrs = naming_context_attr;
 644         req->controls = NULL;
 645         req->context = entryuuid_private;
 646         req->callback = get_remote_rootdse;
 647         ldb_set_timeout(module->ldb, req, 0); /* use default timeout */
 648
 649         ret = ldb_next_request(module, req);
 650
 651         if (ret == LDB_SUCCESS) {
 652                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 653         }
 654
 655         talloc_free(req);
 656         if (ret != LDB_SUCCESS) {
 657                 return ret;
 658         }
 659
 660         return LDB_SUCCESS;
 661 }
 662
 663 /* the context init function */
 664 static int entryuuid_init(struct ldb_module *module)
 665 {
 666         int ret;
 667         struct map_private *map_private;
 668         struct entryuuid_private *entryuuid_private;
 669
 670         ret = ldb_map_init(module, entryuuid_attributes, entryuuid_objectclasses, entryuuid_wildcard_attributes, NULL);
 671         if (ret != LDB_SUCCESS)
 672                 return ret;
 673
 674         map_private = talloc_get_type(module->private_data, struct map_private);
 675
 676         entryuuid_private = talloc_zero(map_private, struct entryuuid_private);
 677         map_private->caller_private = entryuuid_private;
 678
 679         ret = find_base_dns(module, entryuuid_private);
 680
 681         return ldb_next_init(module);
 682 }
 683
 684 /* the context init function */
 685 static int nsuniqueid_init(struct ldb_module *module)
 686 {
 687         int ret;
 688         struct map_private *map_private;
 689         struct entryuuid_private *entryuuid_private;
 690
 691         ret = ldb_map_init(module, nsuniqueid_attributes, NULL, nsuniqueid_wildcard_attributes, NULL);
 692         if (ret != LDB_SUCCESS)
 693                 return ret;
 694
 695         map_private = talloc_get_type(module->private_data, struct map_private);
 696
 697         entryuuid_private = talloc_zero(map_private, struct entryuuid_private);
 698         map_private->caller_private = entryuuid_private;
 699
 700         ret = find_base_dns(module, entryuuid_private);
 701
 702         return ldb_next_init(module);
 703 }
 704
 705 static int get_seq(struct ldb_context *ldb, void *context,
 706                    struct ldb_reply *ares)
 707 {
 708         unsigned long long *max_seq = (unsigned long long *)context;
 709         unsigned long long seq;
 710         if (ares->type == LDB_REPLY_ENTRY) {
 711                 struct ldb_message_element *el = ldb_msg_find_element(ares->message, "contextCSN");
 712                 if (el) {
 713                         seq = entryCSN_to_usn_int(ares, &el->values[0]);
 714                         *max_seq = MAX(seq, *max_seq);
 715                 }
 716         }
 717
 718         return LDB_SUCCESS;
 719 }
 720
 721 static int entryuuid_sequence_number(struct ldb_module *module, struct ldb_request *req)
 722 {
 723         int i, ret;
 724         struct map_private *map_private;
 725         struct entryuuid_private *entryuuid_private;
 726         unsigned long long max_seq = 0;
 727         struct ldb_request *search_req;
 728         map_private = talloc_get_type(module->private_data, struct map_private);
 729
 730         entryuuid_private = talloc_get_type(map_private->caller_private, struct entryuuid_private);
 731
 732         /* Search the baseDNs for a sequence number */
 733         for (i=0; entryuuid_private &&
 734                      entryuuid_private->base_dns &&
 735                      entryuuid_private->base_dns[i];
 736                 i++) {
 737                 static const char *contextCSN_attr[] = {
 738                         "contextCSN", NULL
 739                 };
 740                 search_req = talloc(req, struct ldb_request);
 741                 if (search_req == NULL) {
 742                         ldb_set_errstring(module->ldb, "Out of Memory");
 743                         return LDB_ERR_OPERATIONS_ERROR;
 744                 }
 745
 746                 search_req->operation = LDB_SEARCH;
 747                 search_req->op.search.base = entryuuid_private->base_dns[i];
 748                 search_req->op.search.scope = LDB_SCOPE_BASE;
 749
 750                 search_req->op.search.tree = ldb_parse_tree(search_req, "objectClass=*");
 751                 if (search_req->op.search.tree == NULL) {
 752                         ldb_set_errstring(module->ldb, "Unable to parse search expression");
 753                         talloc_free(search_req);
 754                         return LDB_ERR_OPERATIONS_ERROR;
 755                 }
 756
 757                 search_req->op.search.attrs = contextCSN_attr;
 758                 search_req->controls = NULL;
 759                 search_req->context = &max_seq;
 760                 search_req->callback = get_seq;
 761                 ldb_set_timeout(module->ldb, search_req, 0); /* use default timeout */
 762
 763                 ret = ldb_next_request(module, search_req);
 764
 765                 if (ret == LDB_SUCCESS) {
 766                         ret = ldb_wait(search_req->handle, LDB_WAIT_ALL);
 767                 }
 768
 769                 talloc_free(search_req);
 770                 if (ret != LDB_SUCCESS) {
 771                         return ret;
 772                 }
 773         }
 774
 775         switch (req->op.seq_num.type) {
 776         case LDB_SEQ_HIGHEST_SEQ:
 777                 req->op.seq_num.seq_num = max_seq;
 778                 break;
 779         case LDB_SEQ_NEXT:
 780                 req->op.seq_num.seq_num = max_seq;
 781                 req->op.seq_num.seq_num++;
 782                 break;
 783         case LDB_SEQ_HIGHEST_TIMESTAMP:
 784         {
 785                 req->op.seq_num.seq_num = (max_seq >> 24);
 786                 break;
 787         }
 788         }
 789         req->op.seq_num.flags = 0;
 790         req->op.seq_num.flags |= LDB_SEQ_TIMESTAMP_SEQUENCE;
 791         req->op.seq_num.flags |= LDB_SEQ_GLOBAL_SEQUENCE;
 792         return LDB_SUCCESS;
 793 }
 794
 795 static struct ldb_module_ops entryuuid_ops = {
 796         .name              = "entryuuid",
 797         .init_context      = entryuuid_init,
 798         .sequence_number   = entryuuid_sequence_number
 799 };
 800
 801 static struct ldb_module_ops nsuniqueid_ops = {
 802         .name              = "nsuniqueid",
 803         .init_context      = nsuniqueid_init,
 804         .sequence_number   = entryuuid_sequence_number
 805 };
 806
 807 /* the init function */
 808 int ldb_simple_ldap_map_module_init(void)
 809 {
 810         int ret;
 811         struct ldb_module_ops ops = ldb_map_get_ops();
 812         entryuuid_ops.add       = ops.add;
 813         entryuuid_ops.modify    = ops.modify;
 814         entryuuid_ops.del       = ops.del;
 815         entryuuid_ops.rename    = ops.rename;
 816         entryuuid_ops.search    = ops.search;
 817         entryuuid_ops.wait      = ops.wait;
 818         ret = ldb_register_module(&entryuuid_ops);
 819
 820         if (ret) {
 821                 return ret;
 822         }
 823
 824         nsuniqueid_ops.add      = ops.add;
 825         nsuniqueid_ops.modify   = ops.modify;
 826         nsuniqueid_ops.del      = ops.del;
 827         nsuniqueid_ops.rename   = ops.rename;
 828         nsuniqueid_ops.search   = ops.search;
 829         nsuniqueid_ops.wait     = ops.wait;
 830         ret = ldb_register_module(&nsuniqueid_ops);
 831
 832         return ret;
 833 }