source4/dsdb/schema/schema_syntax.c

   1 /*
   2    Unix SMB/CIFS mplementation.
   3    DSDB schema syntaxes
   4
   5    Copyright (C) Stefan Metzmacher <metze@samba.org> 2006
   6    Copyright (C) Simo Sorce 2005
   7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2008
   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 #include "includes.h"
  24 #include "dsdb/samdb/samdb.h"
  25 #include "librpc/gen_ndr/ndr_drsuapi.h"
  26 #include "librpc/gen_ndr/ndr_security.h"
  27 #include "librpc/gen_ndr/ndr_misc.h"
  28 #include "lib/ldb/include/ldb.h"
  29 #include "lib/ldb/include/ldb_errors.h"
  30 #include "system/time.h"
  31 #include "../lib/util/charset/charset.h"
  32 #include "librpc/ndr/libndr.h"
  33
  34 static WERROR dsdb_syntax_FOOBAR_drsuapi_to_ldb(struct ldb_context *ldb,
  35                                                 const struct dsdb_schema *schema,
  36                                                 const struct dsdb_attribute *attr,
  37                                                 const struct drsuapi_DsReplicaAttribute *in,
  38                                                 TALLOC_CTX *mem_ctx,
  39                                                 struct ldb_message_element *out)
  40 {
  41         uint32_t i;
  42
  43         out->flags      = 0;
  44         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
  45         W_ERROR_HAVE_NO_MEMORY(out->name);
  46
  47         out->num_values = in->value_ctr.num_values;
  48         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
  49         W_ERROR_HAVE_NO_MEMORY(out->values);
  50
  51         for (i=0; i < out->num_values; i++) {
  52                 char *str;
  53
  54                 if (in->value_ctr.values[i].blob == NULL) {
  55                         return WERR_FOOBAR;
  56                 }
  57
  58                 str = talloc_asprintf(out->values, "%s: not implemented",
  59                                       attr->syntax->name);
  60                 W_ERROR_HAVE_NO_MEMORY(str);
  61
  62                 out->values[i] = data_blob_string_const(str);
  63         }
  64
  65         return WERR_OK;
  66 }
  67
  68 static WERROR dsdb_syntax_FOOBAR_ldb_to_drsuapi(struct ldb_context *ldb,
  69                                                 const struct dsdb_schema *schema,
  70                                                 const struct dsdb_attribute *attr,
  71                                                 const struct ldb_message_element *in,
  72                                                 TALLOC_CTX *mem_ctx,
  73                                                 struct drsuapi_DsReplicaAttribute *out)
  74 {
  75         return WERR_FOOBAR;
  76 }
  77
  78 static WERROR dsdb_syntax_BOOL_drsuapi_to_ldb(struct ldb_context *ldb,
  79                                               const struct dsdb_schema *schema,
  80                                               const struct dsdb_attribute *attr,
  81                                               const struct drsuapi_DsReplicaAttribute *in,
  82                                               TALLOC_CTX *mem_ctx,
  83                                               struct ldb_message_element *out)
  84 {
  85         uint32_t i;
  86
  87         out->flags      = 0;
  88         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
  89         W_ERROR_HAVE_NO_MEMORY(out->name);
  90
  91         out->num_values = in->value_ctr.num_values;
  92         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
  93         W_ERROR_HAVE_NO_MEMORY(out->values);
  94
  95         for (i=0; i < out->num_values; i++) {
  96                 uint32_t v;
  97                 char *str;
  98
  99                 if (in->value_ctr.values[i].blob == NULL) {
 100                         return WERR_FOOBAR;
 101                 }
 102
 103                 if (in->value_ctr.values[i].blob->length != 4) {
 104                         return WERR_FOOBAR;
 105                 }
 106
 107                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 108
 109                 if (v != 0) {
 110                         str = talloc_strdup(out->values, "TRUE");
 111                         W_ERROR_HAVE_NO_MEMORY(str);
 112                 } else {
 113                         str = talloc_strdup(out->values, "FALSE");
 114                         W_ERROR_HAVE_NO_MEMORY(str);
 115                 }
 116
 117                 out->values[i] = data_blob_string_const(str);
 118         }
 119
 120         return WERR_OK;
 121 }
 122
 123 static WERROR dsdb_syntax_BOOL_ldb_to_drsuapi(struct ldb_context *ldb,
 124                                               const struct dsdb_schema *schema,
 125                                               const struct dsdb_attribute *attr,
 126                                               const struct ldb_message_element *in,
 127                                               TALLOC_CTX *mem_ctx,
 128                                               struct drsuapi_DsReplicaAttribute *out)
 129 {
 130         uint32_t i;
 131         DATA_BLOB *blobs;
 132
 133         if (attr->attributeID_id == 0xFFFFFFFF) {
 134                 return WERR_FOOBAR;
 135         }
 136
 137         out->attid                      = attr->attributeID_id;
 138         out->value_ctr.num_values       = in->num_values;
 139         out->value_ctr.values           = talloc_array(mem_ctx,
 140                                                        struct drsuapi_DsAttributeValue,
 141                                                        in->num_values);
 142         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 143
 144         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 145         W_ERROR_HAVE_NO_MEMORY(blobs);
 146
 147         for (i=0; i < in->num_values; i++) {
 148                 out->value_ctr.values[i].blob   = &blobs[i];
 149
 150                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 151                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 152
 153                 if (strcmp("TRUE", (const char *)in->values[i].data) == 0) {
 154                         SIVAL(blobs[i].data, 0, 0x00000001);
 155                 } else if (strcmp("FALSE", (const char *)in->values[i].data) == 0) {
 156                         SIVAL(blobs[i].data, 0, 0x00000000);
 157                 } else {
 158                         return WERR_FOOBAR;
 159                 }
 160         }
 161
 162         return WERR_OK;
 163 }
 164
 165 static WERROR dsdb_syntax_INT32_drsuapi_to_ldb(struct ldb_context *ldb,
 166                                                const struct dsdb_schema *schema,
 167                                                const struct dsdb_attribute *attr,
 168                                                const struct drsuapi_DsReplicaAttribute *in,
 169                                                TALLOC_CTX *mem_ctx,
 170                                                struct ldb_message_element *out)
 171 {
 172         uint32_t i;
 173
 174         out->flags      = 0;
 175         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 176         W_ERROR_HAVE_NO_MEMORY(out->name);
 177
 178         out->num_values = in->value_ctr.num_values;
 179         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 180         W_ERROR_HAVE_NO_MEMORY(out->values);
 181
 182         for (i=0; i < out->num_values; i++) {
 183                 int32_t v;
 184                 char *str;
 185
 186                 if (in->value_ctr.values[i].blob == NULL) {
 187                         return WERR_FOOBAR;
 188                 }
 189
 190                 if (in->value_ctr.values[i].blob->length != 4) {
 191                         return WERR_FOOBAR;
 192                 }
 193
 194                 v = IVALS(in->value_ctr.values[i].blob->data, 0);
 195
 196                 str = talloc_asprintf(out->values, "%d", v);
 197                 W_ERROR_HAVE_NO_MEMORY(str);
 198
 199                 out->values[i] = data_blob_string_const(str);
 200         }
 201
 202         return WERR_OK;
 203 }
 204
 205 static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(struct ldb_context *ldb,
 206                                                const struct dsdb_schema *schema,
 207                                                const struct dsdb_attribute *attr,
 208                                                const struct ldb_message_element *in,
 209                                                TALLOC_CTX *mem_ctx,
 210                                                struct drsuapi_DsReplicaAttribute *out)
 211 {
 212         uint32_t i;
 213         DATA_BLOB *blobs;
 214
 215         if (attr->attributeID_id == 0xFFFFFFFF) {
 216                 return WERR_FOOBAR;
 217         }
 218
 219         out->attid                      = attr->attributeID_id;
 220         out->value_ctr.num_values       = in->num_values;
 221         out->value_ctr.values           = talloc_array(mem_ctx,
 222                                                        struct drsuapi_DsAttributeValue,
 223                                                        in->num_values);
 224         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 225
 226         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 227         W_ERROR_HAVE_NO_MEMORY(blobs);
 228
 229         for (i=0; i < in->num_values; i++) {
 230                 int32_t v;
 231
 232                 out->value_ctr.values[i].blob   = &blobs[i];
 233
 234                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 235                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 236
 237                 /* We've to use "strtoll" here to have the intended overflows.
 238                  * Otherwise we may get "LONG_MAX" and the conversion is wrong. */
 239                 v = (int32_t) strtoll((char *)in->values[i].data, NULL, 0);
 240
 241                 SIVALS(blobs[i].data, 0, v);
 242         }
 243
 244         return WERR_OK;
 245 }
 246
 247 static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(struct ldb_context *ldb,
 248                                                const struct dsdb_schema *schema,
 249                                                const struct dsdb_attribute *attr,
 250                                                const struct drsuapi_DsReplicaAttribute *in,
 251                                                TALLOC_CTX *mem_ctx,
 252                                                struct ldb_message_element *out)
 253 {
 254         uint32_t i;
 255
 256         out->flags      = 0;
 257         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 258         W_ERROR_HAVE_NO_MEMORY(out->name);
 259
 260         out->num_values = in->value_ctr.num_values;
 261         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 262         W_ERROR_HAVE_NO_MEMORY(out->values);
 263
 264         for (i=0; i < out->num_values; i++) {
 265                 int64_t v;
 266                 char *str;
 267
 268                 if (in->value_ctr.values[i].blob == NULL) {
 269                         return WERR_FOOBAR;
 270                 }
 271
 272                 if (in->value_ctr.values[i].blob->length != 8) {
 273                         return WERR_FOOBAR;
 274                 }
 275
 276                 v = BVALS(in->value_ctr.values[i].blob->data, 0);
 277
 278                 str = talloc_asprintf(out->values, "%lld", (long long int)v);
 279                 W_ERROR_HAVE_NO_MEMORY(str);
 280
 281                 out->values[i] = data_blob_string_const(str);
 282         }
 283
 284         return WERR_OK;
 285 }
 286
 287 static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(struct ldb_context *ldb,
 288                                                const struct dsdb_schema *schema,
 289                                                const struct dsdb_attribute *attr,
 290                                                const struct ldb_message_element *in,
 291                                                TALLOC_CTX *mem_ctx,
 292                                                struct drsuapi_DsReplicaAttribute *out)
 293 {
 294         uint32_t i;
 295         DATA_BLOB *blobs;
 296
 297         if (attr->attributeID_id == 0xFFFFFFFF) {
 298                 return WERR_FOOBAR;
 299         }
 300
 301         out->attid                      = attr->attributeID_id;
 302         out->value_ctr.num_values       = in->num_values;
 303         out->value_ctr.values           = talloc_array(mem_ctx,
 304                                                        struct drsuapi_DsAttributeValue,
 305                                                        in->num_values);
 306         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 307
 308         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 309         W_ERROR_HAVE_NO_MEMORY(blobs);
 310
 311         for (i=0; i < in->num_values; i++) {
 312                 int64_t v;
 313
 314                 out->value_ctr.values[i].blob   = &blobs[i];
 315
 316                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 317                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 318
 319                 v = strtoll((const char *)in->values[i].data, NULL, 10);
 320
 321                 SBVALS(blobs[i].data, 0, v);
 322         }
 323
 324         return WERR_OK;
 325 }
 326
 327 static WERROR dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb(struct ldb_context *ldb,
 328                                                     const struct dsdb_schema *schema,
 329                                                     const struct dsdb_attribute *attr,
 330                                                     const struct drsuapi_DsReplicaAttribute *in,
 331                                                     TALLOC_CTX *mem_ctx,
 332                                                     struct ldb_message_element *out)
 333 {
 334         uint32_t i;
 335
 336         out->flags      = 0;
 337         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 338         W_ERROR_HAVE_NO_MEMORY(out->name);
 339
 340         out->num_values = in->value_ctr.num_values;
 341         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 342         W_ERROR_HAVE_NO_MEMORY(out->values);
 343
 344         for (i=0; i < out->num_values; i++) {
 345                 NTTIME v;
 346                 time_t t;
 347                 char *str;
 348
 349                 if (in->value_ctr.values[i].blob == NULL) {
 350                         return WERR_FOOBAR;
 351                 }
 352
 353                 if (in->value_ctr.values[i].blob->length != 8) {
 354                         return WERR_FOOBAR;
 355                 }
 356
 357                 v = BVAL(in->value_ctr.values[i].blob->data, 0);
 358                 v *= 10000000;
 359                 t = nt_time_to_unix(v);
 360
 361                 /*
 362                  * NOTE: On a w2k3 server you can set a GeneralizedTime string
 363                  *       via LDAP, but you get back an UTCTime string,
 364                  *       but via DRSUAPI you get back the NTTIME_1sec value
 365                  *       that represents the GeneralizedTime value!
 366                  *
 367                  *       So if we store the UTCTime string in our ldb
 368                  *       we'll loose information!
 369                  */
 370                 str = ldb_timestring_utc(out->values, t);
 371                 W_ERROR_HAVE_NO_MEMORY(str);
 372                 out->values[i] = data_blob_string_const(str);
 373         }
 374
 375         return WERR_OK;
 376 }
 377
 378 static WERROR dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi(struct ldb_context *ldb,
 379                                                     const struct dsdb_schema *schema,
 380                                                     const struct dsdb_attribute *attr,
 381                                                     const struct ldb_message_element *in,
 382                                                     TALLOC_CTX *mem_ctx,
 383                                                     struct drsuapi_DsReplicaAttribute *out)
 384 {
 385         uint32_t i;
 386         DATA_BLOB *blobs;
 387
 388         if (attr->attributeID_id == 0xFFFFFFFF) {
 389                 return WERR_FOOBAR;
 390         }
 391
 392         out->attid                      = attr->attributeID_id;
 393         out->value_ctr.num_values       = in->num_values;
 394         out->value_ctr.values           = talloc_array(mem_ctx,
 395                                                        struct drsuapi_DsAttributeValue,
 396                                                        in->num_values);
 397         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 398
 399         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 400         W_ERROR_HAVE_NO_MEMORY(blobs);
 401
 402         for (i=0; i < in->num_values; i++) {
 403                 NTTIME v;
 404                 time_t t;
 405
 406                 out->value_ctr.values[i].blob   = &blobs[i];
 407
 408                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 409                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 410
 411                 t = ldb_string_utc_to_time((const char *)in->values[i].data);
 412                 unix_to_nt_time(&v, t);
 413                 v /= 10000000;
 414
 415                 SBVAL(blobs[i].data, 0, v);
 416         }
 417
 418         return WERR_OK;
 419 }
 420
 421 static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(struct ldb_context *ldb,
 422                                                 const struct dsdb_schema *schema,
 423                                                 const struct dsdb_attribute *attr,
 424                                                 const struct drsuapi_DsReplicaAttribute *in,
 425                                                 TALLOC_CTX *mem_ctx,
 426                                                 struct ldb_message_element *out)
 427 {
 428         uint32_t i;
 429
 430         out->flags      = 0;
 431         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 432         W_ERROR_HAVE_NO_MEMORY(out->name);
 433
 434         out->num_values = in->value_ctr.num_values;
 435         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 436         W_ERROR_HAVE_NO_MEMORY(out->values);
 437
 438         for (i=0; i < out->num_values; i++) {
 439                 NTTIME v;
 440                 time_t t;
 441                 char *str;
 442
 443                 if (in->value_ctr.values[i].blob == NULL) {
 444                         return WERR_FOOBAR;
 445                 }
 446
 447                 if (in->value_ctr.values[i].blob->length != 8) {
 448                         return WERR_FOOBAR;
 449                 }
 450
 451                 v = BVAL(in->value_ctr.values[i].blob->data, 0);
 452                 v *= 10000000;
 453                 t = nt_time_to_unix(v);
 454
 455                 str = ldb_timestring(out->values, t);
 456                 W_ERROR_HAVE_NO_MEMORY(str);
 457
 458                 out->values[i] = data_blob_string_const(str);
 459         }
 460
 461         return WERR_OK;
 462 }
 463
 464 static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(struct ldb_context *ldb,
 465                                                 const struct dsdb_schema *schema,
 466                                                 const struct dsdb_attribute *attr,
 467                                                 const struct ldb_message_element *in,
 468                                                 TALLOC_CTX *mem_ctx,
 469                                                 struct drsuapi_DsReplicaAttribute *out)
 470 {
 471         uint32_t i;
 472         DATA_BLOB *blobs;
 473
 474         if (attr->attributeID_id == 0xFFFFFFFF) {
 475                 return WERR_FOOBAR;
 476         }
 477
 478         out->attid                      = attr->attributeID_id;
 479         out->value_ctr.num_values       = in->num_values;
 480         out->value_ctr.values           = talloc_array(mem_ctx,
 481                                                        struct drsuapi_DsAttributeValue,
 482                                                        in->num_values);
 483         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 484
 485         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 486         W_ERROR_HAVE_NO_MEMORY(blobs);
 487
 488         for (i=0; i < in->num_values; i++) {
 489                 NTTIME v;
 490                 time_t t;
 491
 492                 out->value_ctr.values[i].blob   = &blobs[i];
 493
 494                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 495                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 496
 497                 t = ldb_string_to_time((const char *)in->values[i].data);
 498                 unix_to_nt_time(&v, t);
 499                 v /= 10000000;
 500
 501                 SBVAL(blobs[i].data, 0, v);
 502         }
 503
 504         return WERR_OK;
 505 }
 506
 507 static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(struct ldb_context *ldb,
 508                                                    const struct dsdb_schema *schema,
 509                                                    const struct dsdb_attribute *attr,
 510                                                    const struct drsuapi_DsReplicaAttribute *in,
 511                                                    TALLOC_CTX *mem_ctx,
 512                                                    struct ldb_message_element *out)
 513 {
 514         uint32_t i;
 515
 516         out->flags      = 0;
 517         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 518         W_ERROR_HAVE_NO_MEMORY(out->name);
 519
 520         out->num_values = in->value_ctr.num_values;
 521         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 522         W_ERROR_HAVE_NO_MEMORY(out->values);
 523
 524         for (i=0; i < out->num_values; i++) {
 525                 if (in->value_ctr.values[i].blob == NULL) {
 526                         return WERR_FOOBAR;
 527                 }
 528
 529                 if (in->value_ctr.values[i].blob->length == 0) {
 530                         return WERR_FOOBAR;
 531                 }
 532
 533                 out->values[i] = data_blob_dup_talloc(out->values,
 534                                                       in->value_ctr.values[i].blob);
 535                 W_ERROR_HAVE_NO_MEMORY(out->values[i].data);
 536         }
 537
 538         return WERR_OK;
 539 }
 540
 541 static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(struct ldb_context *ldb,
 542                                                    const struct dsdb_schema *schema,
 543                                                    const struct dsdb_attribute *attr,
 544                                                    const struct ldb_message_element *in,
 545                                                    TALLOC_CTX *mem_ctx,
 546                                                    struct drsuapi_DsReplicaAttribute *out)
 547 {
 548         uint32_t i;
 549         DATA_BLOB *blobs;
 550
 551         if (attr->attributeID_id == 0xFFFFFFFF) {
 552                 return WERR_FOOBAR;
 553         }
 554
 555         out->attid                      = attr->attributeID_id;
 556         out->value_ctr.num_values       = in->num_values;
 557         out->value_ctr.values           = talloc_array(mem_ctx,
 558                                                        struct drsuapi_DsAttributeValue,
 559                                                        in->num_values);
 560         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 561
 562         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 563         W_ERROR_HAVE_NO_MEMORY(blobs);
 564
 565         for (i=0; i < in->num_values; i++) {
 566                 out->value_ctr.values[i].blob   = &blobs[i];
 567
 568                 blobs[i] = data_blob_dup_talloc(blobs, &in->values[i]);
 569                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 570         }
 571
 572         return WERR_OK;
 573 }
 574
 575 static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(struct ldb_context *ldb,
 576                                                   const struct dsdb_schema *schema,
 577                                                   const struct dsdb_attribute *attr,
 578                                                   const struct drsuapi_DsReplicaAttribute *in,
 579                                                   TALLOC_CTX *mem_ctx,
 580                                                   struct ldb_message_element *out)
 581 {
 582         uint32_t i;
 583
 584         out->flags      = 0;
 585         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 586         W_ERROR_HAVE_NO_MEMORY(out->name);
 587
 588         out->num_values = in->value_ctr.num_values;
 589         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 590         W_ERROR_HAVE_NO_MEMORY(out->values);
 591
 592         for (i=0; i < out->num_values; i++) {
 593                 uint32_t v;
 594                 const struct dsdb_class *c;
 595                 const char *str;
 596
 597                 if (in->value_ctr.values[i].blob == NULL) {
 598                         return WERR_FOOBAR;
 599                 }
 600
 601                 if (in->value_ctr.values[i].blob->length != 4) {
 602                         return WERR_FOOBAR;
 603                 }
 604
 605                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 606
 607                 c = dsdb_class_by_governsID_id(schema, v);
 608                 if (!c) {
 609                         return WERR_FOOBAR;
 610                 }
 611
 612                 str = talloc_strdup(out->values, c->lDAPDisplayName);
 613                 W_ERROR_HAVE_NO_MEMORY(str);
 614
 615                 /* the values need to be reversed */
 616                 out->values[out->num_values - (i + 1)] = data_blob_string_const(str);
 617         }
 618
 619         return WERR_OK;
 620 }
 621
 622 static WERROR _dsdb_syntax_OID_attr_drsuapi_to_ldb(struct ldb_context *ldb,
 623                                                    const struct dsdb_schema *schema,
 624                                                    const struct dsdb_attribute *attr,
 625                                                    const struct drsuapi_DsReplicaAttribute *in,
 626                                                    TALLOC_CTX *mem_ctx,
 627                                                    struct ldb_message_element *out)
 628 {
 629         uint32_t i;
 630
 631         out->flags      = 0;
 632         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 633         W_ERROR_HAVE_NO_MEMORY(out->name);
 634
 635         out->num_values = in->value_ctr.num_values;
 636         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 637         W_ERROR_HAVE_NO_MEMORY(out->values);
 638
 639         for (i=0; i < out->num_values; i++) {
 640                 uint32_t v;
 641                 const struct dsdb_attribute *a;
 642                 const char *str;
 643
 644                 if (in->value_ctr.values[i].blob == NULL) {
 645                         return WERR_FOOBAR;
 646                 }
 647
 648                 if (in->value_ctr.values[i].blob->length != 4) {
 649                         return WERR_FOOBAR;
 650                 }
 651
 652                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 653
 654                 a = dsdb_attribute_by_attributeID_id(schema, v);
 655                 if (!a) {
 656                         return WERR_FOOBAR;
 657                 }
 658
 659                 str = talloc_strdup(out->values, a->lDAPDisplayName);
 660                 W_ERROR_HAVE_NO_MEMORY(str);
 661
 662                 /* the values need to be reversed */
 663                 out->values[out->num_values - (i + 1)] = data_blob_string_const(str);
 664         }
 665
 666         return WERR_OK;
 667 }
 668
 669 static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(struct ldb_context *ldb,
 670                                                   const struct dsdb_schema *schema,
 671                                                   const struct dsdb_attribute *attr,
 672                                                   const struct drsuapi_DsReplicaAttribute *in,
 673                                                   TALLOC_CTX *mem_ctx,
 674                                                   struct ldb_message_element *out)
 675 {
 676         uint32_t i;
 677
 678         out->flags      = 0;
 679         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 680         W_ERROR_HAVE_NO_MEMORY(out->name);
 681
 682         out->num_values = in->value_ctr.num_values;
 683         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 684         W_ERROR_HAVE_NO_MEMORY(out->values);
 685
 686         for (i=0; i < out->num_values; i++) {
 687                 uint32_t v;
 688                 WERROR status;
 689                 const char *str;
 690
 691                 if (in->value_ctr.values[i].blob == NULL) {
 692                         return WERR_FOOBAR;
 693                 }
 694
 695                 if (in->value_ctr.values[i].blob->length != 4) {
 696                         return WERR_FOOBAR;
 697                 }
 698
 699                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 700
 701                 status = dsdb_map_int2oid(schema, v, out->values, &str);
 702                 W_ERROR_NOT_OK_RETURN(status);
 703
 704                 out->values[i] = data_blob_string_const(str);
 705         }
 706
 707         return WERR_OK;
 708 }
 709
 710 static WERROR _dsdb_syntax_OID_obj_ldb_to_drsuapi(struct ldb_context *ldb,
 711                                                   const struct dsdb_schema *schema,
 712                                                   const struct dsdb_attribute *attr,
 713                                                   const struct ldb_message_element *in,
 714                                                   TALLOC_CTX *mem_ctx,
 715                                                   struct drsuapi_DsReplicaAttribute *out)
 716 {
 717         uint32_t i;
 718         DATA_BLOB *blobs;
 719
 720         out->attid= attr->attributeID_id;
 721         out->value_ctr.num_values= in->num_values;
 722         out->value_ctr.values= talloc_array(mem_ctx,
 723                                             struct drsuapi_DsAttributeValue,
 724                                             in->num_values);
 725         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 726
 727         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 728         W_ERROR_HAVE_NO_MEMORY(blobs);
 729
 730         for (i=0; i < in->num_values; i++) {
 731                 const struct dsdb_class *obj_class;
 732
 733                 out->value_ctr.values[i].blob= &blobs[i];
 734
 735                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 736                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 737
 738                 obj_class = dsdb_class_by_lDAPDisplayName(schema, (const char *)in->values[i].data);
 739                 if (!obj_class) {
 740                         return WERR_FOOBAR;
 741                 }
 742                 SIVAL(blobs[i].data, 0, obj_class->governsID_id);
 743         }
 744
 745
 746         return WERR_OK;
 747 }
 748
 749 static WERROR _dsdb_syntax_OID_attr_ldb_to_drsuapi(struct ldb_context *ldb,
 750                                                    const struct dsdb_schema *schema,
 751                                                    const struct dsdb_attribute *attr,
 752                                                    const struct ldb_message_element *in,
 753                                                    TALLOC_CTX *mem_ctx,
 754                                                    struct drsuapi_DsReplicaAttribute *out)
 755 {
 756         uint32_t i;
 757         DATA_BLOB *blobs;
 758
 759         out->attid= attr->attributeID_id;
 760         out->value_ctr.num_values= in->num_values;
 761         out->value_ctr.values= talloc_array(mem_ctx,
 762                                             struct drsuapi_DsAttributeValue,
 763                                             in->num_values);
 764         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 765
 766         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 767         W_ERROR_HAVE_NO_MEMORY(blobs);
 768
 769         for (i=0; i < in->num_values; i++) {
 770                 const struct dsdb_attribute *obj_attr;
 771
 772                 out->value_ctr.values[i].blob= &blobs[i];
 773
 774                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 775                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 776
 777                 obj_attr = dsdb_attribute_by_lDAPDisplayName(schema, (const char *)in->values[i].data);
 778                 if (!obj_attr) {
 779                         return WERR_FOOBAR;
 780                 }
 781                 SIVAL(blobs[i].data, 0, obj_attr->attributeID_id);
 782         }
 783
 784
 785         return WERR_OK;
 786 }
 787
 788 static WERROR _dsdb_syntax_OID_oid_ldb_to_drsuapi(struct ldb_context *ldb,
 789                                                   const struct dsdb_schema *schema,
 790                                                   const struct dsdb_attribute *attr,
 791                                                   const struct ldb_message_element *in,
 792                                                   TALLOC_CTX *mem_ctx,
 793                                                   struct drsuapi_DsReplicaAttribute *out)
 794 {
 795         uint32_t i;
 796         DATA_BLOB *blobs;
 797
 798         out->attid= attr->attributeID_id;
 799         out->value_ctr.num_values= in->num_values;
 800         out->value_ctr.values= talloc_array(mem_ctx,
 801                                             struct drsuapi_DsAttributeValue,
 802                                             in->num_values);
 803         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 804
 805         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 806         W_ERROR_HAVE_NO_MEMORY(blobs);
 807
 808         for (i=0; i < in->num_values; i++) {
 809                 uint32_t v;
 810                 WERROR status;
 811
 812                 out->value_ctr.values[i].blob= &blobs[i];
 813
 814                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 815                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 816
 817                 status = dsdb_map_oid2int(schema,
 818                                           (const char *)in->values[i].data,
 819                                           &v);
 820                 W_ERROR_NOT_OK_RETURN(status);
 821
 822                 SIVAL(blobs[i].data, 0, v);
 823         }
 824
 825         return WERR_OK;
 826 }
 827
 828 static WERROR dsdb_syntax_OID_drsuapi_to_ldb(struct ldb_context *ldb,
 829                                              const struct dsdb_schema *schema,
 830                                              const struct dsdb_attribute *attr,
 831                                              const struct drsuapi_DsReplicaAttribute *in,
 832                                              TALLOC_CTX *mem_ctx,
 833                                              struct ldb_message_element *out)
 834 {
 835         uint32_t i;
 836
 837         switch (attr->attributeID_id) {
 838         case DRSUAPI_ATTRIBUTE_objectClass:
 839         case DRSUAPI_ATTRIBUTE_subClassOf:
 840         case DRSUAPI_ATTRIBUTE_auxiliaryClass:
 841         case DRSUAPI_ATTRIBUTE_systemPossSuperiors:
 842         case DRSUAPI_ATTRIBUTE_possSuperiors:
 843                 return _dsdb_syntax_OID_obj_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
 844         case DRSUAPI_ATTRIBUTE_systemMustContain:
 845         case DRSUAPI_ATTRIBUTE_systemMayContain:
 846         case DRSUAPI_ATTRIBUTE_mustContain:
 847         case DRSUAPI_ATTRIBUTE_mayContain:
 848                 return _dsdb_syntax_OID_attr_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
 849         case DRSUAPI_ATTRIBUTE_governsID:
 850         case DRSUAPI_ATTRIBUTE_attributeID:
 851         case DRSUAPI_ATTRIBUTE_attributeSyntax:
 852                 return _dsdb_syntax_OID_oid_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
 853         }
 854
 855         out->flags      = 0;
 856         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 857         W_ERROR_HAVE_NO_MEMORY(out->name);
 858
 859         out->num_values = in->value_ctr.num_values;
 860         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 861         W_ERROR_HAVE_NO_MEMORY(out->values);
 862
 863         for (i=0; i < out->num_values; i++) {
 864                 uint32_t v;
 865                 const char *name;
 866                 char *str;
 867
 868                 if (in->value_ctr.values[i].blob == NULL) {
 869                         return WERR_FOOBAR;
 870                 }
 871
 872                 if (in->value_ctr.values[i].blob->length != 4) {
 873                         return WERR_FOOBAR;
 874                 }
 875
 876                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 877
 878                 name = dsdb_lDAPDisplayName_by_id(schema, v);
 879                 if (!name) {
 880                         return WERR_FOOBAR;
 881                 }
 882
 883                 str = talloc_strdup(out->values, name);
 884                 W_ERROR_HAVE_NO_MEMORY(str);
 885
 886                 out->values[i] = data_blob_string_const(str);
 887         }
 888
 889         return WERR_OK;
 890 }
 891
 892 static WERROR dsdb_syntax_OID_ldb_to_drsuapi(struct ldb_context *ldb,
 893                                              const struct dsdb_schema *schema,
 894                                              const struct dsdb_attribute *attr,
 895                                              const struct ldb_message_element *in,
 896                                              TALLOC_CTX *mem_ctx,
 897                                              struct drsuapi_DsReplicaAttribute *out)
 898 {
 899         uint32_t i;
 900         DATA_BLOB *blobs;
 901
 902         if (attr->attributeID_id == 0xFFFFFFFF) {
 903                 return WERR_FOOBAR;
 904         }
 905
 906         switch (attr->attributeID_id) {
 907         case DRSUAPI_ATTRIBUTE_objectClass:
 908         case DRSUAPI_ATTRIBUTE_subClassOf:
 909         case DRSUAPI_ATTRIBUTE_auxiliaryClass:
 910         case DRSUAPI_ATTRIBUTE_systemPossSuperiors:
 911         case DRSUAPI_ATTRIBUTE_possSuperiors:
 912                 return _dsdb_syntax_OID_obj_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out);
 913         case DRSUAPI_ATTRIBUTE_systemMustContain:
 914         case DRSUAPI_ATTRIBUTE_systemMayContain:
 915         case DRSUAPI_ATTRIBUTE_mustContain:
 916         case DRSUAPI_ATTRIBUTE_mayContain:
 917                 return _dsdb_syntax_OID_attr_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out);
 918         case DRSUAPI_ATTRIBUTE_governsID:
 919         case DRSUAPI_ATTRIBUTE_attributeID:
 920         case DRSUAPI_ATTRIBUTE_attributeSyntax:
 921                 return _dsdb_syntax_OID_oid_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out);
 922         }
 923
 924         out->attid                      = attr->attributeID_id;
 925         out->value_ctr.num_values       = in->num_values;
 926         out->value_ctr.values           = talloc_array(mem_ctx,
 927                                                        struct drsuapi_DsAttributeValue,
 928                                                        in->num_values);
 929         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 930
 931         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 932         W_ERROR_HAVE_NO_MEMORY(blobs);
 933
 934         for (i=0; i < in->num_values; i++) {
 935                 uint32_t v;
 936
 937                 out->value_ctr.values[i].blob   = &blobs[i];
 938
 939                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 940                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 941
 942                 v = strtol((const char *)in->values[i].data, NULL, 10);
 943
 944                 SIVAL(blobs[i].data, 0, v);
 945         }
 946
 947         return WERR_OK;
 948 }
 949
 950 static WERROR dsdb_syntax_UNICODE_drsuapi_to_ldb(struct ldb_context *ldb,
 951                                                  const struct dsdb_schema *schema,
 952                                                  const struct dsdb_attribute *attr,
 953                                                  const struct drsuapi_DsReplicaAttribute *in,
 954                                                  TALLOC_CTX *mem_ctx,
 955                                                  struct ldb_message_element *out)
 956 {
 957         uint32_t i;
 958
 959         out->flags      = 0;
 960         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 961         W_ERROR_HAVE_NO_MEMORY(out->name);
 962
 963         out->num_values = in->value_ctr.num_values;
 964         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 965         W_ERROR_HAVE_NO_MEMORY(out->values);
 966
 967         for (i=0; i < out->num_values; i++) {
 968                 char *str;
 969
 970                 if (in->value_ctr.values[i].blob == NULL) {
 971                         return WERR_FOOBAR;
 972                 }
 973
 974                 if (in->value_ctr.values[i].blob->length == 0) {
 975                         return WERR_FOOBAR;
 976                 }
 977
 978                 if (!convert_string_talloc_convenience(out->values,
 979                                                 schema->iconv_convenience,
 980                                                                         CH_UTF16, CH_UNIX,
 981                                             in->value_ctr.values[i].blob->data,
 982                                             in->value_ctr.values[i].blob->length,
 983                                             (void **)&str, NULL, false)) {
 984                         return WERR_FOOBAR;
 985                 }
 986
 987                 out->values[i] = data_blob_string_const(str);
 988         }
 989
 990         return WERR_OK;
 991 }
 992
 993 static WERROR dsdb_syntax_UNICODE_ldb_to_drsuapi(struct ldb_context *ldb,
 994                                                  const struct dsdb_schema *schema,
 995                                                  const struct dsdb_attribute *attr,
 996                                                  const struct ldb_message_element *in,
 997                                                  TALLOC_CTX *mem_ctx,
 998                                                  struct drsuapi_DsReplicaAttribute *out)
 999 {
1000         uint32_t i;
1001         DATA_BLOB *blobs;
1002
1003         if (attr->attributeID_id == 0xFFFFFFFF) {
1004                 return WERR_FOOBAR;
1005         }
1006
1007         out->attid                      = attr->attributeID_id;
1008         out->value_ctr.num_values       = in->num_values;
1009         out->value_ctr.values           = talloc_array(mem_ctx,
1010                                                        struct drsuapi_DsAttributeValue,
1011                                                        in->num_values);
1012         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
1013
1014         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
1015         W_ERROR_HAVE_NO_MEMORY(blobs);
1016
1017         for (i=0; i < in->num_values; i++) {
1018                 out->value_ctr.values[i].blob   = &blobs[i];
1019
1020                 if (!convert_string_talloc_convenience(blobs,
1021                         schema->iconv_convenience, CH_UNIX, CH_UTF16,
1022                         in->values[i].data, in->values[i].length,
1023                         (void **)&blobs[i].data, &blobs[i].length, false)) {
1024                                 return WERR_FOOBAR;
1025                 }
1026         }
1027
1028         return WERR_OK;
1029 }
1030
1031 static WERROR dsdb_syntax_DN_drsuapi_to_ldb(struct ldb_context *ldb,
1032                                             const struct dsdb_schema *schema,
1033                                             const struct dsdb_attribute *attr,
1034                                             const struct drsuapi_DsReplicaAttribute *in,
1035                                             TALLOC_CTX *mem_ctx,
1036                                             struct ldb_message_element *out)
1037 {
1038         uint32_t i;
1039         int ret;
1040
1041         out->flags      = 0;
1042         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
1043         W_ERROR_HAVE_NO_MEMORY(out->name);
1044
1045         out->num_values = in->value_ctr.num_values;
1046         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
1047         W_ERROR_HAVE_NO_MEMORY(out->values);
1048
1049         for (i=0; i < out->num_values; i++) {
1050                 struct drsuapi_DsReplicaObjectIdentifier3 id3;
1051                 enum ndr_err_code ndr_err;
1052                 DATA_BLOB guid_blob;
1053                 struct ldb_dn *dn;
1054                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
1055                 if (!tmp_ctx) {
1056                         W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
1057                 }
1058
1059                 if (in->value_ctr.values[i].blob == NULL) {
1060                         talloc_free(tmp_ctx);
1061                         return WERR_FOOBAR;
1062                 }
1063
1064                 if (in->value_ctr.values[i].blob->length == 0) {
1065                         talloc_free(tmp_ctx);
1066                         return WERR_FOOBAR;
1067                 }
1068
1069
1070                 /* windows sometimes sends an extra two pad bytes here */
1071                 ndr_err = ndr_pull_struct_blob(in->value_ctr.values[i].blob,
1072                                                tmp_ctx, schema->iconv_convenience, &id3,
1073                                                (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
1074                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1075                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1076                         talloc_free(tmp_ctx);
1077                         return ntstatus_to_werror(status);
1078                 }
1079
1080                 dn = ldb_dn_new(tmp_ctx, ldb, id3.dn);
1081                 if (!dn) {
1082                         talloc_free(tmp_ctx);
1083                         /* If this fails, it must be out of memory, as it does not do much parsing */
1084                         W_ERROR_HAVE_NO_MEMORY(dn);
1085                 }
1086
1087                 ndr_err = ndr_push_struct_blob(&guid_blob, tmp_ctx, schema->iconv_convenience, &id3.guid,
1088                                                (ndr_push_flags_fn_t)ndr_push_GUID);
1089                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1090                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1091                         talloc_free(tmp_ctx);
1092                         return ntstatus_to_werror(status);
1093                 }
1094
1095                 ret = ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
1096                 if (ret != LDB_SUCCESS) {
1097                         talloc_free(tmp_ctx);
1098                         return WERR_FOOBAR;
1099                 }
1100
1101                 talloc_free(guid_blob.data);
1102
1103                 if (id3.__ndr_size_sid) {
1104                         DATA_BLOB sid_blob;
1105                         ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, schema->iconv_convenience, &id3.sid,
1106                                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
1107                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1108                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1109                                 talloc_free(tmp_ctx);
1110                                 return ntstatus_to_werror(status);
1111                         }
1112
1113                         ret = ldb_dn_set_extended_component(dn, "SID", &sid_blob);
1114                         if (ret != LDB_SUCCESS) {
1115                                 talloc_free(tmp_ctx);
1116                                 return WERR_FOOBAR;
1117                         }
1118                 }
1119
1120                 out->values[i] = data_blob_string_const(ldb_dn_get_extended_linearized(out->values, dn, 1));
1121                 talloc_free(tmp_ctx);
1122         }
1123
1124         return WERR_OK;
1125 }
1126
1127 static WERROR dsdb_syntax_DN_ldb_to_drsuapi(struct ldb_context *ldb,
1128                                             const struct dsdb_schema *schema,
1129                                             const struct dsdb_attribute *attr,
1130                                             const struct ldb_message_element *in,
1131                                             TALLOC_CTX *mem_ctx,
1132                                             struct drsuapi_DsReplicaAttribute *out)
1133 {
1134         uint32_t i;
1135         DATA_BLOB *blobs;
1136
1137         if (attr->attributeID_id == 0xFFFFFFFF) {
1138                 return WERR_FOOBAR;
1139         }
1140
1141         out->attid                      = attr->attributeID_id;
1142         out->value_ctr.num_values       = in->num_values;
1143         out->value_ctr.values           = talloc_array(mem_ctx,
1144                                                        struct drsuapi_DsAttributeValue,
1145                                                        in->num_values);
1146         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
1147
1148         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
1149         W_ERROR_HAVE_NO_MEMORY(blobs);
1150
1151         for (i=0; i < in->num_values; i++) {
1152                 struct drsuapi_DsReplicaObjectIdentifier3 id3;
1153                 enum ndr_err_code ndr_err;
1154                 const DATA_BLOB *guid_blob, *sid_blob;
1155                 struct ldb_dn *dn;
1156                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
1157                 W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
1158
1159                 out->value_ctr.values[i].blob   = &blobs[i];
1160
1161                 dn = ldb_dn_from_ldb_val(tmp_ctx, ldb, &in->values[i]);
1162
1163                 W_ERROR_HAVE_NO_MEMORY(dn);
1164
1165                 guid_blob = ldb_dn_get_extended_component(dn, "GUID");
1166
1167                 ZERO_STRUCT(id3);
1168
1169                 if (guid_blob) {
1170                         ndr_err = ndr_pull_struct_blob_all(guid_blob,
1171                                                            tmp_ctx, schema->iconv_convenience, &id3.guid,
1172                                                            (ndr_pull_flags_fn_t)ndr_pull_GUID);
1173                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1174                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1175                                 talloc_free(tmp_ctx);
1176                                 return ntstatus_to_werror(status);
1177                         }
1178                 }
1179
1180                 sid_blob = ldb_dn_get_extended_component(dn, "SID");
1181                 if (sid_blob) {
1182
1183                         ndr_err = ndr_pull_struct_blob_all(sid_blob,
1184                                                            tmp_ctx, schema->iconv_convenience, &id3.sid,
1185                                                            (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
1186                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1187                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1188                                 talloc_free(tmp_ctx);
1189                                 return ntstatus_to_werror(status);
1190                         }
1191                 }
1192
1193                 id3.dn = ldb_dn_get_linearized(dn);
1194
1195                 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1196                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1197                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1198                         talloc_free(tmp_ctx);
1199                         return ntstatus_to_werror(status);
1200                 }
1201                 talloc_free(tmp_ctx);
1202         }
1203
1204         return WERR_OK;
1205 }
1206
1207
1208
1209 static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(struct ldb_context *ldb,
1210                                                    const struct dsdb_schema *schema,
1211                                                    const struct dsdb_attribute *attr,
1212                                                    const struct drsuapi_DsReplicaAttribute *in,
1213                                                    TALLOC_CTX *mem_ctx,
1214                                                    struct ldb_message_element *out)
1215 {
1216         uint32_t i;
1217         int ret;
1218
1219         out->flags      = 0;
1220         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
1221         W_ERROR_HAVE_NO_MEMORY(out->name);
1222
1223         out->num_values = in->value_ctr.num_values;
1224         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
1225         W_ERROR_HAVE_NO_MEMORY(out->values);
1226
1227         for (i=0; i < out->num_values; i++) {
1228                 struct drsuapi_DsReplicaObjectIdentifier3Binary id3;
1229                 enum ndr_err_code ndr_err;
1230                 DATA_BLOB guid_blob;
1231                 struct ldb_dn *dn;
1232                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
1233                 if (!tmp_ctx) {
1234                         W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
1235                 }
1236
1237                 if (in->value_ctr.values[i].blob == NULL) {
1238                         talloc_free(tmp_ctx);
1239                         return WERR_FOOBAR;
1240                 }
1241
1242                 if (in->value_ctr.values[i].blob->length == 0) {
1243                         talloc_free(tmp_ctx);
1244                         return WERR_FOOBAR;
1245                 }
1246
1247
1248                 /* windows sometimes sends an extra two pad bytes here */
1249                 ndr_err = ndr_pull_struct_blob(in->value_ctr.values[i].blob,
1250                                                tmp_ctx, schema->iconv_convenience, &id3,
1251                                                (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
1252                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1253                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1254                         talloc_free(tmp_ctx);
1255                         return ntstatus_to_werror(status);
1256                 }
1257
1258                 dn = ldb_dn_new(tmp_ctx, ldb, id3.dn);
1259                 if (!dn) {
1260                         talloc_free(tmp_ctx);
1261                         /* If this fails, it must be out of memory, as it does not do much parsing */
1262                         W_ERROR_HAVE_NO_MEMORY(dn);
1263                 }
1264
1265                 ndr_err = ndr_push_struct_blob(&guid_blob, tmp_ctx, schema->iconv_convenience, &id3.guid,
1266                                                (ndr_push_flags_fn_t)ndr_push_GUID);
1267                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1268                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1269                         talloc_free(tmp_ctx);
1270                         return ntstatus_to_werror(status);
1271                 }
1272
1273                 ret = ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
1274                 if (ret != LDB_SUCCESS) {
1275                         talloc_free(tmp_ctx);
1276                         return WERR_FOOBAR;
1277                 }
1278
1279                 talloc_free(guid_blob.data);
1280
1281                 if (id3.__ndr_size_sid) {
1282                         DATA_BLOB sid_blob;
1283                         ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, schema->iconv_convenience, &id3.sid,
1284                                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
1285                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1286                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1287                                 talloc_free(tmp_ctx);
1288                                 return ntstatus_to_werror(status);
1289                         }
1290
1291                         ret = ldb_dn_set_extended_component(dn, "SID", &sid_blob);
1292                         if (ret != LDB_SUCCESS) {
1293                                 talloc_free(tmp_ctx);
1294                                 return WERR_FOOBAR;
1295                         }
1296                 }
1297
1298                 /* set binary stuff */
1299                 ldb_dn_set_binary(dn, &id3.binary);
1300
1301                 out->values[i] = data_blob_string_const(ldb_dn_get_extended_linearized(out->values, dn, 1));
1302                 talloc_free(tmp_ctx);
1303         }
1304
1305         return WERR_OK;
1306 }
1307
1308 static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(struct ldb_context *ldb,
1309                                                    const struct dsdb_schema *schema,
1310                                                    const struct dsdb_attribute *attr,
1311                                                    const struct ldb_message_element *in,
1312                                                    TALLOC_CTX *mem_ctx,
1313                                                    struct drsuapi_DsReplicaAttribute *out)
1314 {
1315         uint32_t i;
1316         DATA_BLOB *blobs;
1317
1318         if (attr->attributeID_id == 0xFFFFFFFF) {
1319                 return WERR_FOOBAR;
1320         }
1321
1322         out->attid                      = attr->attributeID_id;
1323         out->value_ctr.num_values       = in->num_values;
1324         out->value_ctr.values           = talloc_array(mem_ctx,
1325                                                        struct drsuapi_DsAttributeValue,
1326                                                        in->num_values);
1327         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
1328
1329         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
1330         W_ERROR_HAVE_NO_MEMORY(blobs);
1331
1332         for (i=0; i < in->num_values; i++) {
1333                 struct drsuapi_DsReplicaObjectIdentifier3Binary id3;
1334                 enum ndr_err_code ndr_err;
1335                 const DATA_BLOB *guid_blob, *sid_blob;
1336                 struct ldb_dn *dn;
1337                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
1338                 W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
1339
1340                 out->value_ctr.values[i].blob   = &blobs[i];
1341
1342                 dn = ldb_dn_from_ldb_val(tmp_ctx, ldb, &in->values[i]);
1343
1344                 W_ERROR_HAVE_NO_MEMORY(dn);
1345
1346                 guid_blob = ldb_dn_get_extended_component(dn, "GUID");
1347
1348                 ZERO_STRUCT(id3);
1349
1350                 if (guid_blob) {
1351                         ndr_err = ndr_pull_struct_blob_all(guid_blob,
1352                                                            tmp_ctx, schema->iconv_convenience, &id3.guid,
1353                                                            (ndr_pull_flags_fn_t)ndr_pull_GUID);
1354                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1355                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1356                                 talloc_free(tmp_ctx);
1357                                 return ntstatus_to_werror(status);
1358                         }
1359                 }
1360
1361                 sid_blob = ldb_dn_get_extended_component(dn, "SID");
1362                 if (sid_blob) {
1363
1364                         ndr_err = ndr_pull_struct_blob_all(sid_blob,
1365                                                            tmp_ctx, schema->iconv_convenience, &id3.sid,
1366                                                            (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
1367                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1368                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1369                                 talloc_free(tmp_ctx);
1370                                 return ntstatus_to_werror(status);
1371                         }
1372                 }
1373
1374                 id3.dn = ldb_dn_get_linearized(dn);
1375                 if (strncmp(id3.dn, "B:", 2) == 0) {
1376                         id3.dn = strchr(id3.dn, ':');
1377                         id3.dn = strchr(id3.dn+1, ':');
1378                         id3.dn = strchr(id3.dn+1, ':');
1379                         id3.dn++;
1380                 }
1381
1382                 /* get binary stuff */
1383                 ldb_dn_get_binary(dn, &id3.binary);
1384
1385                 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
1386                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1387                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1388                         talloc_free(tmp_ctx);
1389                         return ntstatus_to_werror(status);
1390                 }
1391                 talloc_free(tmp_ctx);
1392         }
1393
1394         return WERR_OK;
1395 }
1396
1397
1398
1399 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb(struct ldb_context *ldb,
1400                                                               const struct dsdb_schema *schema,
1401                                                               const struct dsdb_attribute *attr,
1402                                                               const struct drsuapi_DsReplicaAttribute *in,
1403                                                               TALLOC_CTX *mem_ctx,
1404                                                               struct ldb_message_element *out)
1405 {
1406         uint32_t i;
1407
1408         out->flags      = 0;
1409         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
1410         W_ERROR_HAVE_NO_MEMORY(out->name);
1411
1412         out->num_values = in->value_ctr.num_values;
1413         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
1414         W_ERROR_HAVE_NO_MEMORY(out->values);
1415
1416         for (i=0; i < out->num_values; i++) {
1417                 uint32_t len;
1418                 char *str;
1419
1420                 if (in->value_ctr.values[i].blob == NULL) {
1421                         return WERR_FOOBAR;
1422                 }
1423
1424                 if (in->value_ctr.values[i].blob->length < 4) {
1425                         return WERR_FOOBAR;
1426                 }
1427
1428                 len = IVAL(in->value_ctr.values[i].blob->data, 0);
1429
1430                 if (len != in->value_ctr.values[i].blob->length) {
1431                         return WERR_FOOBAR;
1432                 }
1433
1434                 if (!convert_string_talloc_convenience(out->values, schema->iconv_convenience, CH_UTF16, CH_UNIX,
1435                                             in->value_ctr.values[i].blob->data+4,
1436                                             in->value_ctr.values[i].blob->length-4,
1437                                             (void **)&str, NULL, false)) {
1438                         return WERR_FOOBAR;
1439                 }
1440
1441                 out->values[i] = data_blob_string_const(str);
1442         }
1443
1444         return WERR_OK;
1445 }
1446
1447 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi(struct ldb_context *ldb,
1448                                                               const struct dsdb_schema *schema,
1449                                                               const struct dsdb_attribute *attr,
1450                                                               const struct ldb_message_element *in,
1451                                                               TALLOC_CTX *mem_ctx,
1452                                                               struct drsuapi_DsReplicaAttribute *out)
1453 {
1454         uint32_t i;
1455         DATA_BLOB *blobs;
1456
1457         if (attr->attributeID_id == 0xFFFFFFFF) {
1458                 return WERR_FOOBAR;
1459         }
1460
1461         out->attid                      = attr->attributeID_id;
1462         out->value_ctr.num_values       = in->num_values;
1463         out->value_ctr.values           = talloc_array(mem_ctx,
1464                                                        struct drsuapi_DsAttributeValue,
1465                                                        in->num_values);
1466         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
1467
1468         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
1469         W_ERROR_HAVE_NO_MEMORY(blobs);
1470
1471         for (i=0; i < in->num_values; i++) {
1472                 uint8_t *data;
1473                 size_t ret;
1474
1475                 out->value_ctr.values[i].blob   = &blobs[i];
1476
1477                 if (!convert_string_talloc_convenience(blobs, schema->iconv_convenience, CH_UNIX, CH_UTF16,
1478                                             in->values[i].data,
1479                                             in->values[i].length,
1480                                             (void **)&data, &ret, false)) {
1481                         return WERR_FOOBAR;
1482                 }
1483
1484                 blobs[i] = data_blob_talloc(blobs, NULL, 4 + ret);
1485                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
1486
1487                 SIVAL(blobs[i].data, 0, 4 + ret);
1488
1489                 if (ret > 0) {
1490                         memcpy(blobs[i].data + 4, data, ret);
1491                         talloc_free(data);
1492                 }
1493         }
1494
1495         return WERR_OK;
1496 }
1497
1498 #define OMOBJECTCLASS(val) { .length = sizeof(val) - 1, .data = discard_const_p(uint8_t, val) }
1499
1500 static const struct dsdb_syntax dsdb_syntaxes[] = {
1501         {
1502                 .name                   = "Boolean",
1503                 .ldap_oid               = LDB_SYNTAX_BOOLEAN,
1504                 .oMSyntax               = 1,
1505                 .attributeSyntax_oid    = "2.5.5.8",
1506                 .drsuapi_to_ldb         = dsdb_syntax_BOOL_drsuapi_to_ldb,
1507                 .ldb_to_drsuapi         = dsdb_syntax_BOOL_ldb_to_drsuapi,
1508                 .equality               = "booleanMatch",
1509                 .comment                = "Boolean"
1510         },{
1511                 .name                   = "Integer",
1512                 .ldap_oid               = LDB_SYNTAX_INTEGER,
1513                 .oMSyntax               = 2,
1514                 .attributeSyntax_oid    = "2.5.5.9",
1515                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
1516                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
1517                 .equality               = "integerMatch",
1518                 .comment                = "Integer",
1519                 .ldb_syntax             = LDB_SYNTAX_SAMBA_INT32
1520         },{
1521                 .name                   = "String(Octet)",
1522                 .ldap_oid               = LDB_SYNTAX_OCTET_STRING,
1523                 .oMSyntax               = 4,
1524                 .attributeSyntax_oid    = "2.5.5.10",
1525                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1526                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1527                 .equality               = "octetStringMatch",
1528                 .comment                = "Octet String",
1529         },{
1530                 .name                   = "String(Sid)",
1531                 .ldap_oid               = LDB_SYNTAX_OCTET_STRING,
1532                 .oMSyntax               = 4,
1533                 .attributeSyntax_oid    = "2.5.5.17",
1534                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1535                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1536                 .equality               = "octetStringMatch",
1537                 .comment                = "Octet String - Security Identifier (SID)",
1538                 .ldb_syntax             = LDB_SYNTAX_SAMBA_SID
1539         },{
1540                 .name                   = "String(Object-Identifier)",
1541                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.38",
1542                 .oMSyntax               = 6,
1543                 .attributeSyntax_oid    = "2.5.5.2",
1544                 .drsuapi_to_ldb         = dsdb_syntax_OID_drsuapi_to_ldb,
1545                 .ldb_to_drsuapi         = dsdb_syntax_OID_ldb_to_drsuapi,
1546                 .equality               = "caseIgnoreMatch", /* Would use "objectIdentifierMatch" but most are ldap attribute/class names */
1547                 .comment                = "OID String",
1548                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING
1549         },{
1550                 .name                   = "Enumeration",
1551                 .ldap_oid               = LDB_SYNTAX_INTEGER,
1552                 .oMSyntax               = 10,
1553                 .attributeSyntax_oid    = "2.5.5.9",
1554                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
1555                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
1556                 .ldb_syntax             = LDB_SYNTAX_SAMBA_INT32
1557         },{
1558         /* not used in w2k3 forest */
1559                 .name                   = "String(Numeric)",
1560                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.36",
1561                 .oMSyntax               = 18,
1562                 .attributeSyntax_oid    = "2.5.5.6",
1563                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1564                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1565                 .equality               = "numericStringMatch",
1566                 .substring              = "numericStringSubstringsMatch",
1567                 .comment                = "Numeric String",
1568                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING,
1569         },{
1570                 .name                   = "String(Printable)",
1571                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.44",
1572                 .oMSyntax               = 19,
1573                 .attributeSyntax_oid    = "2.5.5.5",
1574                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1575                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1576                 .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
1577         },{
1578                 .name                   = "String(Teletex)",
1579                 .ldap_oid               = "1.2.840.113556.1.4.905",
1580                 .oMSyntax               = 20,
1581                 .attributeSyntax_oid    = "2.5.5.4",
1582                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1583                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1584                 .equality               = "caseIgnoreMatch",
1585                 .substring              = "caseIgnoreSubstringsMatch",
1586                 .comment                = "Case Insensitive String",
1587                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING,
1588         },{
1589                 .name                   = "String(IA5)",
1590                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.26",
1591                 .oMSyntax               = 22,
1592                 .attributeSyntax_oid    = "2.5.5.5",
1593                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1594                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1595                 .equality               = "caseExactIA5Match",
1596                 .comment                = "Printable String",
1597                 .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
1598         },{
1599                 .name                   = "String(UTC-Time)",
1600                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.53",
1601                 .oMSyntax               = 23,
1602                 .attributeSyntax_oid    = "2.5.5.11",
1603                 .drsuapi_to_ldb         = dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb,
1604                 .ldb_to_drsuapi         = dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi,
1605                 .equality               = "generalizedTimeMatch",
1606                 .comment                = "UTC Time",
1607         },{
1608                 .name                   = "String(Generalized-Time)",
1609                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.24",
1610                 .oMSyntax               = 24,
1611                 .attributeSyntax_oid    = "2.5.5.11",
1612                 .drsuapi_to_ldb         = dsdb_syntax_NTTIME_drsuapi_to_ldb,
1613                 .ldb_to_drsuapi         = dsdb_syntax_NTTIME_ldb_to_drsuapi,
1614                 .equality               = "generalizedTimeMatch",
1615                 .comment                = "Generalized Time",
1616                 .ldb_syntax             = LDB_SYNTAX_UTC_TIME,
1617         },{
1618         /* not used in w2k3 schema */
1619                 .name                   = "String(Case Sensitive)",
1620                 .ldap_oid               = "1.2.840.113556.1.4.1362",
1621                 .oMSyntax               = 27,
1622                 .attributeSyntax_oid    = "2.5.5.3",
1623                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1624                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1625         },{
1626                 .name                   = "String(Unicode)",
1627                 .ldap_oid               = LDB_SYNTAX_DIRECTORY_STRING,
1628                 .oMSyntax               = 64,
1629                 .attributeSyntax_oid    = "2.5.5.12",
1630                 .drsuapi_to_ldb         = dsdb_syntax_UNICODE_drsuapi_to_ldb,
1631                 .ldb_to_drsuapi         = dsdb_syntax_UNICODE_ldb_to_drsuapi,
1632                 .equality               = "caseIgnoreMatch",
1633                 .substring              = "caseIgnoreSubstringsMatch",
1634                 .comment                = "Directory String",
1635         },{
1636                 .name                   = "Interval/LargeInteger",
1637                 .ldap_oid               = "1.2.840.113556.1.4.906",
1638                 .oMSyntax               = 65,
1639                 .attributeSyntax_oid    = "2.5.5.16",
1640                 .drsuapi_to_ldb         = dsdb_syntax_INT64_drsuapi_to_ldb,
1641                 .ldb_to_drsuapi         = dsdb_syntax_INT64_ldb_to_drsuapi,
1642                 .equality               = "integerMatch",
1643                 .comment                = "Large Integer",
1644                 .ldb_syntax             = LDB_SYNTAX_INTEGER,
1645         },{
1646                 .name                   = "String(NT-Sec-Desc)",
1647                 .ldap_oid               = LDB_SYNTAX_SAMBA_SECURITY_DESCRIPTOR,
1648                 .oMSyntax               = 66,
1649                 .attributeSyntax_oid    = "2.5.5.15",
1650                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1651                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1652         },{
1653                 .name                   = "Object(DS-DN)",
1654                 .ldap_oid               = LDB_SYNTAX_DN,
1655                 .oMSyntax               = 127,
1656                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x4a"),
1657                 .attributeSyntax_oid    = "2.5.5.1",
1658                 .drsuapi_to_ldb         = dsdb_syntax_DN_drsuapi_to_ldb,
1659                 .ldb_to_drsuapi         = dsdb_syntax_DN_ldb_to_drsuapi,
1660                 .equality               = "distinguishedNameMatch",
1661                 .comment                = "Object(DS-DN) == a DN",
1662         },{
1663                 .name                   = "Object(DN-Binary)",
1664                 .ldap_oid               = "1.2.840.113556.1.4.903",
1665                 .oMSyntax               = 127,
1666                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0b"),
1667                 .attributeSyntax_oid    = "2.5.5.7",
1668                 .drsuapi_to_ldb         = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
1669                 .ldb_to_drsuapi         = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
1670                 .equality               = "octetStringMatch",
1671                 .comment                = "OctetString: Binary+DN",
1672                 .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
1673         },{
1674         /* not used in w2k3 schema */
1675                 .name                   = "Object(OR-Name)",
1676                 .ldap_oid               = "1.2.840.113556.1.4.1221",
1677                 .oMSyntax               = 127,
1678                 .oMObjectClass          = OMOBJECTCLASS("\x56\x06\x01\x02\x05\x0b\x1D"),
1679                 .attributeSyntax_oid    = "2.5.5.7",
1680                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1681                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1682         },{
1683         /*
1684          * TODO: verify if DATA_BLOB is correct here...!
1685          *
1686          *       repsFrom and repsTo are the only attributes using
1687          *       this attribute syntax, but they're not replicated...
1688          */
1689                 .name                   = "Object(Replica-Link)",
1690                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.40",
1691                 .oMSyntax               = 127,
1692                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x06"),
1693                 .attributeSyntax_oid    = "2.5.5.10",
1694                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1695                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1696         },{
1697                 .name                   = "Object(Presentation-Address)",
1698                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.43",
1699                 .oMSyntax               = 127,
1700                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x5c"),
1701                 .attributeSyntax_oid    = "2.5.5.13",
1702                 .drsuapi_to_ldb         = dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb,
1703                 .ldb_to_drsuapi         = dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi,
1704                 .comment                = "Presentation Address",
1705                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING,
1706         },{
1707         /* not used in w2k3 schema */
1708                 .name                   = "Object(Access-Point)",
1709                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.2",
1710                 .oMSyntax               = 127,
1711                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x3e"),
1712                 .attributeSyntax_oid    = "2.5.5.14",
1713                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1714                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1715                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING,
1716         },{
1717         /* not used in w2k3 schema */
1718                 .name                   = "Object(DN-String)",
1719                 .ldap_oid               = "1.2.840.113556.1.4.904",
1720                 .oMSyntax               = 127,
1721                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0c"),
1722                 .attributeSyntax_oid    = "2.5.5.14",
1723                 .drsuapi_to_ldb         = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
1724                 .ldb_to_drsuapi         = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
1725                 .equality               = "octetStringMatch",
1726                 .comment                = "OctetString: String+DN",
1727                 .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
1728         }
1729 };
1730
1731 const struct dsdb_syntax *find_syntax_map_by_ad_oid(const char *ad_oid)
1732 {
1733         int i;
1734         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
1735                 if (strcasecmp(ad_oid, dsdb_syntaxes[i].attributeSyntax_oid) == 0) {
1736                         return &dsdb_syntaxes[i];
1737                 }
1738         }
1739         return NULL;
1740 }
1741
1742 const struct dsdb_syntax *find_syntax_map_by_ad_syntax(int oMSyntax)
1743 {
1744         int i;
1745         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
1746                 if (oMSyntax == dsdb_syntaxes[i].oMSyntax) {
1747                         return &dsdb_syntaxes[i];
1748                 }
1749         }
1750         return NULL;
1751 }
1752
1753 const struct dsdb_syntax *find_syntax_map_by_standard_oid(const char *standard_oid)
1754 {
1755         int i;
1756         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
1757                 if (strcasecmp(standard_oid, dsdb_syntaxes[i].ldap_oid) == 0) {
1758                         return &dsdb_syntaxes[i];
1759                 }
1760         }
1761         return NULL;
1762 }
1763 const struct dsdb_syntax *dsdb_syntax_for_attribute(const struct dsdb_attribute *attr)
1764 {
1765         uint32_t i;
1766
1767         for (i=0; i < ARRAY_SIZE(dsdb_syntaxes); i++) {
1768                 if (attr->oMSyntax != dsdb_syntaxes[i].oMSyntax) continue;
1769
1770                 if (attr->oMObjectClass.length != dsdb_syntaxes[i].oMObjectClass.length) continue;
1771
1772                 if (attr->oMObjectClass.length) {
1773                         int ret;
1774                         ret = memcmp(attr->oMObjectClass.data,
1775                                      dsdb_syntaxes[i].oMObjectClass.data,
1776                                      attr->oMObjectClass.length);
1777                         if (ret != 0) continue;
1778                 }
1779
1780                 if (strcmp(attr->attributeSyntax_oid, dsdb_syntaxes[i].attributeSyntax_oid) != 0) continue;
1781
1782                 return &dsdb_syntaxes[i];
1783         }
1784
1785         return NULL;
1786 }
1787
1788 WERROR dsdb_attribute_drsuapi_to_ldb(struct ldb_context *ldb,
1789                                      const struct dsdb_schema *schema,
1790                                      const struct drsuapi_DsReplicaAttribute *in,
1791                                      TALLOC_CTX *mem_ctx,
1792                                      struct ldb_message_element *out)
1793 {
1794         const struct dsdb_attribute *sa;
1795
1796         sa = dsdb_attribute_by_attributeID_id(schema, in->attid);
1797         if (!sa) {
1798                 return WERR_FOOBAR;
1799         }
1800
1801         return sa->syntax->drsuapi_to_ldb(ldb, schema, sa, in, mem_ctx, out);
1802 }
1803
1804 WERROR dsdb_attribute_ldb_to_drsuapi(struct ldb_context *ldb,
1805                                      const struct dsdb_schema *schema,
1806                                      const struct ldb_message_element *in,
1807                                      TALLOC_CTX *mem_ctx,
1808                                      struct drsuapi_DsReplicaAttribute *out)
1809 {
1810         const struct dsdb_attribute *sa;
1811
1812         sa = dsdb_attribute_by_lDAPDisplayName(schema, in->name);
1813         if (!sa) {
1814                 return WERR_FOOBAR;
1815         }
1816
1817         return sa->syntax->ldb_to_drsuapi(ldb, schema, sa, in, mem_ctx, out);
1818 }