source4/dsdb/schema/schema_syntax.c

   1 /*
   2    Unix SMB/CIFS mplementation.
   3    DSDB schema syntaxes
   4
   5    Copyright (C) Stefan Metzmacher 2006
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21 */
  22 #include "includes.h"
  23 #include "dsdb/samdb/samdb.h"
  24 #include "librpc/gen_ndr/drsuapi.h"
  25 #include "lib/ldb/include/ldb.h"
  26 #include "system/time.h"
  27
  28 static WERROR dsdb_syntax_FOOBAR_drsuapi_to_ldb(const struct dsdb_schema *schema,
  29                                                 const struct dsdb_attribute *attr,
  30                                                 const struct drsuapi_DsReplicaAttribute *in,
  31                                                 TALLOC_CTX *mem_ctx,
  32                                                 struct ldb_message_element *out)
  33 {
  34         uint32_t i;
  35
  36         out->flags      = 0;
  37         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
  38         W_ERROR_HAVE_NO_MEMORY(out->name);
  39
  40         out->num_values = in->value_ctr.data_blob.num_values;
  41         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
  42         W_ERROR_HAVE_NO_MEMORY(out->values);
  43
  44         for (i=0; i < out->num_values; i++) {
  45                 char *str;
  46
  47                 if (in->value_ctr.data_blob.values[i].data == NULL) {
  48                         return WERR_FOOBAR;
  49                 }
  50
  51                 str = talloc_asprintf(out->values, "%s: not implemented",
  52                                       attr->syntax->name);
  53                 W_ERROR_HAVE_NO_MEMORY(str);
  54
  55                 out->values[i] = data_blob_string_const(str);
  56         }
  57
  58         return WERR_OK;
  59 }
  60
  61 static WERROR dsdb_syntax_FOOBAR_ldb_to_drsuapi(const struct dsdb_schema *schema,
  62                                                 const struct dsdb_attribute *attr,
  63                                                 const struct ldb_message_element *in,
  64                                                 TALLOC_CTX *mem_ctx,
  65                                                 struct drsuapi_DsReplicaAttribute *out)
  66 {
  67         return WERR_FOOBAR;
  68 }
  69
  70 static WERROR dsdb_syntax_BOOL_drsuapi_to_ldb(const struct dsdb_schema *schema,
  71                                               const struct dsdb_attribute *attr,
  72                                               const struct drsuapi_DsReplicaAttribute *in,
  73                                               TALLOC_CTX *mem_ctx,
  74                                               struct ldb_message_element *out)
  75 {
  76         uint32_t i;
  77
  78 switch (attr->attributeID_id) {
  79 case DRSUAPI_ATTRIBUTE_isSingleValued:
  80 case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly:
  81 case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet:
  82         return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
  83 }
  84
  85         out->flags      = 0;
  86         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
  87         W_ERROR_HAVE_NO_MEMORY(out->name);
  88
  89         out->num_values = in->value_ctr.data_blob.num_values;
  90         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
  91         W_ERROR_HAVE_NO_MEMORY(out->values);
  92
  93         for (i=0; i < out->num_values; i++) {
  94                 uint32_t v;
  95                 char *str;
  96
  97                 if (in->value_ctr.data_blob.values[i].data == NULL) {
  98                         return WERR_FOOBAR;
  99                 }
 100
 101                 if (in->value_ctr.data_blob.values[i].data->length != 4) {
 102                         return WERR_FOOBAR;
 103                 }
 104
 105                 v = IVAL(in->value_ctr.data_blob.values[i].data->data, 0);
 106
 107                 if (v != 0) {
 108                         str = talloc_strdup(out->values, "TRUE");
 109                         W_ERROR_HAVE_NO_MEMORY(str);
 110                 } else {
 111                         str = talloc_strdup(out->values, "FALSE");
 112                         W_ERROR_HAVE_NO_MEMORY(str);
 113                 }
 114
 115                 out->values[i] = data_blob_string_const(str);
 116         }
 117
 118         return WERR_OK;
 119 }
 120
 121 static WERROR dsdb_syntax_BOOL_ldb_to_drsuapi(const struct dsdb_schema *schema,
 122                                               const struct dsdb_attribute *attr,
 123                                               const struct ldb_message_element *in,
 124                                               TALLOC_CTX *mem_ctx,
 125                                               struct drsuapi_DsReplicaAttribute *out)
 126 {
 127         uint32_t i;
 128         DATA_BLOB *blobs;
 129
 130         if (attr->attributeID_id == 0xFFFFFFFF) {
 131                 return WERR_FOOBAR;
 132         }
 133
 134         out->attid                              = attr->attributeID_id;
 135         out->value_ctr.data_blob.num_values     = in->num_values;
 136         out->value_ctr.data_blob.values         = talloc_array(mem_ctx,
 137                                                                struct drsuapi_DsAttributeValueDataBlob,
 138                                                                in->num_values);
 139         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
 140
 141         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 142         W_ERROR_HAVE_NO_MEMORY(blobs);
 143
 144         for (i=0; i < in->num_values; i++) {
 145                 out->value_ctr.data_blob.values[i].data = &blobs[i];
 146
 147                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 148                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 149
 150                 if (strcmp("TRUE", (const char *)in->values[i].data) == 0) {
 151                         SIVAL(blobs[i].data, 0, 0x00000001);
 152                 } else if (strcmp("FALSE", (const char *)in->values[i].data) == 0) {
 153                         SIVAL(blobs[i].data, 0, 0x00000000);
 154                 } else {
 155                         return WERR_FOOBAR;
 156                 }
 157         }
 158
 159         return WERR_OK;
 160 }
 161
 162 static WERROR dsdb_syntax_INT32_drsuapi_to_ldb(const struct dsdb_schema *schema,
 163                                                const struct dsdb_attribute *attr,
 164                                                const struct drsuapi_DsReplicaAttribute *in,
 165                                                TALLOC_CTX *mem_ctx,
 166                                                struct ldb_message_element *out)
 167 {
 168         uint32_t i;
 169
 170 switch (attr->attributeID_id) {
 171 case DRSUAPI_ATTRIBUTE_instanceType:
 172 case DRSUAPI_ATTRIBUTE_rangeLower:
 173 case DRSUAPI_ATTRIBUTE_rangeUpper:
 174 case DRSUAPI_ATTRIBUTE_objectVersion:
 175 case DRSUAPI_ATTRIBUTE_oMSyntax:
 176 case DRSUAPI_ATTRIBUTE_searchFlags:
 177 case DRSUAPI_ATTRIBUTE_systemFlags:
 178 case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version:
 179         return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
 180 }
 181
 182         out->flags      = 0;
 183         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 184         W_ERROR_HAVE_NO_MEMORY(out->name);
 185
 186         out->num_values = in->value_ctr.data_blob.num_values;
 187         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 188         W_ERROR_HAVE_NO_MEMORY(out->values);
 189
 190         for (i=0; i < out->num_values; i++) {
 191                 int32_t v;
 192                 char *str;
 193
 194                 if (in->value_ctr.data_blob.values[i].data == NULL) {
 195                         return WERR_FOOBAR;
 196                 }
 197
 198                 if (in->value_ctr.data_blob.values[i].data->length != 4) {
 199                         return WERR_FOOBAR;
 200                 }
 201
 202                 v = IVALS(in->value_ctr.data_blob.values[i].data->data, 0);
 203
 204                 str = talloc_asprintf(out->values, "%d", v);
 205                 W_ERROR_HAVE_NO_MEMORY(str);
 206
 207                 out->values[i] = data_blob_string_const(str);
 208         }
 209
 210         return WERR_OK;
 211 }
 212
 213 static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(const struct dsdb_schema *schema,
 214                                                const struct dsdb_attribute *attr,
 215                                                const struct ldb_message_element *in,
 216                                                TALLOC_CTX *mem_ctx,
 217                                                struct drsuapi_DsReplicaAttribute *out)
 218 {
 219         uint32_t i;
 220         DATA_BLOB *blobs;
 221
 222         if (attr->attributeID_id == 0xFFFFFFFF) {
 223                 return WERR_FOOBAR;
 224         }
 225
 226         out->attid                              = attr->attributeID_id;
 227         out->value_ctr.data_blob.num_values     = in->num_values;
 228         out->value_ctr.data_blob.values         = talloc_array(mem_ctx,
 229                                                                struct drsuapi_DsAttributeValueDataBlob,
 230                                                                in->num_values);
 231         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
 232
 233         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 234         W_ERROR_HAVE_NO_MEMORY(blobs);
 235
 236         for (i=0; i < in->num_values; i++) {
 237                 int32_t v;
 238
 239                 out->value_ctr.data_blob.values[i].data = &blobs[i];
 240
 241                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 242                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 243
 244                 v = strtol((const char *)in->values[i].data, NULL, 10);
 245
 246                 SIVALS(blobs[i].data, 0, v);
 247         }
 248
 249         return WERR_OK;
 250 }
 251
 252 static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(const struct dsdb_schema *schema,
 253                                                const struct dsdb_attribute *attr,
 254                                                const struct drsuapi_DsReplicaAttribute *in,
 255                                                TALLOC_CTX *mem_ctx,
 256                                                struct ldb_message_element *out)
 257 {
 258         uint32_t i;
 259
 260         out->flags      = 0;
 261         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 262         W_ERROR_HAVE_NO_MEMORY(out->name);
 263
 264         out->num_values = in->value_ctr.data_blob.num_values;
 265         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 266         W_ERROR_HAVE_NO_MEMORY(out->values);
 267
 268         for (i=0; i < out->num_values; i++) {
 269                 int64_t v;
 270                 char *str;
 271
 272                 if (in->value_ctr.data_blob.values[i].data == NULL) {
 273                         return WERR_FOOBAR;
 274                 }
 275
 276                 if (in->value_ctr.data_blob.values[i].data->length != 8) {
 277                         return WERR_FOOBAR;
 278                 }
 279
 280                 v = BVALS(in->value_ctr.data_blob.values[i].data->data, 0);
 281
 282                 str = talloc_asprintf(out->values, "%lld", v);
 283                 W_ERROR_HAVE_NO_MEMORY(str);
 284
 285                 out->values[i] = data_blob_string_const(str);
 286         }
 287
 288         return WERR_OK;
 289 }
 290
 291 static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(const struct dsdb_schema *schema,
 292                                                const struct dsdb_attribute *attr,
 293                                                const struct ldb_message_element *in,
 294                                                TALLOC_CTX *mem_ctx,
 295                                                struct drsuapi_DsReplicaAttribute *out)
 296 {
 297         uint32_t i;
 298         DATA_BLOB *blobs;
 299
 300         if (attr->attributeID_id == 0xFFFFFFFF) {
 301                 return WERR_FOOBAR;
 302         }
 303
 304         out->attid                              = attr->attributeID_id;
 305         out->value_ctr.data_blob.num_values     = in->num_values;
 306         out->value_ctr.data_blob.values         = talloc_array(mem_ctx,
 307                                                                struct drsuapi_DsAttributeValueDataBlob,
 308                                                                in->num_values);
 309         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
 310
 311         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 312         W_ERROR_HAVE_NO_MEMORY(blobs);
 313
 314         for (i=0; i < in->num_values; i++) {
 315                 int64_t v;
 316
 317                 out->value_ctr.data_blob.values[i].data = &blobs[i];
 318
 319                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 320                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 321
 322                 v = strtoll((const char *)in->values[i].data, NULL, 10);
 323
 324                 SBVALS(blobs[i].data, 0, v);
 325         }
 326
 327         return WERR_OK;
 328 }
 329
 330 static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(const struct dsdb_schema *schema,
 331                                                 const struct dsdb_attribute *attr,
 332                                                 const struct drsuapi_DsReplicaAttribute *in,
 333                                                 TALLOC_CTX *mem_ctx,
 334                                                 struct ldb_message_element *out)
 335 {
 336         uint32_t i;
 337
 338         out->flags      = 0;
 339         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 340         W_ERROR_HAVE_NO_MEMORY(out->name);
 341
 342         out->num_values = in->value_ctr.data_blob.num_values;
 343         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 344         W_ERROR_HAVE_NO_MEMORY(out->values);
 345
 346         for (i=0; i < out->num_values; i++) {
 347                 NTTIME v;
 348                 time_t t;
 349                 char *str;
 350
 351                 if (in->value_ctr.data_blob.values[i].data == NULL) {
 352                         return WERR_FOOBAR;
 353                 }
 354
 355                 if (in->value_ctr.data_blob.values[i].data->length != 8) {
 356                         return WERR_FOOBAR;
 357                 }
 358
 359                 v = BVAL(in->value_ctr.data_blob.values[i].data->data, 0);
 360                 v *= 10000000;
 361                 t = nt_time_to_unix(v);
 362
 363                 str = ldb_timestring(out->values, t);
 364                 W_ERROR_HAVE_NO_MEMORY(str);
 365
 366                 out->values[i] = data_blob_string_const(str);
 367         }
 368
 369         return WERR_OK;
 370 }
 371
 372 static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(const struct dsdb_schema *schema,
 373                                                 const struct dsdb_attribute *attr,
 374                                                 const struct ldb_message_element *in,
 375                                                 TALLOC_CTX *mem_ctx,
 376                                                 struct drsuapi_DsReplicaAttribute *out)
 377 {
 378         uint32_t i;
 379         DATA_BLOB *blobs;
 380
 381         if (attr->attributeID_id == 0xFFFFFFFF) {
 382                 return WERR_FOOBAR;
 383         }
 384
 385         out->attid                              = attr->attributeID_id;
 386         out->value_ctr.data_blob.num_values     = in->num_values;
 387         out->value_ctr.data_blob.values         = talloc_array(mem_ctx,
 388                                                                struct drsuapi_DsAttributeValueDataBlob,
 389                                                                in->num_values);
 390         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
 391
 392         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 393         W_ERROR_HAVE_NO_MEMORY(blobs);
 394
 395         for (i=0; i < in->num_values; i++) {
 396                 NTTIME v;
 397                 time_t t;
 398
 399                 out->value_ctr.data_blob.values[i].data = &blobs[i];
 400
 401                 blobs[i] = data_blob_talloc(blobs, NULL, 8);
 402                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 403
 404                 t = ldb_string_to_time((const char *)in->values[i].data);
 405                 unix_to_nt_time(&v, t);
 406
 407                 SBVAL(blobs[i].data, 0, v);
 408         }
 409
 410         return WERR_OK;
 411 }
 412
 413 static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(const struct dsdb_schema *schema,
 414                                                    const struct dsdb_attribute *attr,
 415                                                    const struct drsuapi_DsReplicaAttribute *in,
 416                                                    TALLOC_CTX *mem_ctx,
 417                                                    struct ldb_message_element *out)
 418 {
 419         uint32_t i;
 420
 421 switch (attr->attributeID_id) {
 422 case DRSUAPI_ATTRIBUTE_invocationId:
 423 case DRSUAPI_ATTRIBUTE_schemaIDGUID:
 424         return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
 425 }
 426
 427         out->flags      = 0;
 428         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 429         W_ERROR_HAVE_NO_MEMORY(out->name);
 430
 431         out->num_values = in->value_ctr.data_blob.num_values;
 432         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 433         W_ERROR_HAVE_NO_MEMORY(out->values);
 434
 435         for (i=0; i < out->num_values; i++) {
 436                 if (in->value_ctr.data_blob.values[i].data == NULL) {
 437                         return WERR_FOOBAR;
 438                 }
 439
 440                 if (in->value_ctr.data_blob.values[i].data->length == 0) {
 441                         return WERR_FOOBAR;
 442                 }
 443
 444                 out->values[i] = data_blob_dup_talloc(out->values,
 445                                                       in->value_ctr.data_blob.values[i].data);
 446                 W_ERROR_HAVE_NO_MEMORY(out->values[i].data);
 447         }
 448
 449         return WERR_OK;
 450 }
 451
 452 static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(const struct dsdb_schema *schema,
 453                                                    const struct dsdb_attribute *attr,
 454                                                    const struct ldb_message_element *in,
 455                                                    TALLOC_CTX *mem_ctx,
 456                                                    struct drsuapi_DsReplicaAttribute *out)
 457 {
 458         uint32_t i;
 459         DATA_BLOB *blobs;
 460
 461         if (attr->attributeID_id == 0xFFFFFFFF) {
 462                 return WERR_FOOBAR;
 463         }
 464
 465         out->attid                              = attr->attributeID_id;
 466         out->value_ctr.data_blob.num_values     = in->num_values;
 467         out->value_ctr.data_blob.values         = talloc_array(mem_ctx,
 468                                                                struct drsuapi_DsAttributeValueDataBlob,
 469                                                                in->num_values);
 470         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
 471
 472         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 473         W_ERROR_HAVE_NO_MEMORY(blobs);
 474
 475         for (i=0; i < in->num_values; i++) {
 476                 out->value_ctr.data_blob.values[i].data = &blobs[i];
 477
 478                 blobs[i] = data_blob_dup_talloc(blobs, &in->values[i]);
 479                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 480         }
 481
 482         return WERR_OK;
 483 }
 484
 485 static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(const struct dsdb_schema *schema,
 486                                                   const struct dsdb_attribute *attr,
 487                                                   const struct drsuapi_DsReplicaAttribute *in,
 488                                                   TALLOC_CTX *mem_ctx,
 489                                                   struct ldb_message_element *out)
 490 {
 491         uint32_t i;
 492
 493         out->flags      = 0;
 494         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 495         W_ERROR_HAVE_NO_MEMORY(out->name);
 496
 497         out->num_values = in->value_ctr.data_blob.num_values;
 498         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 499         W_ERROR_HAVE_NO_MEMORY(out->values);
 500
 501         for (i=0; i < out->num_values; i++) {
 502                 uint32_t v;
 503                 const struct dsdb_class *c;
 504                 const char *str;
 505
 506                 if (in->value_ctr.object_class_id.values[i].objectClassId == NULL) {
 507                         return WERR_FOOBAR;
 508                 }
 509
 510                 v = *in->value_ctr.object_class_id.values[i].objectClassId;
 511
 512                 c = dsdb_class_by_governsID_id(schema, v);
 513                 if (!c) {
 514                         return WERR_FOOBAR;
 515                 }
 516
 517                 str = talloc_strdup(out->values, c->lDAPDisplayName);
 518                 W_ERROR_HAVE_NO_MEMORY(str);
 519
 520                 /* the values need to be reversed */
 521                 out->values[out->num_values - (i + 1)] = data_blob_string_const(str);
 522         }
 523
 524         return WERR_OK;
 525 }
 526
 527 static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(const struct dsdb_schema *schema,
 528                                                   const struct dsdb_attribute *attr,
 529                                                   const struct drsuapi_DsReplicaAttribute *in,
 530                                                   TALLOC_CTX *mem_ctx,
 531                                                   struct ldb_message_element *out)
 532 {
 533         uint32_t i;
 534
 535         out->flags      = 0;
 536         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 537         W_ERROR_HAVE_NO_MEMORY(out->name);
 538
 539         out->num_values = in->value_ctr.data_blob.num_values;
 540         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 541         W_ERROR_HAVE_NO_MEMORY(out->values);
 542
 543         for (i=0; i < out->num_values; i++) {
 544                 uint32_t v;
 545                 WERROR status;
 546                 const char *str;
 547
 548                 if (in->value_ctr.oid.values[i].value == NULL) {
 549                         return WERR_FOOBAR;
 550                 }
 551
 552                 v = *in->value_ctr.oid.values[i].value;
 553
 554                 status = dsdb_map_int2oid(schema, v, out->values, &str);
 555                 W_ERROR_NOT_OK_RETURN(status);
 556
 557                 out->values[i] = data_blob_string_const(str);
 558         }
 559
 560         return WERR_OK;
 561 }
 562
 563 static WERROR dsdb_syntax_OID_drsuapi_to_ldb(const struct dsdb_schema *schema,
 564                                              const struct dsdb_attribute *attr,
 565                                              const struct drsuapi_DsReplicaAttribute *in,
 566                                              TALLOC_CTX *mem_ctx,
 567                                              struct ldb_message_element *out)
 568 {
 569         uint32_t i;
 570
 571         switch (attr->attributeID_id) {
 572         case DRSUAPI_ATTRIBUTE_objectClass:
 573                 return _dsdb_syntax_OID_obj_drsuapi_to_ldb(schema, attr, in, mem_ctx, out);
 574         case DRSUAPI_ATTRIBUTE_governsID:
 575         case DRSUAPI_ATTRIBUTE_attributeID:
 576         case DRSUAPI_ATTRIBUTE_attributeSyntax:
 577                 return _dsdb_syntax_OID_oid_drsuapi_to_ldb(schema, attr, in, mem_ctx, out);
 578         }
 579
 580         out->flags      = 0;
 581         out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
 582         W_ERROR_HAVE_NO_MEMORY(out->name);
 583
 584         out->num_values = in->value_ctr.data_blob.num_values;
 585         out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
 586         W_ERROR_HAVE_NO_MEMORY(out->values);
 587
 588         for (i=0; i < out->num_values; i++) {
 589                 uint32_t v;
 590                 const char *name;
 591                 char *str;
 592
 593                 if (in->value_ctr.data_blob.values[i].data == NULL) {
 594                         return WERR_FOOBAR;
 595                 }
 596
 597                 if (in->value_ctr.data_blob.values[i].data->length != 4) {
 598                         return WERR_FOOBAR;
 599                 }
 600
 601                 v = IVAL(in->value_ctr.data_blob.values[i].data->data, 0);
 602
 603                 name = dsdb_lDAPDisplayName_by_id(schema, v);
 604                 if (!name) {
 605                         return WERR_FOOBAR;
 606                 }
 607
 608                 str = talloc_strdup(out->values, name);
 609                 W_ERROR_HAVE_NO_MEMORY(str);
 610
 611                 out->values[i] = data_blob_string_const(str);
 612         }
 613
 614         return WERR_OK;
 615 }
 616
 617 static WERROR dsdb_syntax_OID_ldb_to_drsuapi(const struct dsdb_schema *schema,
 618                                              const struct dsdb_attribute *attr,
 619                                              const struct ldb_message_element *in,
 620                                              TALLOC_CTX *mem_ctx,
 621                                              struct drsuapi_DsReplicaAttribute *out)
 622 {
 623         uint32_t i;
 624         DATA_BLOB *blobs;
 625
 626         if (attr->attributeID_id == 0xFFFFFFFF) {
 627                 return WERR_FOOBAR;
 628         }
 629
 630         switch (attr->attributeID_id) {
 631         case DRSUAPI_ATTRIBUTE_objectClass:
 632         case DRSUAPI_ATTRIBUTE_governsID:
 633         case DRSUAPI_ATTRIBUTE_attributeID:
 634         case DRSUAPI_ATTRIBUTE_attributeSyntax:
 635                 return dsdb_syntax_FOOBAR_ldb_to_drsuapi(schema, attr, in, mem_ctx, out);
 636         }
 637
 638         out->attid                              = attr->attributeID_id;
 639         out->value_ctr.data_blob.num_values     = in->num_values;
 640         out->value_ctr.data_blob.values         = talloc_array(mem_ctx,
 641                                                                struct drsuapi_DsAttributeValueDataBlob,
 642                                                                in->num_values);
 643         W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
 644
 645         blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
 646         W_ERROR_HAVE_NO_MEMORY(blobs);
 647
 648         for (i=0; i < in->num_values; i++) {
 649                 uint32_t v;
 650
 651                 out->value_ctr.data_blob.values[i].data = &blobs[i];
 652
 653                 blobs[i] = data_blob_talloc(blobs, NULL, 4);
 654                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 655
 656                 v = strtol((const char *)in->values[i].data, NULL, 10);
 657
 658                 SIVAL(blobs[i].data, 0, v);
 659         }
 660
 661         return WERR_OK;
 662 }
 663
 664 #define OMOBJECTCLASS(val) { .length = sizeof(val) - 1, .data = discard_const_p(uint8_t, val) }
 665
 666 static const struct dsdb_syntax dsdb_syntaxes[] = {
 667         {
 668                 .name                   = "Boolean",
 669                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.7",
 670                 .oMSyntax               = 1,
 671                 .attributeSyntax_oid    = "2.5.5.8",
 672                 .drsuapi_to_ldb         = dsdb_syntax_BOOL_drsuapi_to_ldb,
 673                 .ldb_to_drsuapi         = dsdb_syntax_BOOL_ldb_to_drsuapi,
 674         },{
 675                 .name                   = "Integer",
 676                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.27",
 677                 .oMSyntax               = 2,
 678                 .attributeSyntax_oid    = "2.5.5.9",
 679                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
 680                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
 681         },{
 682                 .name                   = "String(Octet)",
 683                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.40",
 684                 .oMSyntax               = 4,
 685                 .attributeSyntax_oid    = "2.5.5.10",
 686                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
 687                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
 688         },{
 689                 .name                   = "String(Sid)",
 690                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.40",
 691                 .oMSyntax               = 4,
 692                 .attributeSyntax_oid    = "2.5.5.17",
 693                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
 694                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
 695         },{
 696                 .name                   = "String(Object-Identifier)",
 697                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.38",
 698                 .oMSyntax               = 6,
 699                 .attributeSyntax_oid    = "2.5.5.2",
 700                 .drsuapi_to_ldb         = dsdb_syntax_OID_drsuapi_to_ldb,
 701                 .ldb_to_drsuapi         = dsdb_syntax_OID_ldb_to_drsuapi,
 702         },{
 703                 .name                   = "Enumeration",
 704                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.27",
 705                 .oMSyntax               = 10,
 706                 .attributeSyntax_oid    = "2.5.5.9",
 707                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
 708                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
 709         },{
 710         /* not used in w2k3 forest */
 711                 .name                   = "String(Numeric)",
 712                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.36",
 713                 .oMSyntax               = 18,
 714                 .attributeSyntax_oid    = "2.5.5.6",
 715                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 716                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 717         },{
 718         /* not used in w2k3 forest */
 719                 .name                   = "String(Printable)",
 720                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.44",
 721                 .oMSyntax               = 19,
 722                 .attributeSyntax_oid    = "2.5.5.5",
 723                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 724                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 725         },{
 726         /* not used in w2k3 forest */
 727                 .name                   = "String(Teletex)",
 728                 .ldap_oid               = "1.2.840.113556.1.4.905",
 729                 .oMSyntax               = 20,
 730                 .attributeSyntax_oid    = "2.5.5.4",
 731                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 732                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 733         },{
 734         /* not used in w2k3 forest */
 735                 .name                   = "String(IA5)",
 736                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.26",
 737                 .oMSyntax               = 22,
 738                 .attributeSyntax_oid    = "2.5.5.5",
 739                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 740                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 741         },{
 742         /* not used in w2k3 forest */
 743                 .name                   = "String(UTC-Time)",
 744                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.53",
 745                 .oMSyntax               = 23,
 746                 .attributeSyntax_oid    = "2.5.5.11",
 747                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 748                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 749         },{
 750                 .name                   = "String(Generalized-Time)",
 751                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.24",
 752                 .oMSyntax               = 24,
 753                 .attributeSyntax_oid    = "2.5.5.11",
 754                 .drsuapi_to_ldb         = dsdb_syntax_NTTIME_drsuapi_to_ldb,
 755                 .ldb_to_drsuapi         = dsdb_syntax_NTTIME_ldb_to_drsuapi,
 756         },{
 757         /* not used in w2k3 forest */
 758                 .name                   = "String(Case Sensitive)",
 759                 .ldap_oid               = "1.2.840.113556.1.4.1362",
 760                 .oMSyntax               = 27,
 761                 .attributeSyntax_oid    = "2.5.5.3",
 762                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 763                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 764         },{
 765                 .name                   = "String(Unicode)",
 766                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.15",
 767                 .oMSyntax               = 64,
 768                 .attributeSyntax_oid    = "2.5.5.12",
 769                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 770                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 771         },{
 772                 .name                   = "Interval/LargeInteger",
 773                 .ldap_oid               = "1.2.840.113556.1.4.906",
 774                 .oMSyntax               = 65,
 775                 .attributeSyntax_oid    = "2.5.5.16",
 776                 .drsuapi_to_ldb         = dsdb_syntax_INT64_drsuapi_to_ldb,
 777                 .ldb_to_drsuapi         = dsdb_syntax_INT64_ldb_to_drsuapi,
 778         },{
 779                 .name                   = "String(NT-Sec-Desc)",
 780                 .ldap_oid               = "1.2.840.113556.1.4.907",
 781                 .oMSyntax               = 66,
 782                 .attributeSyntax_oid    = "2.5.5.15",
 783                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
 784                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
 785         },{
 786                 .name                   = "Object(DS-DN)",
 787                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.12",
 788                 .oMSyntax               = 127,
 789                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x4a"),
 790                 .attributeSyntax_oid    = "2.5.5.1",
 791                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 792                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 793         },{
 794                 .name                   = "Object(DN-Binary)",
 795                 .ldap_oid               = "1.2.840.113556.1.4.903",
 796                 .oMSyntax               = 127,
 797                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0b"),
 798                 .attributeSyntax_oid    = "2.5.5.7",
 799                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 800                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 801         },{
 802         /* not used in w2k3 forest */
 803                 .name                   = "Object(OR-Name)",
 804                 .ldap_oid               = "1.2.840.113556.1.4.1221",
 805                 .oMSyntax               = 127,
 806                 .oMObjectClass          = OMOBJECTCLASS("\x56\x06\x01\x02\x05\x0b\x1D"),
 807                 .attributeSyntax_oid    = "2.5.5.7",
 808                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 809                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 810         },{
 811                 .name                   = "Object(Replica-Link)",
 812                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.40",
 813                 .oMSyntax               = 127,
 814                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x06"),
 815                 .attributeSyntax_oid    = "2.5.5.10",
 816                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
 817                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
 818         },{
 819         /* not used in w2k3 forest */
 820                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.43",
 821                 .oMSyntax               = 127,
 822                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x5c"),
 823                 .attributeSyntax_oid    = "2.5.5.13",
 824                 .name                   = "Object(Presentation-Address)",
 825                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 826                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 827         },{
 828         /* not used in w2k3 forest */
 829                 .name                   = "Object(Access-Point)",
 830                 .ldap_oid               = "1.3.6.1.4.1.1466.115.121.1.2",
 831                 .oMSyntax               = 127,
 832                 .oMObjectClass          = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x3e"),
 833                 .attributeSyntax_oid    = "2.5.5.14",
 834                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 835                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 836         },{
 837         /* not used in w2k3 forest */
 838                 .name                   = "Object(DN-String)",
 839                 .ldap_oid               = "1.2.840.113556.1.4.904",
 840                 .oMSyntax               = 127,
 841                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0c"),
 842                 .attributeSyntax_oid    = "2.5.5.14",
 843                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
 844                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
 845         }
 846 };
 847
 848 const struct dsdb_syntax *dsdb_syntax_for_attribute(const struct dsdb_attribute *attr)
 849 {
 850         uint32_t i;
 851
 852         for (i=0; i < ARRAY_SIZE(dsdb_syntaxes); i++) {
 853                 if (attr->oMSyntax != dsdb_syntaxes[i].oMSyntax) continue;
 854
 855                 if (attr->oMObjectClass.length != dsdb_syntaxes[i].oMObjectClass.length) continue;
 856
 857                 if (attr->oMObjectClass.length) {
 858                         int ret;
 859                         ret = memcmp(attr->oMObjectClass.data,
 860                                      dsdb_syntaxes[i].oMObjectClass.data,
 861                                      attr->oMObjectClass.length);
 862                         if (ret != 0) continue;
 863                 }
 864
 865                 if (strcmp(attr->attributeSyntax_oid, dsdb_syntaxes[i].attributeSyntax_oid) != 0) continue;
 866
 867                 return &dsdb_syntaxes[i];
 868         }
 869
 870         return NULL;
 871 }
 872
 873 WERROR dsdb_attribute_drsuapi_to_ldb(const struct dsdb_schema *schema,
 874                                      const struct drsuapi_DsReplicaAttribute *in,
 875                                      TALLOC_CTX *mem_ctx,
 876                                      struct ldb_message_element *out)
 877 {
 878         const struct dsdb_attribute *sa;
 879
 880         sa = dsdb_attribute_by_attributeID_id(schema, in->attid);
 881         if (!sa) {
 882                 return WERR_FOOBAR;
 883         }
 884
 885         return sa->syntax->drsuapi_to_ldb(schema, sa, in, mem_ctx, out);
 886 }
 887
 888 WERROR dsdb_attribute_ldb_to_drsuapi(const struct dsdb_schema *schema,
 889                                      const struct ldb_message_element *in,
 890                                      TALLOC_CTX *mem_ctx,
 891                                      struct drsuapi_DsReplicaAttribute *out)
 892 {
 893         const struct dsdb_attribute *sa;
 894
 895         sa = dsdb_attribute_by_lDAPDisplayName(schema, in->name);
 896         if (!sa) {
 897                 return WERR_FOOBAR;
 898         }
 899
 900         return sa->syntax->ldb_to_drsuapi(schema, sa, in, mem_ctx, out);
 901 }