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                 v = strtol((const char *)in->values[i].data, NULL, 10);
 238
 239                 SIVALS(blobs[i].data, 0, v);
 240         }
 241
 242         return WERR_OK;
 243 }
 244
 245 static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(struct ldb_context *ldb,
 246                                                const struct dsdb_schema *schema,
 247                                                const struct dsdb_attribute *attr,
 248                                                const struct drsuapi_DsReplicaAttribute *in,
 249                                                TALLOC_CTX *mem_ctx,
 250                                                struct ldb_message_element *out)
 251 {
 252         uint32_t i;
 253
 254         out->flags      = 0;
 255         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 256         W_ERROR_HAVE_NO_MEMORY(out->name);
 257
 258         out->num_values = in->value_ctr.num_values;
 259         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 260         W_ERROR_HAVE_NO_MEMORY(out->values);
 261
 262         for (i=0; i < out->num_values; i++) {
 263                 int64_t v;
 264                 char *str;
 265
 266                 if (in->value_ctr.values[i].blob == NULL) {
 267                         return WERR_FOOBAR;
 268                 }
 269
 270                 if (in->value_ctr.values[i].blob->length != 8) {
 271                         return WERR_FOOBAR;
 272                 }
 273
 274                 v = BVALS(in->value_ctr.values[i].blob->data, 0);
 275
 276                 str = talloc_asprintf(out->values, "%lld", (long long int)v);
 277                 W_ERROR_HAVE_NO_MEMORY(str);
 278
 279                 out->values[i] = data_blob_string_const(str);
 280         }
 281
 282         return WERR_OK;
 283 }
 284
 285 static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(struct ldb_context *ldb,
 286                                                const struct dsdb_schema *schema,
 287                                                const struct dsdb_attribute *attr,
 288                                                const struct ldb_message_element *in,
 289                                                TALLOC_CTX *mem_ctx,
 290                                                struct drsuapi_DsReplicaAttribute *out)
 291 {
 292         uint32_t i;
 293         DATA_BLOB *blobs;
 294
 295         if (attr->attributeID_id == 0xFFFFFFFF) {
 296                 return WERR_FOOBAR;
 297         }
 298
 299         out->attid                      = attr->attributeID_id;
 300         out->value_ctr.num_values       = in->num_values;
 301         out->value_ctr.values           = talloc_array(mem_ctx,
 302                                                        struct drsuapi_DsAttributeValue,
 303                                                        in->num_values);
 304         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 305
 306         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 307         W_ERROR_HAVE_NO_MEMORY(blobs);
 308
 309         for (i=0; i < in->num_values; i++) {
 310                 int64_t v;
 311
 312                 out->value_ctr.values[i].blob   = &blobs[i];
 313
 314                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 315                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 316
 317                 v = strtoll((const char *)in->values[i].data, NULL, 10);
 318
 319                 SBVALS(blobs[i].data, 0, v);
 320         }
 321
 322         return WERR_OK;
 323 }
 324
 325 static WERROR dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb(struct ldb_context *ldb,
 326                                                     const struct dsdb_schema *schema,
 327                                                     const struct dsdb_attribute *attr,
 328                                                     const struct drsuapi_DsReplicaAttribute *in,
 329                                                     TALLOC_CTX *mem_ctx,
 330                                                     struct ldb_message_element *out)
 331 {
 332         uint32_t i;
 333
 334         out->flags      = 0;
 335         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 336         W_ERROR_HAVE_NO_MEMORY(out->name);
 337
 338         out->num_values = in->value_ctr.num_values;
 339         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 340         W_ERROR_HAVE_NO_MEMORY(out->values);
 341
 342         for (i=0; i < out->num_values; i++) {
 343                 NTTIME v;
 344                 time_t t;
 345                 char *str;
 346
 347                 if (in->value_ctr.values[i].blob == NULL) {
 348                         return WERR_FOOBAR;
 349                 }
 350
 351                 if (in->value_ctr.values[i].blob->length != 8) {
 352                         return WERR_FOOBAR;
 353                 }
 354
 355                 v = BVAL(in->value_ctr.values[i].blob->data, 0);
 356                 v *= 10000000;
 357                 t = nt_time_to_unix(v);
 358
 359                 /*
 360                  * NOTE: On a w2k3 server you can set a GeneralizedTime string
 361                  *       via LDAP, but you get back an UTCTime string,
 362                  *       but via DRSUAPI you get back the NTTIME_1sec value
 363                  *       that represents the GeneralizedTime value!
 364                  *
 365                  *       So if we store the UTCTime string in our ldb
 366                  *       we'll loose information!
 367                  */
 368                 str = ldb_timestring_utc(out->values, t);
 369                 W_ERROR_HAVE_NO_MEMORY(str);
 370                 out->values[i] = data_blob_string_const(str);
 371         }
 372
 373         return WERR_OK;
 374 }
 375
 376 static WERROR dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi(struct ldb_context *ldb,
 377                                                     const struct dsdb_schema *schema,
 378                                                     const struct dsdb_attribute *attr,
 379                                                     const struct ldb_message_element *in,
 380                                                     TALLOC_CTX *mem_ctx,
 381                                                     struct drsuapi_DsReplicaAttribute *out)
 382 {
 383         uint32_t i;
 384         DATA_BLOB *blobs;
 385
 386         if (attr->attributeID_id == 0xFFFFFFFF) {
 387                 return WERR_FOOBAR;
 388         }
 389
 390         out->attid                      = attr->attributeID_id;
 391         out->value_ctr.num_values       = in->num_values;
 392         out->value_ctr.values           = talloc_array(mem_ctx,
 393                                                        struct drsuapi_DsAttributeValue,
 394                                                        in->num_values);
 395         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 396
 397         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 398         W_ERROR_HAVE_NO_MEMORY(blobs);
 399
 400         for (i=0; i < in->num_values; i++) {
 401                 NTTIME v;
 402                 time_t t;
 403
 404                 out->value_ctr.values[i].blob   = &blobs[i];
 405
 406                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 407                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 408
 409                 t = ldb_string_utc_to_time((const char *)in->values[i].data);
 410                 unix_to_nt_time(&v, t);
 411                 v /= 10000000;
 412
 413                 SBVAL(blobs[i].data, 0, v);
 414         }
 415
 416         return WERR_OK;
 417 }
 418
 419 static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(struct ldb_context *ldb,
 420                                                 const struct dsdb_schema *schema,
 421                                                 const struct dsdb_attribute *attr,
 422                                                 const struct drsuapi_DsReplicaAttribute *in,
 423                                                 TALLOC_CTX *mem_ctx,
 424                                                 struct ldb_message_element *out)
 425 {
 426         uint32_t i;
 427
 428         out->flags      = 0;
 429         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 430         W_ERROR_HAVE_NO_MEMORY(out->name);
 431
 432         out->num_values = in->value_ctr.num_values;
 433         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 434         W_ERROR_HAVE_NO_MEMORY(out->values);
 435
 436         for (i=0; i < out->num_values; i++) {
 437                 NTTIME v;
 438                 time_t t;
 439                 char *str;
 440
 441                 if (in->value_ctr.values[i].blob == NULL) {
 442                         return WERR_FOOBAR;
 443                 }
 444
 445                 if (in->value_ctr.values[i].blob->length != 8) {
 446                         return WERR_FOOBAR;
 447                 }
 448
 449                 v = BVAL(in->value_ctr.values[i].blob->data, 0);
 450                 v *= 10000000;
 451                 t = nt_time_to_unix(v);
 452
 453                 str = ldb_timestring(out->values, t);
 454                 W_ERROR_HAVE_NO_MEMORY(str);
 455
 456                 out->values[i] = data_blob_string_const(str);
 457         }
 458
 459         return WERR_OK;
 460 }
 461
 462 static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(struct ldb_context *ldb,
 463                                                 const struct dsdb_schema *schema,
 464                                                 const struct dsdb_attribute *attr,
 465                                                 const struct ldb_message_element *in,
 466                                                 TALLOC_CTX *mem_ctx,
 467                                                 struct drsuapi_DsReplicaAttribute *out)
 468 {
 469         uint32_t i;
 470         DATA_BLOB *blobs;
 471
 472         if (attr->attributeID_id == 0xFFFFFFFF) {
 473                 return WERR_FOOBAR;
 474         }
 475
 476         out->attid                      = attr->attributeID_id;
 477         out->value_ctr.num_values       = in->num_values;
 478         out->value_ctr.values           = talloc_array(mem_ctx,
 479                                                        struct drsuapi_DsAttributeValue,
 480                                                        in->num_values);
 481         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 482
 483         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 484         W_ERROR_HAVE_NO_MEMORY(blobs);
 485
 486         for (i=0; i < in->num_values; i++) {
 487                 NTTIME v;
 488                 time_t t;
 489
 490                 out->value_ctr.values[i].blob   = &blobs[i];
 491
 492                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 493                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 494
 495                 t = ldb_string_to_time((const char *)in->values[i].data);
 496                 unix_to_nt_time(&v, t);
 497                 v /= 10000000;
 498
 499                 SBVAL(blobs[i].data, 0, v);
 500         }
 501
 502         return WERR_OK;
 503 }
 504
 505 static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(struct ldb_context *ldb,
 506                                                    const struct dsdb_schema *schema,
 507                                                    const struct dsdb_attribute *attr,
 508                                                    const struct drsuapi_DsReplicaAttribute *in,
 509                                                    TALLOC_CTX *mem_ctx,
 510                                                    struct ldb_message_element *out)
 511 {
 512         uint32_t i;
 513
 514         out->flags      = 0;
 515         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 516         W_ERROR_HAVE_NO_MEMORY(out->name);
 517
 518         out->num_values = in->value_ctr.num_values;
 519         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 520         W_ERROR_HAVE_NO_MEMORY(out->values);
 521
 522         for (i=0; i < out->num_values; i++) {
 523                 if (in->value_ctr.values[i].blob == NULL) {
 524                         return WERR_FOOBAR;
 525                 }
 526
 527                 if (in->value_ctr.values[i].blob->length == 0) {
 528                         return WERR_FOOBAR;
 529                 }
 530
 531                 out->values[i] = data_blob_dup_talloc(out->values,
 532                                                       in->value_ctr.values[i].blob);
 533                 W_ERROR_HAVE_NO_MEMORY(out->values[i].data);
 534         }
 535
 536         return WERR_OK;
 537 }
 538
 539 static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(struct ldb_context *ldb,
 540                                                    const struct dsdb_schema *schema,
 541                                                    const struct dsdb_attribute *attr,
 542                                                    const struct ldb_message_element *in,
 543                                                    TALLOC_CTX *mem_ctx,
 544                                                    struct drsuapi_DsReplicaAttribute *out)
 545 {
 546         uint32_t i;
 547         DATA_BLOB *blobs;
 548
 549         if (attr->attributeID_id == 0xFFFFFFFF) {
 550                 return WERR_FOOBAR;
 551         }
 552
 553         out->attid                      = attr->attributeID_id;
 554         out->value_ctr.num_values       = in->num_values;
 555         out->value_ctr.values           = talloc_array(mem_ctx,
 556                                                        struct drsuapi_DsAttributeValue,
 557                                                        in->num_values);
 558         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 559
 560         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 561         W_ERROR_HAVE_NO_MEMORY(blobs);
 562
 563         for (i=0; i < in->num_values; i++) {
 564                 out->value_ctr.values[i].blob   = &blobs[i];
 565
 566                 blobs[i] = data_blob_dup_talloc(blobs, &in->values[i]);
 567                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 568         }
 569
 570         return WERR_OK;
 571 }
 572
 573 static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(struct ldb_context *ldb,
 574                                                   const struct dsdb_schema *schema,
 575                                                   const struct dsdb_attribute *attr,
 576                                                   const struct drsuapi_DsReplicaAttribute *in,
 577                                                   TALLOC_CTX *mem_ctx,
 578                                                   struct ldb_message_element *out)
 579 {
 580         uint32_t i;
 581
 582         out->flags      = 0;
 583         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 584         W_ERROR_HAVE_NO_MEMORY(out->name);
 585
 586         out->num_values = in->value_ctr.num_values;
 587         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 588         W_ERROR_HAVE_NO_MEMORY(out->values);
 589
 590         for (i=0; i < out->num_values; i++) {
 591                 uint32_t v;
 592                 const struct dsdb_class *c;
 593                 const char *str;
 594
 595                 if (in->value_ctr.values[i].blob == NULL) {
 596                         return WERR_FOOBAR;
 597                 }
 598
 599                 if (in->value_ctr.values[i].blob->length != 4) {
 600                         return WERR_FOOBAR;
 601                 }
 602
 603                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 604
 605                 c = dsdb_class_by_governsID_id(schema, v);
 606                 if (!c) {
 607                         return WERR_FOOBAR;
 608                 }
 609
 610                 str = talloc_strdup(out->values, c->lDAPDisplayName);
 611                 W_ERROR_HAVE_NO_MEMORY(str);
 612
 613                 /* the values need to be reversed */
 614                 out->values[out->num_values - (i + 1)] = data_blob_string_const(str);
 615         }
 616
 617         return WERR_OK;
 618 }
 619
 620 static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(struct ldb_context *ldb,
 621                                                   const struct dsdb_schema *schema,
 622                                                   const struct dsdb_attribute *attr,
 623                                                   const struct drsuapi_DsReplicaAttribute *in,
 624                                                   TALLOC_CTX *mem_ctx,
 625                                                   struct ldb_message_element *out)
 626 {
 627         uint32_t i;
 628
 629         out->flags      = 0;
 630         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 631         W_ERROR_HAVE_NO_MEMORY(out->name);
 632
 633         out->num_values = in->value_ctr.num_values;
 634         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 635         W_ERROR_HAVE_NO_MEMORY(out->values);
 636
 637         for (i=0; i < out->num_values; i++) {
 638                 uint32_t v;
 639                 WERROR status;
 640                 const char *str;
 641
 642                 if (in->value_ctr.values[i].blob == NULL) {
 643                         return WERR_FOOBAR;
 644                 }
 645
 646                 if (in->value_ctr.values[i].blob->length != 4) {
 647                         return WERR_FOOBAR;
 648                 }
 649
 650                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 651
 652                 status = dsdb_map_int2oid(schema, v, out->values, &str);
 653                 W_ERROR_NOT_OK_RETURN(status);
 654
 655                 out->values[i] = data_blob_string_const(str);
 656         }
 657
 658         return WERR_OK;
 659 }
 660
 661 static WERROR dsdb_syntax_OID_drsuapi_to_ldb(struct ldb_context *ldb,
 662                                              const struct dsdb_schema *schema,
 663                                              const struct dsdb_attribute *attr,
 664                                              const struct drsuapi_DsReplicaAttribute *in,
 665                                              TALLOC_CTX *mem_ctx,
 666                                              struct ldb_message_element *out)
 667 {
 668         uint32_t i;
 669
 670         switch (attr->attributeID_id) {
 671         case DRSUAPI_ATTRIBUTE_objectClass:
 672                 return _dsdb_syntax_OID_obj_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
 673         case DRSUAPI_ATTRIBUTE_governsID:
 674         case DRSUAPI_ATTRIBUTE_attributeID:
 675         case DRSUAPI_ATTRIBUTE_attributeSyntax:
 676                 return _dsdb_syntax_OID_oid_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
 677         }
 678
 679         out->flags      = 0;
 680         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 681         W_ERROR_HAVE_NO_MEMORY(out->name);
 682
 683         out->num_values = in->value_ctr.num_values;
 684         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 685         W_ERROR_HAVE_NO_MEMORY(out->values);
 686
 687         for (i=0; i < out->num_values; i++) {
 688                 uint32_t v;
 689                 const char *name;
 690                 char *str;
 691
 692                 if (in->value_ctr.values[i].blob == NULL) {
 693                         return WERR_FOOBAR;
 694                 }
 695
 696                 if (in->value_ctr.values[i].blob->length != 4) {
 697                         return WERR_FOOBAR;
 698                 }
 699
 700                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 701
 702                 name = dsdb_lDAPDisplayName_by_id(schema, v);
 703                 if (!name) {
 704                         return WERR_FOOBAR;
 705                 }
 706
 707                 str = talloc_strdup(out->values, name);
 708                 W_ERROR_HAVE_NO_MEMORY(str);
 709
 710                 out->values[i] = data_blob_string_const(str);
 711         }
 712
 713         return WERR_OK;
 714 }
 715
 716 static WERROR dsdb_syntax_OID_ldb_to_drsuapi(struct ldb_context *ldb,
 717                                              const struct dsdb_schema *schema,
 718                                              const struct dsdb_attribute *attr,
 719                                              const struct ldb_message_element *in,
 720                                              TALLOC_CTX *mem_ctx,
 721                                              struct drsuapi_DsReplicaAttribute *out)
 722 {
 723         uint32_t i;
 724         DATA_BLOB *blobs;
 725
 726         if (attr->attributeID_id == 0xFFFFFFFF) {
 727                 return WERR_FOOBAR;
 728         }
 729
 730         switch (attr->attributeID_id) {
 731         case DRSUAPI_ATTRIBUTE_objectClass:
 732         case DRSUAPI_ATTRIBUTE_governsID:
 733         case DRSUAPI_ATTRIBUTE_attributeID:
 734         case DRSUAPI_ATTRIBUTE_attributeSyntax:
 735                 return dsdb_syntax_FOOBAR_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out);
 736         }
 737
 738         out->attid                      = attr->attributeID_id;
 739         out->value_ctr.num_values       = in->num_values;
 740         out->value_ctr.values           = talloc_array(mem_ctx,
 741                                                        struct drsuapi_DsAttributeValue,
 742                                                        in->num_values);
 743         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 744
 745         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 746         W_ERROR_HAVE_NO_MEMORY(blobs);
 747
 748         for (i=0; i < in->num_values; i++) {
 749                 uint32_t v;
 750
 751                 out->value_ctr.values[i].blob   = &blobs[i];
 752
 753                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 754                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 755
 756                 v = strtol((const char *)in->values[i].data, NULL, 10);
 757
 758                 SIVAL(blobs[i].data, 0, v);
 759         }
 760
 761         return WERR_OK;
 762 }
 763
 764 static WERROR dsdb_syntax_UNICODE_drsuapi_to_ldb(struct ldb_context *ldb,
 765                                                  const struct dsdb_schema *schema,
 766                                                  const struct dsdb_attribute *attr,
 767                                                  const struct drsuapi_DsReplicaAttribute *in,
 768                                                  TALLOC_CTX *mem_ctx,
 769                                                  struct ldb_message_element *out)
 770 {
 771         uint32_t i;
 772
 773         out->flags      = 0;
 774         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 775         W_ERROR_HAVE_NO_MEMORY(out->name);
 776
 777         out->num_values = in->value_ctr.num_values;
 778         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 779         W_ERROR_HAVE_NO_MEMORY(out->values);
 780
 781         for (i=0; i < out->num_values; i++) {
 782                 ssize_t ret;
 783                 char *str;
 784
 785                 if (in->value_ctr.values[i].blob == NULL) {
 786                         return WERR_FOOBAR;
 787                 }
 788
 789                 if (in->value_ctr.values[i].blob->length == 0) {
 790                         return WERR_FOOBAR;
 791                 }
 792
 793                 ret = convert_string_talloc_convenience(out->values,
 794                                                 schema->iconv_convenience,
 795                                                                         CH_UTF16, CH_UNIX,
 796                                             in->value_ctr.values[i].blob->data,
 797                                             in->value_ctr.values[i].blob->length,
 798                                             (void **)&str);
 799                 if (ret == -1) {
 800                         return WERR_FOOBAR;
 801                 }
 802
 803                 out->values[i] = data_blob_string_const(str);
 804         }
 805
 806         return WERR_OK;
 807 }
 808
 809 static WERROR dsdb_syntax_UNICODE_ldb_to_drsuapi(struct ldb_context *ldb,
 810                                                  const struct dsdb_schema *schema,
 811                                                  const struct dsdb_attribute *attr,
 812                                                  const struct ldb_message_element *in,
 813                                                  TALLOC_CTX *mem_ctx,
 814                                                  struct drsuapi_DsReplicaAttribute *out)
 815 {
 816         uint32_t i;
 817         DATA_BLOB *blobs;
 818
 819         if (attr->attributeID_id == 0xFFFFFFFF) {
 820                 return WERR_FOOBAR;
 821         }
 822
 823         out->attid                      = attr->attributeID_id;
 824         out->value_ctr.num_values       = in->num_values;
 825         out->value_ctr.values           = talloc_array(mem_ctx,
 826                                                        struct drsuapi_DsAttributeValue,
 827                                                        in->num_values);
 828         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 829
 830         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 831         W_ERROR_HAVE_NO_MEMORY(blobs);
 832
 833         for (i=0; i < in->num_values; i++) {
 834                 ssize_t ret;
 835
 836                 out->value_ctr.values[i].blob   = &blobs[i];
 837
 838                 ret = convert_string_talloc_convenience(blobs, schema->iconv_convenience, CH_UNIX, CH_UTF16,
 839                                             in->values[i].data,
 840                                             in->values[i].length,
 841                                             (void **)&blobs[i].data);
 842                 if (ret == -1) {
 843                         return WERR_FOOBAR;
 844                 }
 845                 blobs[i].length = ret;
 846         }
 847
 848         return WERR_OK;
 849 }
 850
 851 static WERROR dsdb_syntax_DN_drsuapi_to_ldb(struct ldb_context *ldb,
 852                                             const struct dsdb_schema *schema,
 853                                             const struct dsdb_attribute *attr,
 854                                             const struct drsuapi_DsReplicaAttribute *in,
 855                                             TALLOC_CTX *mem_ctx,
 856                                             struct ldb_message_element *out)
 857 {
 858         uint32_t i;
 859         int ret;
 860
 861         out->flags      = 0;
 862         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 863         W_ERROR_HAVE_NO_MEMORY(out->name);
 864
 865         out->num_values = in->value_ctr.num_values;
 866         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 867         W_ERROR_HAVE_NO_MEMORY(out->values);
 868
 869         for (i=0; i < out->num_values; i++) {
 870                 struct drsuapi_DsReplicaObjectIdentifier3 id3;
 871                 enum ndr_err_code ndr_err;
 872                 DATA_BLOB guid_blob;
 873                 struct ldb_dn *dn;
 874                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 875                 if (!tmp_ctx) {
 876                         W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
 877                 }
 878
 879                 if (in->value_ctr.values[i].blob == NULL) {
 880                         talloc_free(tmp_ctx);
 881                         return WERR_FOOBAR;
 882                 }
 883
 884                 if (in->value_ctr.values[i].blob->length == 0) {
 885                         talloc_free(tmp_ctx);
 886                         return WERR_FOOBAR;
 887                 }
 888
 889
 890
 891                 ndr_err = ndr_pull_struct_blob_all(in->value_ctr.values[i].blob,
 892                                                    tmp_ctx, schema->iconv_convenience, &id3,
 893                                                    (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
 894                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 895                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
 896                         talloc_free(tmp_ctx);
 897                         return ntstatus_to_werror(status);
 898                 }
 899
 900                 dn = ldb_dn_new(tmp_ctx, ldb, id3.dn);
 901                 if (!dn) {
 902                         talloc_free(tmp_ctx);
 903                         /* If this fails, it must be out of memory, as it does not do much parsing */
 904                         W_ERROR_HAVE_NO_MEMORY(dn);
 905                 }
 906
 907                 ndr_err = ndr_push_struct_blob(&guid_blob, tmp_ctx, schema->iconv_convenience, &id3.guid,
 908                                                (ndr_push_flags_fn_t)ndr_push_GUID);
 909                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 910                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
 911                         talloc_free(tmp_ctx);
 912                         return ntstatus_to_werror(status);
 913                 }
 914
 915                 ret = ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
 916                 if (ret != LDB_SUCCESS) {
 917                         talloc_free(tmp_ctx);
 918                         return WERR_FOOBAR;
 919                 }
 920
 921                 talloc_free(guid_blob.data);
 922
 923                 if (id3.__ndr_size_sid) {
 924                         DATA_BLOB sid_blob;
 925                         ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, schema->iconv_convenience, &id3.sid,
 926                                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
 927                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 928                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
 929                                 talloc_free(tmp_ctx);
 930                                 return ntstatus_to_werror(status);
 931                         }
 932
 933                         ret = ldb_dn_set_extended_component(dn, "SID", &sid_blob);
 934                         if (ret != LDB_SUCCESS) {
 935                                 talloc_free(tmp_ctx);
 936                                 return WERR_FOOBAR;
 937                         }
 938                 }
 939
 940                 out->values[i] = data_blob_string_const(ldb_dn_get_extended_linearized(out->values, dn, 1));
 941                 talloc_free(tmp_ctx);
 942         }
 943
 944         return WERR_OK;
 945 }
 946
 947 static WERROR dsdb_syntax_DN_ldb_to_drsuapi(struct ldb_context *ldb,
 948                                             const struct dsdb_schema *schema,
 949                                             const struct dsdb_attribute *attr,
 950                                             const struct ldb_message_element *in,
 951                                             TALLOC_CTX *mem_ctx,
 952                                             struct drsuapi_DsReplicaAttribute *out)
 953 {
 954         uint32_t i;
 955         DATA_BLOB *blobs;
 956
 957         if (attr->attributeID_id == 0xFFFFFFFF) {
 958                 return WERR_FOOBAR;
 959         }
 960
 961         out->attid                      = attr->attributeID_id;
 962         out->value_ctr.num_values       = in->num_values;
 963         out->value_ctr.values           = talloc_array(mem_ctx,
 964                                                        struct drsuapi_DsAttributeValue,
 965                                                        in->num_values);
 966         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
 967
 968         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 969         W_ERROR_HAVE_NO_MEMORY(blobs);
 970
 971         for (i=0; i < in->num_values; i++) {
 972                 struct drsuapi_DsReplicaObjectIdentifier3 id3;
 973                 enum ndr_err_code ndr_err;
 974                 const DATA_BLOB *guid_blob, *sid_blob;
 975                 struct ldb_dn *dn;
 976                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 977                 W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
 978
 979                 out->value_ctr.values[i].blob   = &blobs[i];
 980
 981                 dn = ldb_dn_from_ldb_val(tmp_ctx, ldb, &in->values[i]);
 982
 983                 W_ERROR_HAVE_NO_MEMORY(dn);
 984
 985                 guid_blob = ldb_dn_get_extended_component(dn, "GUID");
 986
 987                 ZERO_STRUCT(id3);
 988
 989                 if (guid_blob) {
 990                         ndr_err = ndr_pull_struct_blob_all(guid_blob,
 991                                                            tmp_ctx, schema->iconv_convenience, &id3.guid,
 992                                                            (ndr_pull_flags_fn_t)ndr_pull_GUID);
 993                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 994                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
 995                                 talloc_free(tmp_ctx);
 996                                 return ntstatus_to_werror(status);
 997                         }
 998                 }
 999
1000                 sid_blob = ldb_dn_get_extended_component(dn, "SID");
1001                 if (sid_blob) {
1002
1003                         ndr_err = ndr_pull_struct_blob_all(sid_blob,
1004                                                            tmp_ctx, schema->iconv_convenience, &id3.sid,
1005                                                            (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
1006                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1007                                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1008                                 talloc_free(tmp_ctx);
1009                                 return ntstatus_to_werror(status);
1010                         }
1011                 }
1012
1013                 id3.dn = ldb_dn_get_linearized(dn);
1014
1015                 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1016                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1017                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1018                         talloc_free(tmp_ctx);
1019                         return ntstatus_to_werror(status);
1020                 }
1021                 talloc_free(tmp_ctx);
1022         }
1023
1024         return WERR_OK;
1025 }
1026
1027 static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(struct ldb_context *ldb,
1028                                                    const struct dsdb_schema *schema,
1029                                                    const struct dsdb_attribute *attr,
1030                                                    const struct drsuapi_DsReplicaAttribute *in,
1031                                                    TALLOC_CTX *mem_ctx,
1032                                                    struct ldb_message_element *out)
1033 {
1034         uint32_t i;
1035
1036         out->flags      = 0;
1037         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
1038         W_ERROR_HAVE_NO_MEMORY(out->name);
1039
1040         out->num_values = in->value_ctr.num_values;
1041         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
1042         W_ERROR_HAVE_NO_MEMORY(out->values);
1043
1044         for (i=0; i < out->num_values; i++) {
1045                 struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
1046                 char *binary;
1047                 char *str;
1048                 enum ndr_err_code ndr_err;
1049
1050                 if (in->value_ctr.values[i].blob == NULL) {
1051                         return WERR_FOOBAR;
1052                 }
1053
1054                 if (in->value_ctr.values[i].blob->length == 0) {
1055                         return WERR_FOOBAR;
1056                 }
1057
1058                 ndr_err = ndr_pull_struct_blob_all(in->value_ctr.values[i].blob,
1059                                                    out->values, schema->iconv_convenience, &id3b,
1060                                                    (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
1061                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1062                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1063                         return ntstatus_to_werror(status);
1064                 }
1065
1066                 /* TODO: handle id3.guid and id3.sid */
1067                 binary = data_blob_hex_string(out->values, &id3b.binary);
1068                 W_ERROR_HAVE_NO_MEMORY(binary);
1069
1070                 str = talloc_asprintf(out->values, "B:%u:%s:%s",
1071                                       (unsigned int)(id3b.binary.length * 2), /* because of 2 hex chars per byte */
1072                                       binary,
1073                                       id3b.dn);
1074                 W_ERROR_HAVE_NO_MEMORY(str);
1075
1076                 /* TODO: handle id3.guid and id3.sid */
1077                 out->values[i] = data_blob_string_const(str);
1078         }
1079
1080         return WERR_OK;
1081 }
1082
1083 static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(struct ldb_context *ldb,
1084                                                    const struct dsdb_schema *schema,
1085                                                    const struct dsdb_attribute *attr,
1086                                                    const struct ldb_message_element *in,
1087                                                    TALLOC_CTX *mem_ctx,
1088                                                    struct drsuapi_DsReplicaAttribute *out)
1089 {
1090         uint32_t i;
1091         DATA_BLOB *blobs;
1092
1093         if (attr->attributeID_id == 0xFFFFFFFF) {
1094                 return WERR_FOOBAR;
1095         }
1096
1097         out->attid                      = attr->attributeID_id;
1098         out->value_ctr.num_values       = in->num_values;
1099         out->value_ctr.values           = talloc_array(mem_ctx,
1100                                                        struct drsuapi_DsAttributeValue,
1101                                                        in->num_values);
1102         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
1103
1104         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
1105         W_ERROR_HAVE_NO_MEMORY(blobs);
1106
1107         for (i=0; i < in->num_values; i++) {
1108                 struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
1109                 enum ndr_err_code ndr_err;
1110
1111                 out->value_ctr.values[i].blob   = &blobs[i];
1112
1113                 /* TODO: handle id3b.guid and id3b.sid, id3.binary */
1114                 ZERO_STRUCT(id3b);
1115                 id3b.dn         = (const char *)in->values[i].data;
1116                 id3b.binary     = data_blob(NULL, 0);
1117
1118                 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3b,
1119                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
1120                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1121                         NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
1122                         return ntstatus_to_werror(status);
1123                 }
1124         }
1125
1126         return WERR_OK;
1127 }
1128
1129 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb(struct ldb_context *ldb,
1130                                                               const struct dsdb_schema *schema,
1131                                                               const struct dsdb_attribute *attr,
1132                                                               const struct drsuapi_DsReplicaAttribute *in,
1133                                                               TALLOC_CTX *mem_ctx,
1134                                                               struct ldb_message_element *out)
1135 {
1136         uint32_t i;
1137
1138         out->flags      = 0;
1139         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
1140         W_ERROR_HAVE_NO_MEMORY(out->name);
1141
1142         out->num_values = in->value_ctr.num_values;
1143         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
1144         W_ERROR_HAVE_NO_MEMORY(out->values);
1145
1146         for (i=0; i < out->num_values; i++) {
1147                 uint32_t len;
1148                 ssize_t ret;
1149                 char *str;
1150
1151                 if (in->value_ctr.values[i].blob == NULL) {
1152                         return WERR_FOOBAR;
1153                 }
1154
1155                 if (in->value_ctr.values[i].blob->length < 4) {
1156                         return WERR_FOOBAR;
1157                 }
1158
1159                 len = IVAL(in->value_ctr.values[i].blob->data, 0);
1160
1161                 if (len != in->value_ctr.values[i].blob->length) {
1162                         return WERR_FOOBAR;
1163                 }
1164
1165                 ret = convert_string_talloc_convenience(out->values, schema->iconv_convenience, CH_UTF16, CH_UNIX,
1166                                             in->value_ctr.values[i].blob->data+4,
1167                                             in->value_ctr.values[i].blob->length-4,
1168                                             (void **)&str);
1169                 if (ret == -1) {
1170                         return WERR_FOOBAR;
1171                 }
1172
1173                 out->values[i] = data_blob_string_const(str);
1174         }
1175
1176         return WERR_OK;
1177 }
1178
1179 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi(struct ldb_context *ldb,
1180                                                               const struct dsdb_schema *schema,
1181                                                               const struct dsdb_attribute *attr,
1182                                                               const struct ldb_message_element *in,
1183                                                               TALLOC_CTX *mem_ctx,
1184                                                               struct drsuapi_DsReplicaAttribute *out)
1185 {
1186         uint32_t i;
1187         DATA_BLOB *blobs;
1188
1189         if (attr->attributeID_id == 0xFFFFFFFF) {
1190                 return WERR_FOOBAR;
1191         }
1192
1193         out->attid                      = attr->attributeID_id;
1194         out->value_ctr.num_values       = in->num_values;
1195         out->value_ctr.values           = talloc_array(mem_ctx,
1196                                                        struct drsuapi_DsAttributeValue,
1197                                                        in->num_values);
1198         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
1199
1200         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
1201         W_ERROR_HAVE_NO_MEMORY(blobs);
1202
1203         for (i=0; i < in->num_values; i++) {
1204                 uint8_t *data;
1205                 ssize_t ret;
1206
1207                 out->value_ctr.values[i].blob   = &blobs[i];
1208
1209                 ret = convert_string_talloc_convenience(blobs, schema->iconv_convenience, CH_UNIX, CH_UTF16,
1210                                             in->values[i].data,
1211                                             in->values[i].length,
1212                                             (void **)&data);
1213                 if (ret == -1) {
1214                         return WERR_FOOBAR;
1215                 }
1216
1217                 blobs[i] = data_blob_talloc(blobs, NULL, 4 + ret);
1218                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
1219
1220                 SIVAL(blobs[i].data, 0, 4 + ret);
1221
1222                 if (ret > 0) {
1223                         memcpy(blobs[i].data + 4, data, ret);
1224                         talloc_free(data);
1225                 }
1226         }
1227
1228         return WERR_OK;
1229 }
1230
1231 #define OMOBJECTCLASS(val) { .length = sizeof(val) - 1, .data = discard_const_p(uint8_t, val) }
1232
1233 static const struct dsdb_syntax dsdb_syntaxes[] = {
1234         {
1235                 .name                   = "Boolean",
1236                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.7",
1237                 .oMSyntax               = 1,
1238                 .attributeSyntax_oid    = "2.5.5.8",
1239                 .drsuapi_to_ldb         = dsdb_syntax_BOOL_drsuapi_to_ldb,
1240                 .ldb_to_drsuapi         = dsdb_syntax_BOOL_ldb_to_drsuapi,
1241                 .equality               = "booleanMatch",
1242                 .comment                = "Boolean"
1243         },{
1244                 .name                   = "Integer",
1245                 .ldap_oid               = LDB_SYNTAX_INTEGER,
1246                 .oMSyntax               = 2,
1247                 .attributeSyntax_oid    = "2.5.5.9",
1248                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
1249                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
1250                 .equality               = "integerMatch",
1251                 .comment                = "Integer",
1252         },{
1253                 .name                   = "String(Octet)",
1254                 .ldap_oid               = LDB_SYNTAX_OCTET_STRING,
1255                 .oMSyntax               = 4,
1256                 .attributeSyntax_oid    = "2.5.5.10",
1257                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1258                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1259                 .equality               = "octetStringMatch",
1260                 .comment                = "Octet String",
1261         },{
1262                 .name                   = "String(Sid)",
1263                 .ldap_oid               = LDB_SYNTAX_OCTET_STRING,
1264                 .oMSyntax               = 4,
1265                 .attributeSyntax_oid    = "2.5.5.17",
1266                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1267                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1268                 .equality               = "octetStringMatch",
1269                 .comment                = "Octet String - Security Identifier (SID)",
1270                 .ldb_syntax             = LDB_SYNTAX_SAMBA_SID
1271         },{
1272                 .name                   = "String(Object-Identifier)",
1273                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.38",
1274                 .oMSyntax               = 6,
1275                 .attributeSyntax_oid    = "2.5.5.2",
1276                 .drsuapi_to_ldb         = dsdb_syntax_OID_drsuapi_to_ldb,
1277                 .ldb_to_drsuapi         = dsdb_syntax_OID_ldb_to_drsuapi,
1278                 .equality               = "caseIgnoreMatch", /* Would use "objectIdentifierMatch" but most are ldap attribute/class names */
1279                 .comment                = "OID String",
1280                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING
1281         },{
1282                 .name                   = "Enumeration",
1283                 .ldap_oid               = LDB_SYNTAX_INTEGER,
1284                 .oMSyntax               = 10,
1285                 .attributeSyntax_oid    = "2.5.5.9",
1286                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
1287                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
1288         },{
1289         /* not used in w2k3 forest */
1290                 .name                   = "String(Numeric)",
1291                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.36",
1292                 .oMSyntax               = 18,
1293                 .attributeSyntax_oid    = "2.5.5.6",
1294                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1295                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1296                 .equality               = "numericStringMatch",
1297                 .substring              = "numericStringSubstringsMatch",
1298                 .comment                = "Numeric String"
1299         },{
1300                 .name                   = "String(Printable)",
1301                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.44",
1302                 .oMSyntax               = 19,
1303                 .attributeSyntax_oid    = "2.5.5.5",
1304                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1305                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1306         },{
1307                 .name                   = "String(Teletex)",
1308                 .ldap_oid               = "1.2.840.113556.1.4.905",
1309                 .oMSyntax               = 20,
1310                 .attributeSyntax_oid    = "2.5.5.4",
1311                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1312                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1313                 .equality               = "caseIgnoreMatch",
1314                 .substring              = "caseIgnoreSubstringsMatch",
1315                 .comment                = "Case Insensitive String",
1316                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING,
1317         },{
1318                 .name                   = "String(IA5)",
1319                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.26",
1320                 .oMSyntax               = 22,
1321                 .attributeSyntax_oid    = "2.5.5.5",
1322                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1323                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1324                 .equality               = "caseExactIA5Match",
1325                 .comment                = "Printable String"
1326         },{
1327                 .name                   = "String(UTC-Time)",
1328                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.53",
1329                 .oMSyntax               = 23,
1330                 .attributeSyntax_oid    = "2.5.5.11",
1331                 .drsuapi_to_ldb         = dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb,
1332                 .ldb_to_drsuapi         = dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi,
1333                 .equality               = "generalizedTimeMatch",
1334                 .comment                = "UTC Time",
1335         },{
1336                 .name                   = "String(Generalized-Time)",
1337                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.24",
1338                 .oMSyntax               = 24,
1339                 .attributeSyntax_oid    = "2.5.5.11",
1340                 .drsuapi_to_ldb         = dsdb_syntax_NTTIME_drsuapi_to_ldb,
1341                 .ldb_to_drsuapi         = dsdb_syntax_NTTIME_ldb_to_drsuapi,
1342                 .equality               = "generalizedTimeMatch",
1343                 .comment                = "Generalized Time",
1344                 .ldb_syntax             = LDB_SYNTAX_UTC_TIME,
1345         },{
1346         /* not used in w2k3 schema */
1347                 .name                   = "String(Case Sensitive)",
1348                 .ldap_oid               = "1.2.840.113556.1.4.1362",
1349                 .oMSyntax               = 27,
1350                 .attributeSyntax_oid    = "2.5.5.3",
1351                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1352                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1353         },{
1354                 .name                   = "String(Unicode)",
1355                 .ldap_oid               = LDB_SYNTAX_DIRECTORY_STRING,
1356                 .oMSyntax               = 64,
1357                 .attributeSyntax_oid    = "2.5.5.12",
1358                 .drsuapi_to_ldb         = dsdb_syntax_UNICODE_drsuapi_to_ldb,
1359                 .ldb_to_drsuapi         = dsdb_syntax_UNICODE_ldb_to_drsuapi,
1360                 .equality               = "caseIgnoreMatch",
1361                 .substring              = "caseIgnoreSubstringsMatch",
1362                 .comment                = "Directory String",
1363         },{
1364                 .name                   = "Interval/LargeInteger",
1365                 .ldap_oid               = "1.2.840.113556.1.4.906",
1366                 .oMSyntax               = 65,
1367                 .attributeSyntax_oid    = "2.5.5.16",
1368                 .drsuapi_to_ldb         = dsdb_syntax_INT64_drsuapi_to_ldb,
1369                 .ldb_to_drsuapi         = dsdb_syntax_INT64_ldb_to_drsuapi,
1370                 .equality               = "integerMatch",
1371                 .comment                = "Large Integer",
1372                 .ldb_syntax             = LDB_SYNTAX_INTEGER,
1373         },{
1374                 .name                   = "String(NT-Sec-Desc)",
1375                 .ldap_oid               = LDB_SYNTAX_SAMBA_SECURITY_DESCRIPTOR,
1376                 .oMSyntax               = 66,
1377                 .attributeSyntax_oid    = "2.5.5.15",
1378                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1379                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1380         },{
1381                 .name                   = "Object(DS-DN)",
1382                 .ldap_oid               = LDB_SYNTAX_DN,
1383                 .oMSyntax               = 127,
1384                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x4a"),
1385                 .attributeSyntax_oid    = "2.5.5.1",
1386                 .drsuapi_to_ldb         = dsdb_syntax_DN_drsuapi_to_ldb,
1387                 .ldb_to_drsuapi         = dsdb_syntax_DN_ldb_to_drsuapi,
1388                 .equality               = "distinguishedNameMatch",
1389                 .comment                = "Object(DS-DN) == a DN",
1390         },{
1391                 .name                   = "Object(DN-Binary)",
1392                 .ldap_oid               = "1.2.840.113556.1.4.903",
1393                 .oMSyntax               = 127,
1394                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0b"),
1395                 .attributeSyntax_oid    = "2.5.5.7",
1396                 .drsuapi_to_ldb         = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
1397                 .ldb_to_drsuapi         = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
1398                 .equality               = "octetStringMatch",
1399                 .comment                = "OctetString: Binary+DN",
1400                 .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
1401         },{
1402         /* not used in w2k3 schema */
1403                 .name                   = "Object(OR-Name)",
1404                 .ldap_oid               = "1.2.840.113556.1.4.1221",
1405                 .oMSyntax               = 127,
1406                 .oMObjectClass          = OMOBJECTCLASS("\x56\x06\x01\x02\x05\x0b\x1D"),
1407                 .attributeSyntax_oid    = "2.5.5.7",
1408                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1409                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1410         },{
1411         /*
1412          * TODO: verify if DATA_BLOB is correct here...!
1413          *
1414          *       repsFrom and repsTo are the only attributes using
1415          *       this attribute syntax, but they're not replicated...
1416          */
1417                 .name                   = "Object(Replica-Link)",
1418                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.40",
1419                 .oMSyntax               = 127,
1420                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x06"),
1421                 .attributeSyntax_oid    = "2.5.5.10",
1422                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1423                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1424         },{
1425                 .name                   = "Object(Presentation-Address)",
1426                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.43",
1427                 .oMSyntax               = 127,
1428                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x5c"),
1429                 .attributeSyntax_oid    = "2.5.5.13",
1430                 .drsuapi_to_ldb         = dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb,
1431                 .ldb_to_drsuapi         = dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi,
1432                 .comment                = "Presentation Address"
1433         },{
1434         /* not used in w2k3 schema */
1435                 .name                   = "Object(Access-Point)",
1436                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.2",
1437                 .oMSyntax               = 127,
1438                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x3e"),
1439                 .attributeSyntax_oid    = "2.5.5.14",
1440                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1441                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1442         },{
1443         /* not used in w2k3 schema */
1444                 .name                   = "Object(DN-String)",
1445                 .ldap_oid               = "1.2.840.113556.1.4.904",
1446                 .oMSyntax               = 127,
1447                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0c"),
1448                 .attributeSyntax_oid    = "2.5.5.14",
1449                 .drsuapi_to_ldb         = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
1450                 .ldb_to_drsuapi         = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
1451                 .equality               = "octetStringMatch",
1452                 .comment                = "OctetString: String+DN",
1453                 .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
1454         }
1455 };
1456
1457 const struct dsdb_syntax *find_syntax_map_by_ad_oid(const char *ad_oid)
1458 {
1459         int i;
1460         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
1461                 if (strcasecmp(ad_oid, dsdb_syntaxes[i].attributeSyntax_oid) == 0) {
1462                         return &dsdb_syntaxes[i];
1463                 }
1464         }
1465         return NULL;
1466 }
1467
1468 const struct dsdb_syntax *find_syntax_map_by_ad_syntax(int oMSyntax)
1469 {
1470         int i;
1471         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
1472                 if (oMSyntax == dsdb_syntaxes[i].oMSyntax) {
1473                         return &dsdb_syntaxes[i];
1474                 }
1475         }
1476         return NULL;
1477 }
1478
1479 const struct dsdb_syntax *find_syntax_map_by_standard_oid(const char *standard_oid)
1480 {
1481         int i;
1482         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
1483                 if (strcasecmp(standard_oid, dsdb_syntaxes[i].ldap_oid) == 0) {
1484                         return &dsdb_syntaxes[i];
1485                 }
1486         }
1487         return NULL;
1488 }
1489 const struct dsdb_syntax *dsdb_syntax_for_attribute(const struct dsdb_attribute *attr)
1490 {
1491         uint32_t i;
1492
1493         for (i=0; i < ARRAY_SIZE(dsdb_syntaxes); i++) {
1494                 if (attr->oMSyntax != dsdb_syntaxes[i].oMSyntax) continue;
1495
1496                 if (attr->oMObjectClass.length != dsdb_syntaxes[i].oMObjectClass.length) continue;
1497
1498                 if (attr->oMObjectClass.length) {
1499                         int ret;
1500                         ret = memcmp(attr->oMObjectClass.data,
1501                                      dsdb_syntaxes[i].oMObjectClass.data,
1502                                      attr->oMObjectClass.length);
1503                         if (ret != 0) continue;
1504                 }
1505
1506                 if (strcmp(attr->attributeSyntax_oid, dsdb_syntaxes[i].attributeSyntax_oid) != 0) continue;
1507
1508                 return &dsdb_syntaxes[i];
1509         }
1510
1511         return NULL;
1512 }
1513
1514 WERROR dsdb_attribute_drsuapi_to_ldb(struct ldb_context *ldb,
1515                                      const struct dsdb_schema *schema,
1516                                      const struct drsuapi_DsReplicaAttribute *in,
1517                                      TALLOC_CTX *mem_ctx,
1518                                      struct ldb_message_element *out)
1519 {
1520         const struct dsdb_attribute *sa;
1521
1522         sa = dsdb_attribute_by_attributeID_id(schema, in->attid);
1523         if (!sa) {
1524                 return WERR_FOOBAR;
1525         }
1526
1527         return sa->syntax->drsuapi_to_ldb(ldb, schema, sa, in, mem_ctx, out);
1528 }
1529
1530 WERROR dsdb_attribute_ldb_to_drsuapi(struct ldb_context *ldb,
1531                                      const struct dsdb_schema *schema,
1532                                      const struct ldb_message_element *in,
1533                                      TALLOC_CTX *mem_ctx,
1534                                      struct drsuapi_DsReplicaAttribute *out)
1535 {
1536         const struct dsdb_attribute *sa;
1537
1538         sa = dsdb_attribute_by_lDAPDisplayName(schema, in->name);
1539         if (!sa) {
1540                 return WERR_FOOBAR;
1541         }
1542
1543         return sa->syntax->ldb_to_drsuapi(ldb, schema, sa, in, mem_ctx, out);
1544 }