Changeset 740 for vendor/current/source4/dsdb/schema/schema_syntax.c
- Timestamp:
- Nov 14, 2012, 12:59:34 PM (12 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
TabularUnified vendor/current/source4/dsdb/schema/schema_syntax.c ¶
r414 r740 1 /* 1 /* 2 2 Unix SMB/CIFS mplementation. 3 3 DSDB schema syntaxes 4 4 5 5 Copyright (C) Stefan Metzmacher <metze@samba.org> 2006 6 6 Copyright (C) Simo Sorce 2005 … … 11 11 the Free Software Foundation; either version 3 of the License, or 12 12 (at your option) any later version. 13 13 14 14 This program is distributed in the hope that it will be useful, 15 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 17 GNU General Public License for more details. 18 18 19 19 You should have received a copy of the GNU General Public License 20 20 along with this program. If not, see <http://www.gnu.org/licenses/>. 21 21 22 22 */ 23 23 #include "includes.h" … … 26 26 #include "librpc/gen_ndr/ndr_security.h" 27 27 #include "librpc/gen_ndr/ndr_misc.h" 28 #include "lib/ldb/include/ldb.h"29 #include "lib/ldb/include/ldb_errors.h"28 #include <ldb.h> 29 #include <ldb_errors.h> 30 30 #include "system/time.h" 31 31 #include "../lib/util/charset/charset.h" 32 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, 33 #include "../lib/util/asn1.h" 34 35 /** 36 * Initialize dsdb_syntax_ctx with default values 37 * for common cases. 38 */ 39 void dsdb_syntax_ctx_init(struct dsdb_syntax_ctx *ctx, 40 struct ldb_context *ldb, 41 const struct dsdb_schema *schema) 42 { 43 ctx->ldb = ldb; 44 ctx->schema = schema; 45 46 /* 47 * 'true' will keep current behavior, 48 * i.e. attributeID_id will be returned by default 49 */ 50 ctx->is_schema_nc = true; 51 52 ctx->pfm_remote = NULL; 53 } 54 55 56 /** 57 * Returns ATTID for DRS attribute. 58 * 59 * ATTID depends on whether we are replicating 60 * Schema NC or msDs-IntId is set for schemaAttribute 61 * for the attribute. 62 */ 63 uint32_t dsdb_attribute_get_attid(const struct dsdb_attribute *attr, 64 bool for_schema_nc) 65 { 66 if (!for_schema_nc && attr->msDS_IntId) { 67 return attr->msDS_IntId; 68 } 69 70 return attr->attributeID_id; 71 } 72 73 /** 74 * Map an ATTID from remote DC to a local ATTID 75 * using remote prefixMap 76 */ 77 static bool dsdb_syntax_attid_from_remote_attid(const struct dsdb_syntax_ctx *ctx, 78 TALLOC_CTX *mem_ctx, 79 uint32_t id_remote, 80 uint32_t *id_local) 81 { 82 WERROR werr; 83 const char *oid; 84 85 /* 86 * map remote ATTID to local directly in case 87 * of no remote prefixMap (during provision for instance) 88 */ 89 if (!ctx->pfm_remote) { 90 *id_local = id_remote; 91 return true; 92 } 93 94 werr = dsdb_schema_pfm_oid_from_attid(ctx->pfm_remote, id_remote, mem_ctx, &oid); 95 if (!W_ERROR_IS_OK(werr)) { 96 DEBUG(0,("ATTID->OID failed (%s) for: 0x%08X\n", win_errstr(werr), id_remote)); 97 return false; 98 } 99 100 werr = dsdb_schema_pfm_make_attid(ctx->schema->prefixmap, oid, id_local); 101 if (!W_ERROR_IS_OK(werr)) { 102 DEBUG(0,("OID->ATTID failed (%s) for: %s\n", win_errstr(werr), oid)); 103 return false; 104 } 105 106 return true; 107 } 108 109 static WERROR dsdb_syntax_FOOBAR_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 36 110 const struct dsdb_attribute *attr, 37 111 const struct drsuapi_DsReplicaAttribute *in, … … 39 113 struct ldb_message_element *out) 40 114 { 41 u int32_t i;115 unsigned int i; 42 116 43 117 out->flags = 0; … … 66 140 } 67 141 68 static WERROR dsdb_syntax_FOOBAR_ldb_to_drsuapi(struct ldb_context *ldb, 69 const struct dsdb_schema *schema, 142 static WERROR dsdb_syntax_FOOBAR_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 70 143 const struct dsdb_attribute *attr, 71 144 const struct ldb_message_element *in, … … 76 149 } 77 150 78 static WERROR dsdb_syntax_BOOL_drsuapi_to_ldb(struct ldb_context *ldb, 79 const struct dsdb_schema *schema, 151 static WERROR dsdb_syntax_FOOBAR_validate_ldb(const struct dsdb_syntax_ctx *ctx, 152 const struct dsdb_attribute *attr, 153 const struct ldb_message_element *in) 154 { 155 return WERR_FOOBAR; 156 } 157 158 static WERROR dsdb_syntax_BOOL_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 80 159 const struct dsdb_attribute *attr, 81 160 const struct drsuapi_DsReplicaAttribute *in, … … 83 162 struct ldb_message_element *out) 84 163 { 85 u int32_t i;164 unsigned int i; 86 165 87 166 out->flags = 0; … … 121 200 } 122 201 123 static WERROR dsdb_syntax_BOOL_ldb_to_drsuapi(struct ldb_context *ldb, 124 const struct dsdb_schema *schema, 202 static WERROR dsdb_syntax_BOOL_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 125 203 const struct dsdb_attribute *attr, 126 204 const struct ldb_message_element *in, … … 128 206 struct drsuapi_DsReplicaAttribute *out) 129 207 { 130 u int32_t i;208 unsigned int i; 131 209 DATA_BLOB *blobs; 132 210 133 if (attr->attributeID_id == 0xFFFFFFFF) { 134 return WERR_FOOBAR; 135 } 136 137 out->attid = attr->attributeID_id; 211 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 212 return WERR_FOOBAR; 213 } 214 215 out->attid = dsdb_attribute_get_attid(attr, 216 ctx->is_schema_nc); 138 217 out->value_ctr.num_values = in->num_values; 139 218 out->value_ctr.values = talloc_array(mem_ctx, … … 163 242 } 164 243 165 static WERROR dsdb_syntax_INT32_drsuapi_to_ldb(struct ldb_context *ldb, 166 const struct dsdb_schema *schema, 244 static WERROR dsdb_syntax_BOOL_validate_ldb(const struct dsdb_syntax_ctx *ctx, 245 const struct dsdb_attribute *attr, 246 const struct ldb_message_element *in) 247 { 248 unsigned int i; 249 250 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 251 return WERR_FOOBAR; 252 } 253 254 for (i=0; i < in->num_values; i++) { 255 int t, f; 256 257 t = strncmp("TRUE", 258 (const char *)in->values[i].data, 259 in->values[i].length); 260 f = strncmp("FALSE", 261 (const char *)in->values[i].data, 262 in->values[i].length); 263 264 if (t != 0 && f != 0) { 265 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 266 } 267 } 268 269 return WERR_OK; 270 } 271 272 static WERROR dsdb_syntax_INT32_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 167 273 const struct dsdb_attribute *attr, 168 274 const struct drsuapi_DsReplicaAttribute *in, … … 170 276 struct ldb_message_element *out) 171 277 { 172 u int32_t i;278 unsigned int i; 173 279 174 280 out->flags = 0; … … 203 309 } 204 310 205 static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(struct ldb_context *ldb, 206 const struct dsdb_schema *schema, 311 static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 207 312 const struct dsdb_attribute *attr, 208 313 const struct ldb_message_element *in, … … 210 315 struct drsuapi_DsReplicaAttribute *out) 211 316 { 212 u int32_t i;317 unsigned int i; 213 318 DATA_BLOB *blobs; 214 319 215 if (attr->attributeID_id == 0xFFFFFFFF) { 216 return WERR_FOOBAR; 217 } 218 219 out->attid = attr->attributeID_id; 320 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 321 return WERR_FOOBAR; 322 } 323 324 out->attid = dsdb_attribute_get_attid(attr, 325 ctx->is_schema_nc); 220 326 out->value_ctr.num_values = in->num_values; 221 327 out->value_ctr.values = talloc_array(mem_ctx, … … 245 351 } 246 352 247 static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(struct ldb_context *ldb, 248 const struct dsdb_schema *schema, 353 static WERROR dsdb_syntax_INT32_validate_ldb(const struct dsdb_syntax_ctx *ctx, 354 const struct dsdb_attribute *attr, 355 const struct ldb_message_element *in) 356 { 357 unsigned int i; 358 359 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 360 return WERR_FOOBAR; 361 } 362 363 for (i=0; i < in->num_values; i++) { 364 long v; 365 char buf[sizeof("-2147483648")]; 366 char *end = NULL; 367 368 ZERO_STRUCT(buf); 369 if (in->values[i].length >= sizeof(buf)) { 370 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 371 } 372 373 memcpy(buf, in->values[i].data, in->values[i].length); 374 errno = 0; 375 v = strtol(buf, &end, 10); 376 if (errno != 0) { 377 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 378 } 379 if (end && end[0] != '\0') { 380 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 381 } 382 383 if (attr->rangeLower) { 384 if ((int32_t)v < (int32_t)*attr->rangeLower) { 385 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 386 } 387 } 388 389 if (attr->rangeUpper) { 390 if ((int32_t)v > (int32_t)*attr->rangeUpper) { 391 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 392 } 393 } 394 } 395 396 return WERR_OK; 397 } 398 399 static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 249 400 const struct dsdb_attribute *attr, 250 401 const struct drsuapi_DsReplicaAttribute *in, … … 252 403 struct ldb_message_element *out) 253 404 { 254 u int32_t i;405 unsigned int i; 255 406 256 407 out->flags = 0; … … 285 436 } 286 437 287 static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(struct ldb_context *ldb, 288 const struct dsdb_schema *schema, 438 static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 289 439 const struct dsdb_attribute *attr, 290 440 const struct ldb_message_element *in, … … 292 442 struct drsuapi_DsReplicaAttribute *out) 293 443 { 294 u int32_t i;444 unsigned int i; 295 445 DATA_BLOB *blobs; 296 446 297 if (attr->attributeID_id == 0xFFFFFFFF) { 298 return WERR_FOOBAR; 299 } 300 301 out->attid = attr->attributeID_id; 447 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 448 return WERR_FOOBAR; 449 } 450 451 out->attid = dsdb_attribute_get_attid(attr, 452 ctx->is_schema_nc); 302 453 out->value_ctr.num_values = in->num_values; 303 454 out->value_ctr.values = talloc_array(mem_ctx, … … 325 476 } 326 477 327 static WERROR dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb(struct ldb_context *ldb, 328 const struct dsdb_schema *schema, 478 static WERROR dsdb_syntax_INT64_validate_ldb(const struct dsdb_syntax_ctx *ctx, 479 const struct dsdb_attribute *attr, 480 const struct ldb_message_element *in) 481 { 482 unsigned int i; 483 484 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 485 return WERR_FOOBAR; 486 } 487 488 for (i=0; i < in->num_values; i++) { 489 long long v; 490 char buf[sizeof("-9223372036854775808")]; 491 char *end = NULL; 492 493 ZERO_STRUCT(buf); 494 if (in->values[i].length >= sizeof(buf)) { 495 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 496 } 497 memcpy(buf, in->values[i].data, in->values[i].length); 498 499 errno = 0; 500 v = strtoll(buf, &end, 10); 501 if (errno != 0) { 502 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 503 } 504 if (end && end[0] != '\0') { 505 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 506 } 507 508 if (attr->rangeLower) { 509 if ((int64_t)v < (int64_t)*attr->rangeLower) { 510 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 511 } 512 } 513 514 if (attr->rangeUpper) { 515 if ((int64_t)v > (int64_t)*attr->rangeUpper) { 516 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 517 } 518 } 519 } 520 521 return WERR_OK; 522 } 523 static WERROR dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 329 524 const struct dsdb_attribute *attr, 330 525 const struct drsuapi_DsReplicaAttribute *in, … … 332 527 struct ldb_message_element *out) 333 528 { 334 u int32_t i;529 unsigned int i; 335 530 336 531 out->flags = 0; … … 359 554 t = nt_time_to_unix(v); 360 555 361 /* 556 /* 362 557 * NOTE: On a w2k3 server you can set a GeneralizedTime string 363 558 * via LDAP, but you get back an UTCTime string, … … 368 563 * we'll loose information! 369 564 */ 370 str = ldb_timestring_utc(out->values, t); 565 str = ldb_timestring_utc(out->values, t); 371 566 W_ERROR_HAVE_NO_MEMORY(str); 372 567 out->values[i] = data_blob_string_const(str); … … 376 571 } 377 572 378 static WERROR dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi(struct ldb_context *ldb, 379 const struct dsdb_schema *schema, 573 static WERROR dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 380 574 const struct dsdb_attribute *attr, 381 575 const struct ldb_message_element *in, … … 383 577 struct drsuapi_DsReplicaAttribute *out) 384 578 { 385 u int32_t i;579 unsigned int i; 386 580 DATA_BLOB *blobs; 387 581 388 if (attr->attributeID_id == 0xFFFFFFFF) { 389 return WERR_FOOBAR; 390 } 391 392 out->attid = attr->attributeID_id; 582 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 583 return WERR_FOOBAR; 584 } 585 586 out->attid = dsdb_attribute_get_attid(attr, 587 ctx->is_schema_nc); 393 588 out->value_ctr.num_values = in->num_values; 394 589 out->value_ctr.values = talloc_array(mem_ctx, … … 419 614 } 420 615 421 static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(struct ldb_context *ldb, 422 const struct dsdb_schema *schema, 616 static WERROR dsdb_syntax_NTTIME_UTC_validate_ldb(const struct dsdb_syntax_ctx *ctx, 617 const struct dsdb_attribute *attr, 618 const struct ldb_message_element *in) 619 { 620 unsigned int i; 621 622 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 623 return WERR_FOOBAR; 624 } 625 626 for (i=0; i < in->num_values; i++) { 627 time_t t; 628 char buf[sizeof("090826075717Z")]; 629 630 ZERO_STRUCT(buf); 631 if (in->values[i].length >= sizeof(buf)) { 632 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 633 } 634 memcpy(buf, in->values[i].data, in->values[i].length); 635 636 errno = 0; 637 t = ldb_string_utc_to_time(buf); 638 if (errno != 0) { 639 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 640 } 641 642 if (attr->rangeLower) { 643 if ((int32_t)t < (int32_t)*attr->rangeLower) { 644 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 645 } 646 } 647 648 if (attr->rangeUpper) { 649 if ((int32_t)t > (int32_t)*attr->rangeLower) { 650 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 651 } 652 } 653 654 /* 655 * TODO: verify the comment in the 656 * dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb() function! 657 */ 658 } 659 660 return WERR_OK; 661 } 662 663 static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 423 664 const struct dsdb_attribute *attr, 424 665 const struct drsuapi_DsReplicaAttribute *in, … … 426 667 struct ldb_message_element *out) 427 668 { 428 u int32_t i;669 unsigned int i; 429 670 430 671 out->flags = 0; … … 453 694 t = nt_time_to_unix(v); 454 695 455 str = ldb_timestring(out->values, t); 696 str = ldb_timestring(out->values, t); 456 697 W_ERROR_HAVE_NO_MEMORY(str); 457 698 … … 462 703 } 463 704 464 static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(struct ldb_context *ldb, 465 const struct dsdb_schema *schema, 705 static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 466 706 const struct dsdb_attribute *attr, 467 707 const struct ldb_message_element *in, … … 469 709 struct drsuapi_DsReplicaAttribute *out) 470 710 { 471 u int32_t i;711 unsigned int i; 472 712 DATA_BLOB *blobs; 473 713 474 if (attr->attributeID_id == 0xFFFFFFFF) { 475 return WERR_FOOBAR; 476 } 477 478 out->attid = attr->attributeID_id; 714 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 715 return WERR_FOOBAR; 716 } 717 718 out->attid = dsdb_attribute_get_attid(attr, 719 ctx->is_schema_nc); 479 720 out->value_ctr.num_values = in->num_values; 480 721 out->value_ctr.values = talloc_array(mem_ctx, … … 489 730 NTTIME v; 490 731 time_t t; 732 int ret; 491 733 492 734 out->value_ctr.values[i].blob = &blobs[i]; … … 495 737 W_ERROR_HAVE_NO_MEMORY(blobs[i].data); 496 738 497 t = ldb_string_to_time((const char *)in->values[i].data); 739 ret = ldb_val_to_time(&in->values[i], &t); 740 if (ret != LDB_SUCCESS) { 741 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 742 } 498 743 unix_to_nt_time(&v, t); 499 744 v /= 10000000; … … 505 750 } 506 751 507 static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(struct ldb_context *ldb, 508 const struct dsdb_schema *schema, 752 static WERROR dsdb_syntax_NTTIME_validate_ldb(const struct dsdb_syntax_ctx *ctx, 753 const struct dsdb_attribute *attr, 754 const struct ldb_message_element *in) 755 { 756 unsigned int i; 757 758 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 759 return WERR_FOOBAR; 760 } 761 762 for (i=0; i < in->num_values; i++) { 763 time_t t; 764 int ret; 765 766 ret = ldb_val_to_time(&in->values[i], &t); 767 if (ret != LDB_SUCCESS) { 768 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 769 } 770 771 if (attr->rangeLower) { 772 if ((int32_t)t < (int32_t)*attr->rangeLower) { 773 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 774 } 775 } 776 777 if (attr->rangeUpper) { 778 if ((int32_t)t > (int32_t)*attr->rangeLower) { 779 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 780 } 781 } 782 } 783 784 return WERR_OK; 785 } 786 787 static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 509 788 const struct dsdb_attribute *attr, 510 789 const struct drsuapi_DsReplicaAttribute *in, … … 512 791 struct ldb_message_element *out) 513 792 { 514 u int32_t i;793 unsigned int i; 515 794 516 795 out->flags = 0; … … 539 818 } 540 819 541 static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(struct ldb_context *ldb, 542 const struct dsdb_schema *schema, 820 static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 543 821 const struct dsdb_attribute *attr, 544 822 const struct ldb_message_element *in, … … 546 824 struct drsuapi_DsReplicaAttribute *out) 547 825 { 548 u int32_t i;826 unsigned int i; 549 827 DATA_BLOB *blobs; 550 828 551 if (attr->attributeID_id == 0xFFFFFFFF) { 552 return WERR_FOOBAR; 553 } 554 555 out->attid = attr->attributeID_id; 829 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 830 return WERR_FOOBAR; 831 } 832 833 out->attid = dsdb_attribute_get_attid(attr, 834 ctx->is_schema_nc); 556 835 out->value_ctr.num_values = in->num_values; 557 836 out->value_ctr.values = talloc_array(mem_ctx, … … 573 852 } 574 853 575 static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(struct ldb_context *ldb, 576 const struct dsdb_schema *schema, 854 static WERROR dsdb_syntax_DATA_BLOB_validate_one_val(const struct dsdb_syntax_ctx *ctx, 855 const struct dsdb_attribute *attr, 856 const struct ldb_val *val) 857 { 858 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 859 return WERR_FOOBAR; 860 } 861 862 if (attr->rangeLower) { 863 if ((uint32_t)val->length < (uint32_t)*attr->rangeLower) { 864 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 865 } 866 } 867 868 if (attr->rangeUpper) { 869 if ((uint32_t)val->length > (uint32_t)*attr->rangeUpper) { 870 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 871 } 872 } 873 874 return WERR_OK; 875 } 876 877 static WERROR dsdb_syntax_DATA_BLOB_validate_ldb(const struct dsdb_syntax_ctx *ctx, 878 const struct dsdb_attribute *attr, 879 const struct ldb_message_element *in) 880 { 881 unsigned int i; 882 WERROR status; 883 884 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 885 return WERR_FOOBAR; 886 } 887 888 for (i=0; i < in->num_values; i++) { 889 if (in->values[i].length == 0) { 890 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 891 } 892 893 status = dsdb_syntax_DATA_BLOB_validate_one_val(ctx, 894 attr, 895 &in->values[i]); 896 if (!W_ERROR_IS_OK(status)) { 897 return status; 898 } 899 } 900 901 return WERR_OK; 902 } 903 904 static WERROR _dsdb_syntax_auto_OID_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 905 const struct dsdb_attribute *attr, 906 const struct drsuapi_DsReplicaAttribute *in, 907 TALLOC_CTX *mem_ctx, 908 struct ldb_message_element *out) 909 { 910 unsigned int i; 911 912 out->flags = 0; 913 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName); 914 W_ERROR_HAVE_NO_MEMORY(out->name); 915 916 out->num_values = in->value_ctr.num_values; 917 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values); 918 W_ERROR_HAVE_NO_MEMORY(out->values); 919 920 for (i=0; i < out->num_values; i++) { 921 uint32_t v; 922 const struct dsdb_class *c; 923 const struct dsdb_attribute *a; 924 const char *str = NULL; 925 926 if (in->value_ctr.values[i].blob == NULL) { 927 return WERR_FOOBAR; 928 } 929 930 if (in->value_ctr.values[i].blob->length != 4) { 931 return WERR_FOOBAR; 932 } 933 934 v = IVAL(in->value_ctr.values[i].blob->data, 0); 935 936 if ((c = dsdb_class_by_governsID_id(ctx->schema, v))) { 937 str = talloc_strdup(out->values, c->lDAPDisplayName); 938 } else if ((a = dsdb_attribute_by_attributeID_id(ctx->schema, v))) { 939 str = talloc_strdup(out->values, a->lDAPDisplayName); 940 } else { 941 WERROR werr; 942 SMB_ASSERT(ctx->pfm_remote); 943 werr = dsdb_schema_pfm_oid_from_attid(ctx->pfm_remote, v, 944 out->values, &str); 945 W_ERROR_NOT_OK_RETURN(werr); 946 } 947 W_ERROR_HAVE_NO_MEMORY(str); 948 949 /* the values need to be reversed */ 950 out->values[out->num_values - (i + 1)] = data_blob_string_const(str); 951 } 952 953 return WERR_OK; 954 } 955 956 static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 577 957 const struct dsdb_attribute *attr, 578 958 const struct drsuapi_DsReplicaAttribute *in, … … 580 960 struct ldb_message_element *out) 581 961 { 582 u int32_t i;962 unsigned int i; 583 963 584 964 out->flags = 0; … … 605 985 v = IVAL(in->value_ctr.values[i].blob->data, 0); 606 986 607 c = dsdb_class_by_governsID_id(schema, v); 987 /* convert remote ATTID to local ATTID */ 988 if (!dsdb_syntax_attid_from_remote_attid(ctx, mem_ctx, v, &v)) { 989 DEBUG(1,(__location__ ": Failed to map remote ATTID to local ATTID!\n")); 990 return WERR_FOOBAR; 991 } 992 993 c = dsdb_class_by_governsID_id(ctx->schema, v); 608 994 if (!c) { 995 DEBUG(1,(__location__ ": Unknown governsID 0x%08X\n", v)); 609 996 return WERR_FOOBAR; 610 997 } … … 620 1007 } 621 1008 622 static WERROR _dsdb_syntax_OID_attr_drsuapi_to_ldb(struct ldb_context *ldb, 623 const struct dsdb_schema *schema, 1009 static WERROR _dsdb_syntax_OID_attr_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 624 1010 const struct dsdb_attribute *attr, 625 1011 const struct drsuapi_DsReplicaAttribute *in, … … 627 1013 struct ldb_message_element *out) 628 1014 { 629 u int32_t i;1015 unsigned int i; 630 1016 631 1017 out->flags = 0; … … 652 1038 v = IVAL(in->value_ctr.values[i].blob->data, 0); 653 1039 654 a = dsdb_attribute_by_attributeID_id(schema, v); 1040 /* convert remote ATTID to local ATTID */ 1041 if (!dsdb_syntax_attid_from_remote_attid(ctx, mem_ctx, v, &v)) { 1042 DEBUG(1,(__location__ ": Failed to map remote ATTID to local ATTID!\n")); 1043 return WERR_FOOBAR; 1044 } 1045 1046 a = dsdb_attribute_by_attributeID_id(ctx->schema, v); 655 1047 if (!a) { 1048 DEBUG(1,(__location__ ": Unknown attributeID_id 0x%08X\n", v)); 656 1049 return WERR_FOOBAR; 657 1050 } … … 667 1060 } 668 1061 669 static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(struct ldb_context *ldb, 670 const struct dsdb_schema *schema, 1062 static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 671 1063 const struct dsdb_attribute *attr, 672 1064 const struct drsuapi_DsReplicaAttribute *in, … … 674 1066 struct ldb_message_element *out) 675 1067 { 676 uint32_t i; 1068 unsigned int i; 1069 1070 SMB_ASSERT(ctx->pfm_remote); 677 1071 678 1072 out->flags = 0; … … 685 1079 686 1080 for (i=0; i < out->num_values; i++) { 687 uint32_t v;1081 uint32_t attid; 688 1082 WERROR status; 689 const char * str;1083 const char *oid; 690 1084 691 1085 if (in->value_ctr.values[i].blob == NULL) { … … 697 1091 } 698 1092 699 v = IVAL(in->value_ctr.values[i].blob->data, 0); 700 701 status = dsdb_map_int2oid(schema, v, out->values, &str); 702 W_ERROR_NOT_OK_RETURN(status); 703 704 out->values[i] = data_blob_string_const(str); 705 } 706 707 return WERR_OK; 708 } 709 710 static WERROR _dsdb_syntax_OID_obj_ldb_to_drsuapi(struct ldb_context *ldb, 711 const struct dsdb_schema *schema, 712 const struct dsdb_attribute *attr, 713 const struct ldb_message_element *in, 714 TALLOC_CTX *mem_ctx, 715 struct drsuapi_DsReplicaAttribute *out) 716 { 717 uint32_t i; 1093 attid = IVAL(in->value_ctr.values[i].blob->data, 0); 1094 1095 status = dsdb_schema_pfm_oid_from_attid(ctx->pfm_remote, attid, 1096 out->values, &oid); 1097 if (!W_ERROR_IS_OK(status)) { 1098 DEBUG(0,(__location__ ": Error: Unknown ATTID 0x%08X\n", 1099 attid)); 1100 return status; 1101 } 1102 1103 out->values[i] = data_blob_string_const(oid); 1104 } 1105 1106 return WERR_OK; 1107 } 1108 1109 static WERROR _dsdb_syntax_auto_OID_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 1110 const struct dsdb_attribute *attr, 1111 const struct ldb_message_element *in, 1112 TALLOC_CTX *mem_ctx, 1113 struct drsuapi_DsReplicaAttribute *out) 1114 { 1115 unsigned int i; 718 1116 DATA_BLOB *blobs; 719 1117 720 out->attid= attr->attributeID_id; 1118 out->attid= dsdb_attribute_get_attid(attr, 1119 ctx->is_schema_nc); 721 1120 out->value_ctr.num_values= in->num_values; 722 1121 out->value_ctr.values= talloc_array(mem_ctx, … … 730 1129 for (i=0; i < in->num_values; i++) { 731 1130 const struct dsdb_class *obj_class; 1131 const struct dsdb_attribute *obj_attr; 1132 struct ldb_val *v; 732 1133 733 1134 out->value_ctr.values[i].blob= &blobs[i]; … … 736 1137 W_ERROR_HAVE_NO_MEMORY(blobs[i].data); 737 1138 738 obj_class = dsdb_class_by_lDAPDisplayName(schema, (const char *)in->values[i].data); 739 if (!obj_class) { 740 return WERR_FOOBAR; 741 } 742 SIVAL(blobs[i].data, 0, obj_class->governsID_id); 1139 /* in DRS windows puts the classes in the opposite 1140 order to the order used in ldap */ 1141 v = &in->values[(in->num_values-1)-i]; 1142 1143 if ((obj_class = dsdb_class_by_lDAPDisplayName_ldb_val(ctx->schema, v))) { 1144 SIVAL(blobs[i].data, 0, obj_class->governsID_id); 1145 } else if ((obj_attr = dsdb_attribute_by_lDAPDisplayName_ldb_val(ctx->schema, v))) { 1146 SIVAL(blobs[i].data, 0, obj_attr->attributeID_id); 1147 } else { 1148 uint32_t attid; 1149 WERROR werr; 1150 werr = dsdb_schema_pfm_attid_from_oid(ctx->schema->prefixmap, 1151 (const char *)v->data, 1152 &attid); 1153 W_ERROR_NOT_OK_RETURN(werr); 1154 SIVAL(blobs[i].data, 0, attid); 1155 } 1156 743 1157 } 744 1158 … … 747 1161 } 748 1162 749 static WERROR _dsdb_syntax_OID_attr_ldb_to_drsuapi(struct ldb_context *ldb, 750 const struct dsdb_schema *schema, 751 const struct dsdb_attribute *attr, 752 const struct ldb_message_element *in, 753 TALLOC_CTX *mem_ctx, 754 struct drsuapi_DsReplicaAttribute *out) 755 { 756 uint32_t i; 1163 static WERROR _dsdb_syntax_OID_obj_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 1164 const struct dsdb_attribute *attr, 1165 const struct ldb_message_element *in, 1166 TALLOC_CTX *mem_ctx, 1167 struct drsuapi_DsReplicaAttribute *out) 1168 { 1169 unsigned int i; 757 1170 DATA_BLOB *blobs; 758 1171 759 out->attid= attr->attributeID_id; 1172 out->attid= dsdb_attribute_get_attid(attr, 1173 ctx->is_schema_nc); 760 1174 out->value_ctr.num_values= in->num_values; 761 1175 out->value_ctr.values= talloc_array(mem_ctx, … … 768 1182 769 1183 for (i=0; i < in->num_values; i++) { 770 const struct dsdb_ attribute *obj_attr;1184 const struct dsdb_class *obj_class; 771 1185 772 1186 out->value_ctr.values[i].blob= &blobs[i]; … … 775 1189 W_ERROR_HAVE_NO_MEMORY(blobs[i].data); 776 1190 777 obj_attr = dsdb_attribute_by_lDAPDisplayName(schema, (const char *)in->values[i].data); 1191 /* in DRS windows puts the classes in the opposite 1192 order to the order used in ldap */ 1193 obj_class = dsdb_class_by_lDAPDisplayName(ctx->schema, 1194 (const char *)in->values[(in->num_values-1)-i].data); 1195 if (!obj_class) { 1196 return WERR_FOOBAR; 1197 } 1198 SIVAL(blobs[i].data, 0, obj_class->governsID_id); 1199 } 1200 1201 1202 return WERR_OK; 1203 } 1204 1205 static WERROR _dsdb_syntax_OID_attr_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 1206 const struct dsdb_attribute *attr, 1207 const struct ldb_message_element *in, 1208 TALLOC_CTX *mem_ctx, 1209 struct drsuapi_DsReplicaAttribute *out) 1210 { 1211 unsigned int i; 1212 DATA_BLOB *blobs; 1213 1214 out->attid= dsdb_attribute_get_attid(attr, 1215 ctx->is_schema_nc); 1216 out->value_ctr.num_values= in->num_values; 1217 out->value_ctr.values= talloc_array(mem_ctx, 1218 struct drsuapi_DsAttributeValue, 1219 in->num_values); 1220 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values); 1221 1222 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values); 1223 W_ERROR_HAVE_NO_MEMORY(blobs); 1224 1225 for (i=0; i < in->num_values; i++) { 1226 const struct dsdb_attribute *obj_attr; 1227 1228 out->value_ctr.values[i].blob= &blobs[i]; 1229 1230 blobs[i] = data_blob_talloc(blobs, NULL, 4); 1231 W_ERROR_HAVE_NO_MEMORY(blobs[i].data); 1232 1233 obj_attr = dsdb_attribute_by_lDAPDisplayName(ctx->schema, (const char *)in->values[i].data); 778 1234 if (!obj_attr) { 779 1235 return WERR_FOOBAR; … … 786 1242 } 787 1243 788 static WERROR _dsdb_syntax_OID_oid_ldb_to_drsuapi(struct ldb_context *ldb, 789 const struct dsdb_schema *schema, 1244 static WERROR _dsdb_syntax_OID_oid_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 790 1245 const struct dsdb_attribute *attr, 791 1246 const struct ldb_message_element *in, … … 793 1248 struct drsuapi_DsReplicaAttribute *out) 794 1249 { 795 u int32_t i;1250 unsigned int i; 796 1251 DATA_BLOB *blobs; 797 1252 798 out->attid= attr->attributeID_id; 1253 out->attid= dsdb_attribute_get_attid(attr, 1254 ctx->is_schema_nc); 799 1255 out->value_ctr.num_values= in->num_values; 800 1256 out->value_ctr.values= talloc_array(mem_ctx, … … 807 1263 808 1264 for (i=0; i < in->num_values; i++) { 809 uint32_t v;1265 uint32_t attid; 810 1266 WERROR status; 811 1267 … … 815 1271 W_ERROR_HAVE_NO_MEMORY(blobs[i].data); 816 1272 817 status = dsdb_ map_oid2int(schema,818 (const char *)in->values[i].data,819 &v);1273 status = dsdb_schema_pfm_attid_from_oid(ctx->schema->prefixmap, 1274 (const char *)in->values[i].data, 1275 &attid); 820 1276 W_ERROR_NOT_OK_RETURN(status); 821 1277 822 SIVAL(blobs[i].data, 0, v); 823 } 824 825 return WERR_OK; 826 } 827 828 static WERROR dsdb_syntax_OID_drsuapi_to_ldb(struct ldb_context *ldb, 829 const struct dsdb_schema *schema, 1278 SIVAL(blobs[i].data, 0, attid); 1279 } 1280 1281 return WERR_OK; 1282 } 1283 1284 static WERROR dsdb_syntax_OID_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 830 1285 const struct dsdb_attribute *attr, 831 1286 const struct drsuapi_DsReplicaAttribute *in, … … 833 1288 struct ldb_message_element *out) 834 1289 { 835 uint32_t i;1290 WERROR werr; 836 1291 837 1292 switch (attr->attributeID_id) { 838 case DRSUAPI_ATTRIBUTE_objectClass: 839 case DRSUAPI_ATTRIBUTE_subClassOf: 840 case DRSUAPI_ATTRIBUTE_auxiliaryClass: 841 case DRSUAPI_ATTRIBUTE_systemPossSuperiors: 842 case DRSUAPI_ATTRIBUTE_possSuperiors: 843 return _dsdb_syntax_OID_obj_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out); 844 case DRSUAPI_ATTRIBUTE_systemMustContain: 845 case DRSUAPI_ATTRIBUTE_systemMayContain: 846 case DRSUAPI_ATTRIBUTE_mustContain: 847 case DRSUAPI_ATTRIBUTE_mayContain: 848 return _dsdb_syntax_OID_attr_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out); 849 case DRSUAPI_ATTRIBUTE_governsID: 850 case DRSUAPI_ATTRIBUTE_attributeID: 851 case DRSUAPI_ATTRIBUTE_attributeSyntax: 852 return _dsdb_syntax_OID_oid_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out); 853 } 854 855 out->flags = 0; 856 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName); 857 W_ERROR_HAVE_NO_MEMORY(out->name); 858 859 out->num_values = in->value_ctr.num_values; 860 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values); 861 W_ERROR_HAVE_NO_MEMORY(out->values); 862 863 for (i=0; i < out->num_values; i++) { 864 uint32_t v; 865 const char *name; 866 char *str; 867 868 if (in->value_ctr.values[i].blob == NULL) { 869 return WERR_FOOBAR; 870 } 871 872 if (in->value_ctr.values[i].blob->length != 4) { 873 return WERR_FOOBAR; 874 } 875 876 v = IVAL(in->value_ctr.values[i].blob->data, 0); 877 878 name = dsdb_lDAPDisplayName_by_id(schema, v); 879 if (!name) { 880 return WERR_FOOBAR; 881 } 882 883 str = talloc_strdup(out->values, name); 884 W_ERROR_HAVE_NO_MEMORY(str); 885 886 out->values[i] = data_blob_string_const(str); 887 } 888 889 return WERR_OK; 890 } 891 892 static WERROR dsdb_syntax_OID_ldb_to_drsuapi(struct ldb_context *ldb, 893 const struct dsdb_schema *schema, 1293 case DRSUAPI_ATTID_objectClass: 1294 case DRSUAPI_ATTID_subClassOf: 1295 case DRSUAPI_ATTID_auxiliaryClass: 1296 case DRSUAPI_ATTID_systemAuxiliaryClass: 1297 case DRSUAPI_ATTID_systemPossSuperiors: 1298 case DRSUAPI_ATTID_possSuperiors: 1299 werr = _dsdb_syntax_OID_obj_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out); 1300 break; 1301 case DRSUAPI_ATTID_systemMustContain: 1302 case DRSUAPI_ATTID_systemMayContain: 1303 case DRSUAPI_ATTID_mustContain: 1304 case DRSUAPI_ATTID_rDNAttId: 1305 case DRSUAPI_ATTID_transportAddressAttribute: 1306 case DRSUAPI_ATTID_mayContain: 1307 werr = _dsdb_syntax_OID_attr_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out); 1308 break; 1309 case DRSUAPI_ATTID_governsID: 1310 case DRSUAPI_ATTID_attributeID: 1311 case DRSUAPI_ATTID_attributeSyntax: 1312 werr = _dsdb_syntax_OID_oid_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out); 1313 break; 1314 default: 1315 DEBUG(0,(__location__ ": Unknown handling for attributeID_id for %s\n", 1316 attr->lDAPDisplayName)); 1317 return _dsdb_syntax_auto_OID_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out); 1318 } 1319 1320 /* When we are doing the vampire of a schema, we don't want 1321 * the inability to reference an OID to get in the way. 1322 * Otherwise, we won't get the new schema with which to 1323 * understand this */ 1324 if (!W_ERROR_IS_OK(werr) && ctx->schema->relax_OID_conversions) { 1325 return _dsdb_syntax_OID_oid_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out); 1326 } 1327 return werr; 1328 } 1329 1330 static WERROR dsdb_syntax_OID_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 894 1331 const struct dsdb_attribute *attr, 895 1332 const struct ldb_message_element *in, … … 897 1334 struct drsuapi_DsReplicaAttribute *out) 898 1335 { 899 uint32_t i; 1336 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1337 return WERR_FOOBAR; 1338 } 1339 1340 switch (attr->attributeID_id) { 1341 case DRSUAPI_ATTID_objectClass: 1342 case DRSUAPI_ATTID_subClassOf: 1343 case DRSUAPI_ATTID_auxiliaryClass: 1344 case DRSUAPI_ATTID_systemAuxiliaryClass: 1345 case DRSUAPI_ATTID_systemPossSuperiors: 1346 case DRSUAPI_ATTID_possSuperiors: 1347 return _dsdb_syntax_OID_obj_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out); 1348 case DRSUAPI_ATTID_systemMustContain: 1349 case DRSUAPI_ATTID_systemMayContain: 1350 case DRSUAPI_ATTID_mustContain: 1351 case DRSUAPI_ATTID_rDNAttId: 1352 case DRSUAPI_ATTID_transportAddressAttribute: 1353 case DRSUAPI_ATTID_mayContain: 1354 return _dsdb_syntax_OID_attr_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out); 1355 case DRSUAPI_ATTID_governsID: 1356 case DRSUAPI_ATTID_attributeID: 1357 case DRSUAPI_ATTID_attributeSyntax: 1358 return _dsdb_syntax_OID_oid_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out); 1359 } 1360 1361 DEBUG(0,(__location__ ": Unknown handling for attributeID_id for %s\n", 1362 attr->lDAPDisplayName)); 1363 1364 return _dsdb_syntax_auto_OID_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out); 1365 } 1366 1367 static WERROR _dsdb_syntax_OID_validate_numericoid(const struct dsdb_syntax_ctx *ctx, 1368 const struct dsdb_attribute *attr, 1369 const struct ldb_message_element *in) 1370 { 1371 unsigned int i; 1372 TALLOC_CTX *tmp_ctx; 1373 1374 tmp_ctx = talloc_new(ctx->ldb); 1375 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 1376 1377 for (i=0; i < in->num_values; i++) { 1378 DATA_BLOB blob; 1379 char *oid_out; 1380 const char *oid = (const char*)in->values[i].data; 1381 1382 if (!ber_write_OID_String(tmp_ctx, &blob, oid)) { 1383 DEBUG(0,("ber_write_OID_String() failed for %s\n", oid)); 1384 talloc_free(tmp_ctx); 1385 return WERR_INVALID_PARAMETER; 1386 } 1387 1388 if (!ber_read_OID_String(tmp_ctx, blob, &oid_out)) { 1389 DEBUG(0,("ber_read_OID_String() failed for %s\n", 1390 hex_encode_talloc(tmp_ctx, blob.data, blob.length))); 1391 talloc_free(tmp_ctx); 1392 return WERR_INVALID_PARAMETER; 1393 } 1394 1395 if (strcmp(oid, oid_out) != 0) { 1396 talloc_free(tmp_ctx); 1397 return WERR_INVALID_PARAMETER; 1398 } 1399 } 1400 1401 talloc_free(tmp_ctx); 1402 return WERR_OK; 1403 } 1404 1405 static WERROR dsdb_syntax_OID_validate_ldb(const struct dsdb_syntax_ctx *ctx, 1406 const struct dsdb_attribute *attr, 1407 const struct ldb_message_element *in) 1408 { 1409 WERROR status; 1410 struct drsuapi_DsReplicaAttribute drs_tmp; 1411 struct ldb_message_element ldb_tmp; 1412 TALLOC_CTX *tmp_ctx; 1413 1414 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1415 return WERR_FOOBAR; 1416 } 1417 1418 switch (attr->attributeID_id) { 1419 case DRSUAPI_ATTID_governsID: 1420 case DRSUAPI_ATTID_attributeID: 1421 case DRSUAPI_ATTID_attributeSyntax: 1422 return _dsdb_syntax_OID_validate_numericoid(ctx, attr, in); 1423 } 1424 1425 /* 1426 * TODO: optimize and verify this code 1427 */ 1428 1429 tmp_ctx = talloc_new(ctx->ldb); 1430 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 1431 1432 status = dsdb_syntax_OID_ldb_to_drsuapi(ctx, 1433 attr, 1434 in, 1435 tmp_ctx, 1436 &drs_tmp); 1437 if (!W_ERROR_IS_OK(status)) { 1438 talloc_free(tmp_ctx); 1439 return status; 1440 } 1441 1442 status = dsdb_syntax_OID_drsuapi_to_ldb(ctx, 1443 attr, 1444 &drs_tmp, 1445 tmp_ctx, 1446 &ldb_tmp); 1447 if (!W_ERROR_IS_OK(status)) { 1448 talloc_free(tmp_ctx); 1449 return status; 1450 } 1451 1452 talloc_free(tmp_ctx); 1453 return WERR_OK; 1454 } 1455 1456 static WERROR dsdb_syntax_UNICODE_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 1457 const struct dsdb_attribute *attr, 1458 const struct drsuapi_DsReplicaAttribute *in, 1459 TALLOC_CTX *mem_ctx, 1460 struct ldb_message_element *out) 1461 { 1462 unsigned int i; 1463 1464 out->flags = 0; 1465 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName); 1466 W_ERROR_HAVE_NO_MEMORY(out->name); 1467 1468 out->num_values = in->value_ctr.num_values; 1469 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values); 1470 W_ERROR_HAVE_NO_MEMORY(out->values); 1471 1472 for (i=0; i < out->num_values; i++) { 1473 char *str; 1474 1475 if (in->value_ctr.values[i].blob == NULL) { 1476 return WERR_FOOBAR; 1477 } 1478 1479 if (in->value_ctr.values[i].blob->length == 0) { 1480 return WERR_FOOBAR; 1481 } 1482 1483 if (!convert_string_talloc(out->values, 1484 CH_UTF16, CH_UNIX, 1485 in->value_ctr.values[i].blob->data, 1486 in->value_ctr.values[i].blob->length, 1487 (void **)&str, NULL, false)) { 1488 return WERR_FOOBAR; 1489 } 1490 1491 out->values[i] = data_blob_string_const(str); 1492 } 1493 1494 return WERR_OK; 1495 } 1496 1497 static WERROR dsdb_syntax_UNICODE_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 1498 const struct dsdb_attribute *attr, 1499 const struct ldb_message_element *in, 1500 TALLOC_CTX *mem_ctx, 1501 struct drsuapi_DsReplicaAttribute *out) 1502 { 1503 unsigned int i; 900 1504 DATA_BLOB *blobs; 901 1505 902 if (attr->attributeID_id == 0xFFFFFFFF) { 903 return WERR_FOOBAR; 904 } 905 906 switch (attr->attributeID_id) { 907 case DRSUAPI_ATTRIBUTE_objectClass: 908 case DRSUAPI_ATTRIBUTE_subClassOf: 909 case DRSUAPI_ATTRIBUTE_auxiliaryClass: 910 case DRSUAPI_ATTRIBUTE_systemPossSuperiors: 911 case DRSUAPI_ATTRIBUTE_possSuperiors: 912 return _dsdb_syntax_OID_obj_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out); 913 case DRSUAPI_ATTRIBUTE_systemMustContain: 914 case DRSUAPI_ATTRIBUTE_systemMayContain: 915 case DRSUAPI_ATTRIBUTE_mustContain: 916 case DRSUAPI_ATTRIBUTE_mayContain: 917 return _dsdb_syntax_OID_attr_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out); 918 case DRSUAPI_ATTRIBUTE_governsID: 919 case DRSUAPI_ATTRIBUTE_attributeID: 920 case DRSUAPI_ATTRIBUTE_attributeSyntax: 921 return _dsdb_syntax_OID_oid_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out); 922 } 923 924 out->attid = attr->attributeID_id; 1506 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1507 return WERR_FOOBAR; 1508 } 1509 1510 out->attid = dsdb_attribute_get_attid(attr, 1511 ctx->is_schema_nc); 925 1512 out->value_ctr.num_values = in->num_values; 926 1513 out->value_ctr.values = talloc_array(mem_ctx, … … 933 1520 934 1521 for (i=0; i < in->num_values; i++) { 935 uint32_t v;936 937 1522 out->value_ctr.values[i].blob = &blobs[i]; 938 1523 939 blobs[i] = data_blob_talloc(blobs, NULL, 4); 940 W_ERROR_HAVE_NO_MEMORY(blobs[i].data); 941 942 v = strtol((const char *)in->values[i].data, NULL, 10); 943 944 SIVAL(blobs[i].data, 0, v); 945 } 946 947 return WERR_OK; 948 } 949 950 static WERROR dsdb_syntax_UNICODE_drsuapi_to_ldb(struct ldb_context *ldb, 951 const struct dsdb_schema *schema, 952 const struct dsdb_attribute *attr, 953 const struct drsuapi_DsReplicaAttribute *in, 954 TALLOC_CTX *mem_ctx, 955 struct ldb_message_element *out) 956 { 957 uint32_t i; 1524 if (!convert_string_talloc(blobs, 1525 CH_UNIX, CH_UTF16, 1526 in->values[i].data, in->values[i].length, 1527 (void **)&blobs[i].data, &blobs[i].length, false)) { 1528 return WERR_FOOBAR; 1529 } 1530 } 1531 1532 return WERR_OK; 1533 } 1534 1535 static WERROR dsdb_syntax_UNICODE_validate_one_val(const struct dsdb_syntax_ctx *ctx, 1536 const struct dsdb_attribute *attr, 1537 const struct ldb_val *val) 1538 { 1539 void *dst = NULL; 1540 size_t size; 1541 bool ok; 1542 1543 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1544 return WERR_FOOBAR; 1545 } 1546 1547 ok = convert_string_talloc(ctx->ldb, 1548 CH_UNIX, CH_UTF16, 1549 val->data, 1550 val->length, 1551 (void **)&dst, 1552 &size, false); 1553 TALLOC_FREE(dst); 1554 if (!ok) { 1555 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1556 } 1557 1558 if (attr->rangeLower) { 1559 if ((size/2) < *attr->rangeLower) { 1560 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1561 } 1562 } 1563 1564 if (attr->rangeUpper) { 1565 if ((size/2) > *attr->rangeUpper) { 1566 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1567 } 1568 } 1569 1570 return WERR_OK; 1571 } 1572 1573 static WERROR dsdb_syntax_UNICODE_validate_ldb(const struct dsdb_syntax_ctx *ctx, 1574 const struct dsdb_attribute *attr, 1575 const struct ldb_message_element *in) 1576 { 1577 WERROR status; 1578 unsigned int i; 1579 1580 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1581 return WERR_FOOBAR; 1582 } 1583 1584 for (i=0; i < in->num_values; i++) { 1585 if (in->values[i].length == 0) { 1586 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1587 } 1588 1589 status = dsdb_syntax_UNICODE_validate_one_val(ctx, 1590 attr, 1591 &in->values[i]); 1592 if (!W_ERROR_IS_OK(status)) { 1593 return status; 1594 } 1595 } 1596 1597 return WERR_OK; 1598 } 1599 1600 static WERROR dsdb_syntax_one_DN_drsuapi_to_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, 1601 const struct dsdb_syntax *syntax, 1602 const DATA_BLOB *in, DATA_BLOB *out) 1603 { 1604 struct drsuapi_DsReplicaObjectIdentifier3 id3; 1605 enum ndr_err_code ndr_err; 1606 DATA_BLOB guid_blob; 1607 struct ldb_dn *dn; 1608 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx); 1609 int ret; 1610 NTSTATUS status; 1611 1612 if (!tmp_ctx) { 1613 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 1614 } 1615 1616 if (in == NULL) { 1617 talloc_free(tmp_ctx); 1618 return WERR_FOOBAR; 1619 } 1620 1621 if (in->length == 0) { 1622 talloc_free(tmp_ctx); 1623 return WERR_FOOBAR; 1624 } 1625 1626 1627 /* windows sometimes sends an extra two pad bytes here */ 1628 ndr_err = ndr_pull_struct_blob(in, 1629 tmp_ctx, &id3, 1630 (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3); 1631 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1632 status = ndr_map_error2ntstatus(ndr_err); 1633 talloc_free(tmp_ctx); 1634 return ntstatus_to_werror(status); 1635 } 1636 1637 dn = ldb_dn_new(tmp_ctx, ldb, id3.dn); 1638 if (!dn) { 1639 talloc_free(tmp_ctx); 1640 /* If this fails, it must be out of memory, as it does not do much parsing */ 1641 W_ERROR_HAVE_NO_MEMORY(dn); 1642 } 1643 1644 if (!GUID_all_zero(&id3.guid)) { 1645 status = GUID_to_ndr_blob(&id3.guid, tmp_ctx, &guid_blob); 1646 if (!NT_STATUS_IS_OK(status)) { 1647 talloc_free(tmp_ctx); 1648 return ntstatus_to_werror(status); 1649 } 1650 1651 ret = ldb_dn_set_extended_component(dn, "GUID", &guid_blob); 1652 if (ret != LDB_SUCCESS) { 1653 talloc_free(tmp_ctx); 1654 return WERR_FOOBAR; 1655 } 1656 talloc_free(guid_blob.data); 1657 } 1658 1659 if (id3.__ndr_size_sid) { 1660 DATA_BLOB sid_blob; 1661 ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, &id3.sid, 1662 (ndr_push_flags_fn_t)ndr_push_dom_sid); 1663 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1664 status = ndr_map_error2ntstatus(ndr_err); 1665 talloc_free(tmp_ctx); 1666 return ntstatus_to_werror(status); 1667 } 1668 1669 ret = ldb_dn_set_extended_component(dn, "SID", &sid_blob); 1670 if (ret != LDB_SUCCESS) { 1671 talloc_free(tmp_ctx); 1672 return WERR_FOOBAR; 1673 } 1674 } 1675 1676 *out = data_blob_string_const(ldb_dn_get_extended_linearized(mem_ctx, dn, 1)); 1677 talloc_free(tmp_ctx); 1678 return WERR_OK; 1679 } 1680 1681 static WERROR dsdb_syntax_DN_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 1682 const struct dsdb_attribute *attr, 1683 const struct drsuapi_DsReplicaAttribute *in, 1684 TALLOC_CTX *mem_ctx, 1685 struct ldb_message_element *out) 1686 { 1687 unsigned int i; 958 1688 959 1689 out->flags = 0; … … 966 1696 967 1697 for (i=0; i < out->num_values; i++) { 968 char *str; 969 970 if (in->value_ctr.values[i].blob == NULL) { 971 return WERR_FOOBAR; 972 } 973 974 if (in->value_ctr.values[i].blob->length == 0) { 975 return WERR_FOOBAR; 976 } 977 978 if (!convert_string_talloc_convenience(out->values, 979 schema->iconv_convenience, 980 CH_UTF16, CH_UNIX, 981 in->value_ctr.values[i].blob->data, 982 in->value_ctr.values[i].blob->length, 983 (void **)&str, NULL, false)) { 984 return WERR_FOOBAR; 985 } 986 987 out->values[i] = data_blob_string_const(str); 988 } 989 990 return WERR_OK; 991 } 992 993 static WERROR dsdb_syntax_UNICODE_ldb_to_drsuapi(struct ldb_context *ldb, 994 const struct dsdb_schema *schema, 995 const struct dsdb_attribute *attr, 996 const struct ldb_message_element *in, 997 TALLOC_CTX *mem_ctx, 998 struct drsuapi_DsReplicaAttribute *out) 999 { 1000 uint32_t i; 1698 WERROR status = dsdb_syntax_one_DN_drsuapi_to_ldb(out->values, ctx->ldb, attr->syntax, 1699 in->value_ctr.values[i].blob, 1700 &out->values[i]); 1701 if (!W_ERROR_IS_OK(status)) { 1702 return status; 1703 } 1704 1705 } 1706 1707 return WERR_OK; 1708 } 1709 1710 static WERROR dsdb_syntax_DN_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 1711 const struct dsdb_attribute *attr, 1712 const struct ldb_message_element *in, 1713 TALLOC_CTX *mem_ctx, 1714 struct drsuapi_DsReplicaAttribute *out) 1715 { 1716 unsigned int i; 1001 1717 DATA_BLOB *blobs; 1002 1718 1003 if (attr->attributeID_id == 0xFFFFFFFF) { 1004 return WERR_FOOBAR; 1005 } 1006 1007 out->attid = attr->attributeID_id; 1719 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1720 return WERR_FOOBAR; 1721 } 1722 1723 out->attid = dsdb_attribute_get_attid(attr, 1724 ctx->is_schema_nc); 1008 1725 out->value_ctr.num_values = in->num_values; 1009 1726 out->value_ctr.values = talloc_array(mem_ctx, … … 1016 1733 1017 1734 for (i=0; i < in->num_values; i++) { 1735 struct drsuapi_DsReplicaObjectIdentifier3 id3; 1736 enum ndr_err_code ndr_err; 1737 struct ldb_dn *dn; 1738 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx); 1739 NTSTATUS status; 1740 1741 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 1742 1018 1743 out->value_ctr.values[i].blob = &blobs[i]; 1019 1744 1020 if (!convert_string_talloc_convenience(blobs, 1021 schema->iconv_convenience, CH_UNIX, CH_UTF16, 1022 in->values[i].data, in->values[i].length, 1023 (void **)&blobs[i].data, &blobs[i].length, false)) { 1024 return WERR_FOOBAR; 1025 } 1026 } 1027 1028 return WERR_OK; 1029 } 1030 1031 static WERROR dsdb_syntax_DN_drsuapi_to_ldb(struct ldb_context *ldb, 1032 const struct dsdb_schema *schema, 1033 const struct dsdb_attribute *attr, 1034 const struct drsuapi_DsReplicaAttribute *in, 1035 TALLOC_CTX *mem_ctx, 1036 struct ldb_message_element *out) 1037 { 1038 uint32_t i; 1745 dn = ldb_dn_from_ldb_val(tmp_ctx, ctx->ldb, &in->values[i]); 1746 1747 W_ERROR_HAVE_NO_MEMORY(dn); 1748 1749 ZERO_STRUCT(id3); 1750 1751 status = dsdb_get_extended_dn_guid(dn, &id3.guid, "GUID"); 1752 if (!NT_STATUS_IS_OK(status) && 1753 !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { 1754 talloc_free(tmp_ctx); 1755 return ntstatus_to_werror(status); 1756 } 1757 1758 status = dsdb_get_extended_dn_sid(dn, &id3.sid, "SID"); 1759 if (!NT_STATUS_IS_OK(status) && 1760 !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { 1761 talloc_free(tmp_ctx); 1762 return ntstatus_to_werror(status); 1763 } 1764 1765 id3.dn = ldb_dn_get_linearized(dn); 1766 1767 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3); 1768 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1769 status = ndr_map_error2ntstatus(ndr_err); 1770 talloc_free(tmp_ctx); 1771 return ntstatus_to_werror(status); 1772 } 1773 talloc_free(tmp_ctx); 1774 } 1775 1776 return WERR_OK; 1777 } 1778 1779 static WERROR dsdb_syntax_DN_validate_one_val(const struct dsdb_syntax_ctx *ctx, 1780 const struct dsdb_attribute *attr, 1781 const struct ldb_val *val, 1782 TALLOC_CTX *mem_ctx, 1783 struct dsdb_dn **_dsdb_dn) 1784 { 1785 static const char * const extended_list[] = { "GUID", "SID", NULL }; 1786 enum ndr_err_code ndr_err; 1787 struct GUID guid; 1788 struct dom_sid sid; 1789 const DATA_BLOB *sid_blob; 1790 struct dsdb_dn *dsdb_dn; 1791 struct ldb_dn *dn; 1792 char *dn_str; 1793 struct ldb_dn *dn2; 1794 char *dn2_str; 1795 int num_components; 1796 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx); 1797 NTSTATUS status; 1798 1799 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 1800 1801 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1802 return WERR_FOOBAR; 1803 } 1804 1805 dsdb_dn = dsdb_dn_parse(tmp_ctx, ctx->ldb, val, 1806 attr->syntax->ldap_oid); 1807 if (!dsdb_dn) { 1808 talloc_free(tmp_ctx); 1809 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1810 } 1811 dn = dsdb_dn->dn; 1812 1813 dn2 = ldb_dn_copy(tmp_ctx, dn); 1814 if (dn == NULL) { 1815 talloc_free(tmp_ctx); 1816 return WERR_NOMEM; 1817 } 1818 1819 num_components = ldb_dn_get_comp_num(dn); 1820 1821 status = dsdb_get_extended_dn_guid(dn, &guid, "GUID"); 1822 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { 1823 num_components++; 1824 } else if (!NT_STATUS_IS_OK(status)) { 1825 talloc_free(tmp_ctx); 1826 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1827 } 1828 1829 sid_blob = ldb_dn_get_extended_component(dn, "SID"); 1830 if (sid_blob) { 1831 num_components++; 1832 ndr_err = ndr_pull_struct_blob_all(sid_blob, 1833 tmp_ctx, 1834 &sid, 1835 (ndr_pull_flags_fn_t)ndr_pull_dom_sid); 1836 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1837 talloc_free(tmp_ctx); 1838 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1839 } 1840 } 1841 1842 /* Do not allow links to the RootDSE */ 1843 if (num_components == 0) { 1844 talloc_free(tmp_ctx); 1845 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1846 } 1847 1848 /* 1849 * We need to check that only "GUID" and "SID" are 1850 * specified as extended components, we do that 1851 * by comparing the dn's after removing all components 1852 * from one dn and only the allowed subset from the other 1853 * one. 1854 */ 1855 ldb_dn_extended_filter(dn, extended_list); 1856 1857 dn_str = ldb_dn_get_extended_linearized(tmp_ctx, dn, 0); 1858 if (dn_str == NULL) { 1859 talloc_free(tmp_ctx); 1860 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1861 } 1862 dn2_str = ldb_dn_get_extended_linearized(tmp_ctx, dn2, 0); 1863 if (dn2_str == NULL) { 1864 talloc_free(tmp_ctx); 1865 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1866 } 1867 1868 if (strcmp(dn_str, dn2_str) != 0) { 1869 talloc_free(tmp_ctx); 1870 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1871 } 1872 1873 *_dsdb_dn = talloc_move(mem_ctx, &dsdb_dn); 1874 talloc_free(tmp_ctx); 1875 return WERR_OK; 1876 } 1877 1878 static WERROR dsdb_syntax_DN_validate_ldb(const struct dsdb_syntax_ctx *ctx, 1879 const struct dsdb_attribute *attr, 1880 const struct ldb_message_element *in) 1881 { 1882 unsigned int i; 1883 1884 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 1885 return WERR_FOOBAR; 1886 } 1887 1888 for (i=0; i < in->num_values; i++) { 1889 WERROR status; 1890 struct dsdb_dn *dsdb_dn; 1891 TALLOC_CTX *tmp_ctx = talloc_new(ctx->ldb); 1892 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 1893 1894 status = dsdb_syntax_DN_validate_one_val(ctx, 1895 attr, 1896 &in->values[i], 1897 tmp_ctx, &dsdb_dn); 1898 if (!W_ERROR_IS_OK(status)) { 1899 talloc_free(tmp_ctx); 1900 return status; 1901 } 1902 1903 if (dsdb_dn->dn_format != DSDB_NORMAL_DN) { 1904 talloc_free(tmp_ctx); 1905 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 1906 } 1907 1908 talloc_free(tmp_ctx); 1909 } 1910 1911 return WERR_OK; 1912 } 1913 1914 static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 1915 const struct dsdb_attribute *attr, 1916 const struct drsuapi_DsReplicaAttribute *in, 1917 TALLOC_CTX *mem_ctx, 1918 struct ldb_message_element *out) 1919 { 1920 unsigned int i; 1039 1921 int ret; 1040 1922 … … 1048 1930 1049 1931 for (i=0; i < out->num_values; i++) { 1050 struct drsuapi_DsReplicaObjectIdentifier3 id3;1932 struct drsuapi_DsReplicaObjectIdentifier3Binary id3; 1051 1933 enum ndr_err_code ndr_err; 1052 1934 DATA_BLOB guid_blob; 1053 1935 struct ldb_dn *dn; 1936 struct dsdb_dn *dsdb_dn; 1937 NTSTATUS status; 1054 1938 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx); 1055 1939 if (!tmp_ctx) { … … 1067 1951 } 1068 1952 1069 1953 1070 1954 /* windows sometimes sends an extra two pad bytes here */ 1071 1955 ndr_err = ndr_pull_struct_blob(in->value_ctr.values[i].blob, 1072 tmp_ctx, schema->iconv_convenience,&id3,1073 (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3 );1956 tmp_ctx, &id3, 1957 (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary); 1074 1958 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1075 NTSTATUSstatus = ndr_map_error2ntstatus(ndr_err);1959 status = ndr_map_error2ntstatus(ndr_err); 1076 1960 talloc_free(tmp_ctx); 1077 1961 return ntstatus_to_werror(status); 1078 1962 } 1079 1963 1080 dn = ldb_dn_new(tmp_ctx, ldb, id3.dn);1964 dn = ldb_dn_new(tmp_ctx, ctx->ldb, id3.dn); 1081 1965 if (!dn) { 1082 1966 talloc_free(tmp_ctx); … … 1085 1969 } 1086 1970 1087 ndr_err = ndr_push_struct_blob(&guid_blob, tmp_ctx, schema->iconv_convenience, &id3.guid, 1088 (ndr_push_flags_fn_t)ndr_push_GUID); 1089 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1090 NTSTATUS status = ndr_map_error2ntstatus(ndr_err); 1971 status = GUID_to_ndr_blob(&id3.guid, tmp_ctx, &guid_blob); 1972 if (!NT_STATUS_IS_OK(status)) { 1091 1973 talloc_free(tmp_ctx); 1092 1974 return ntstatus_to_werror(status); … … 1103 1985 if (id3.__ndr_size_sid) { 1104 1986 DATA_BLOB sid_blob; 1105 ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, schema->iconv_convenience,&id3.sid,1987 ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, &id3.sid, 1106 1988 (ndr_push_flags_fn_t)ndr_push_dom_sid); 1107 1989 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1108 NTSTATUSstatus = ndr_map_error2ntstatus(ndr_err);1990 status = ndr_map_error2ntstatus(ndr_err); 1109 1991 talloc_free(tmp_ctx); 1110 1992 return ntstatus_to_werror(status); … … 1118 2000 } 1119 2001 1120 out->values[i] = data_blob_string_const(ldb_dn_get_extended_linearized(out->values, dn, 1)); 2002 /* set binary stuff */ 2003 dsdb_dn = dsdb_dn_construct(tmp_ctx, dn, id3.binary, attr->syntax->ldap_oid); 2004 if (!dsdb_dn) { 2005 /* If this fails, it must be out of memory, we know the ldap_oid is valid */ 2006 talloc_free(tmp_ctx); 2007 W_ERROR_HAVE_NO_MEMORY(dsdb_dn); 2008 } 2009 out->values[i] = data_blob_string_const(dsdb_dn_get_extended_linearized(out->values, dsdb_dn, 1)); 1121 2010 talloc_free(tmp_ctx); 1122 2011 } … … 1125 2014 } 1126 2015 1127 static WERROR dsdb_syntax_DN_ldb_to_drsuapi(struct ldb_context *ldb, 1128 const struct dsdb_schema *schema, 1129 const struct dsdb_attribute *attr, 1130 const struct ldb_message_element *in, 1131 TALLOC_CTX *mem_ctx, 1132 struct drsuapi_DsReplicaAttribute *out) 1133 { 1134 uint32_t i; 2016 static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 2017 const struct dsdb_attribute *attr, 2018 const struct ldb_message_element *in, 2019 TALLOC_CTX *mem_ctx, 2020 struct drsuapi_DsReplicaAttribute *out) 2021 { 2022 unsigned int i; 1135 2023 DATA_BLOB *blobs; 1136 2024 1137 if (attr->attributeID_id == 0xFFFFFFFF) { 1138 return WERR_FOOBAR; 1139 } 1140 1141 out->attid = attr->attributeID_id; 2025 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 2026 return WERR_FOOBAR; 2027 } 2028 2029 out->attid = dsdb_attribute_get_attid(attr, 2030 ctx->is_schema_nc); 1142 2031 out->value_ctr.num_values = in->num_values; 1143 2032 out->value_ctr.values = talloc_array(mem_ctx, … … 1150 2039 1151 2040 for (i=0; i < in->num_values; i++) { 1152 struct drsuapi_DsReplicaObjectIdentifier3 id3;2041 struct drsuapi_DsReplicaObjectIdentifier3Binary id3; 1153 2042 enum ndr_err_code ndr_err; 1154 const DATA_BLOB * guid_blob, *sid_blob;1155 struct ldb_dn *dn;2043 const DATA_BLOB *sid_blob; 2044 struct dsdb_dn *dsdb_dn; 1156 2045 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx); 2046 NTSTATUS status; 2047 1157 2048 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 1158 2049 1159 2050 out->value_ctr.values[i].blob = &blobs[i]; 1160 2051 1161 dn = ldb_dn_from_ldb_val(tmp_ctx, ldb, &in->values[i]); 1162 1163 W_ERROR_HAVE_NO_MEMORY(dn); 1164 1165 guid_blob = ldb_dn_get_extended_component(dn, "GUID"); 2052 dsdb_dn = dsdb_dn_parse(tmp_ctx, ctx->ldb, &in->values[i], attr->syntax->ldap_oid); 2053 2054 if (!dsdb_dn) { 2055 talloc_free(tmp_ctx); 2056 return ntstatus_to_werror(NT_STATUS_INVALID_PARAMETER); 2057 } 1166 2058 1167 2059 ZERO_STRUCT(id3); 1168 2060 1169 if (guid_blob) { 1170 ndr_err = ndr_pull_struct_blob_all(guid_blob, 1171 tmp_ctx, schema->iconv_convenience, &id3.guid, 1172 (ndr_pull_flags_fn_t)ndr_pull_GUID); 2061 status = dsdb_get_extended_dn_guid(dsdb_dn->dn, &id3.guid, "GUID"); 2062 if (!NT_STATUS_IS_OK(status) && 2063 !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { 2064 talloc_free(tmp_ctx); 2065 return ntstatus_to_werror(status); 2066 } 2067 2068 sid_blob = ldb_dn_get_extended_component(dsdb_dn->dn, "SID"); 2069 if (sid_blob) { 2070 2071 ndr_err = ndr_pull_struct_blob_all(sid_blob, 2072 tmp_ctx, &id3.sid, 2073 (ndr_pull_flags_fn_t)ndr_pull_dom_sid); 1173 2074 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1174 NTSTATUSstatus = ndr_map_error2ntstatus(ndr_err);2075 status = ndr_map_error2ntstatus(ndr_err); 1175 2076 talloc_free(tmp_ctx); 1176 2077 return ntstatus_to_werror(status); … … 1178 2079 } 1179 2080 1180 sid_blob = ldb_dn_get_extended_component(dn, "SID"); 1181 if (sid_blob) { 1182 1183 ndr_err = ndr_pull_struct_blob_all(sid_blob, 1184 tmp_ctx, schema->iconv_convenience, &id3.sid, 1185 (ndr_pull_flags_fn_t)ndr_pull_dom_sid); 1186 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1187 NTSTATUS status = ndr_map_error2ntstatus(ndr_err); 1188 talloc_free(tmp_ctx); 1189 return ntstatus_to_werror(status); 1190 } 1191 } 1192 1193 id3.dn = ldb_dn_get_linearized(dn); 1194 1195 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3); 2081 id3.dn = ldb_dn_get_linearized(dsdb_dn->dn); 2082 2083 /* get binary stuff */ 2084 id3.binary = dsdb_dn->extra_part; 2085 2086 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary); 1196 2087 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1197 NTSTATUSstatus = ndr_map_error2ntstatus(ndr_err);2088 status = ndr_map_error2ntstatus(ndr_err); 1198 2089 talloc_free(tmp_ctx); 1199 2090 return ntstatus_to_werror(status); … … 1205 2096 } 1206 2097 1207 static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(struct ldb_context *ldb, 1208 const struct dsdb_schema *schema, 2098 static WERROR dsdb_syntax_DN_BINARY_validate_ldb(const struct dsdb_syntax_ctx *ctx, 2099 const struct dsdb_attribute *attr, 2100 const struct ldb_message_element *in) 2101 { 2102 unsigned int i; 2103 2104 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 2105 return WERR_FOOBAR; 2106 } 2107 2108 for (i=0; i < in->num_values; i++) { 2109 WERROR status; 2110 struct dsdb_dn *dsdb_dn; 2111 TALLOC_CTX *tmp_ctx = talloc_new(ctx->ldb); 2112 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 2113 2114 status = dsdb_syntax_DN_validate_one_val(ctx, 2115 attr, 2116 &in->values[i], 2117 tmp_ctx, &dsdb_dn); 2118 if (!W_ERROR_IS_OK(status)) { 2119 talloc_free(tmp_ctx); 2120 return status; 2121 } 2122 2123 if (dsdb_dn->dn_format != DSDB_BINARY_DN) { 2124 talloc_free(tmp_ctx); 2125 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 2126 } 2127 2128 status = dsdb_syntax_DATA_BLOB_validate_one_val(ctx, 2129 attr, 2130 &dsdb_dn->extra_part); 2131 if (!W_ERROR_IS_OK(status)) { 2132 talloc_free(tmp_ctx); 2133 return status; 2134 } 2135 2136 talloc_free(tmp_ctx); 2137 } 2138 2139 return WERR_OK; 2140 } 2141 2142 static WERROR dsdb_syntax_DN_STRING_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 1209 2143 const struct dsdb_attribute *attr, 1210 2144 const struct drsuapi_DsReplicaAttribute *in, … … 1212 2146 struct ldb_message_element *out) 1213 2147 { 1214 uint32_t i; 1215 1216 out->flags = 0; 1217 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName); 1218 W_ERROR_HAVE_NO_MEMORY(out->name); 1219 1220 out->num_values = in->value_ctr.num_values; 1221 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values); 1222 W_ERROR_HAVE_NO_MEMORY(out->values); 1223 1224 for (i=0; i < out->num_values; i++) { 1225 struct drsuapi_DsReplicaObjectIdentifier3Binary id3b; 1226 char *binary; 1227 char *str; 1228 enum ndr_err_code ndr_err; 1229 1230 if (in->value_ctr.values[i].blob == NULL) { 1231 return WERR_FOOBAR; 1232 } 1233 1234 if (in->value_ctr.values[i].blob->length == 0) { 1235 return WERR_FOOBAR; 1236 } 1237 1238 ndr_err = ndr_pull_struct_blob_all(in->value_ctr.values[i].blob, 1239 out->values, schema->iconv_convenience, &id3b, 1240 (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary); 1241 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1242 NTSTATUS status = ndr_map_error2ntstatus(ndr_err); 1243 return ntstatus_to_werror(status); 1244 } 1245 1246 /* TODO: handle id3.guid and id3.sid */ 1247 binary = data_blob_hex_string(out->values, &id3b.binary); 1248 W_ERROR_HAVE_NO_MEMORY(binary); 1249 1250 str = talloc_asprintf(out->values, "B:%u:%s:%s", 1251 (unsigned int)(id3b.binary.length * 2), /* because of 2 hex chars per byte */ 1252 binary, 1253 id3b.dn); 1254 W_ERROR_HAVE_NO_MEMORY(str); 1255 1256 /* TODO: handle id3.guid and id3.sid */ 1257 out->values[i] = data_blob_string_const(str); 1258 } 1259 1260 return WERR_OK; 1261 } 1262 1263 static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(struct ldb_context *ldb, 1264 const struct dsdb_schema *schema, 2148 return dsdb_syntax_DN_BINARY_drsuapi_to_ldb(ctx, 2149 attr, 2150 in, 2151 mem_ctx, 2152 out); 2153 } 2154 2155 static WERROR dsdb_syntax_DN_STRING_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 1265 2156 const struct dsdb_attribute *attr, 1266 2157 const struct ldb_message_element *in, … … 1268 2159 struct drsuapi_DsReplicaAttribute *out) 1269 2160 { 1270 uint32_t i; 2161 return dsdb_syntax_DN_BINARY_ldb_to_drsuapi(ctx, 2162 attr, 2163 in, 2164 mem_ctx, 2165 out); 2166 } 2167 2168 static WERROR dsdb_syntax_DN_STRING_validate_ldb(const struct dsdb_syntax_ctx *ctx, 2169 const struct dsdb_attribute *attr, 2170 const struct ldb_message_element *in) 2171 { 2172 unsigned int i; 2173 2174 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 2175 return WERR_FOOBAR; 2176 } 2177 2178 for (i=0; i < in->num_values; i++) { 2179 WERROR status; 2180 struct dsdb_dn *dsdb_dn; 2181 TALLOC_CTX *tmp_ctx = talloc_new(ctx->ldb); 2182 W_ERROR_HAVE_NO_MEMORY(tmp_ctx); 2183 2184 status = dsdb_syntax_DN_validate_one_val(ctx, 2185 attr, 2186 &in->values[i], 2187 tmp_ctx, &dsdb_dn); 2188 if (!W_ERROR_IS_OK(status)) { 2189 talloc_free(tmp_ctx); 2190 return status; 2191 } 2192 2193 if (dsdb_dn->dn_format != DSDB_STRING_DN) { 2194 talloc_free(tmp_ctx); 2195 return WERR_DS_INVALID_ATTRIBUTE_SYNTAX; 2196 } 2197 2198 status = dsdb_syntax_UNICODE_validate_one_val(ctx, 2199 attr, 2200 &dsdb_dn->extra_part); 2201 if (!W_ERROR_IS_OK(status)) { 2202 talloc_free(tmp_ctx); 2203 return status; 2204 } 2205 2206 talloc_free(tmp_ctx); 2207 } 2208 2209 return WERR_OK; 2210 } 2211 2212 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx, 2213 const struct dsdb_attribute *attr, 2214 const struct drsuapi_DsReplicaAttribute *in, 2215 TALLOC_CTX *mem_ctx, 2216 struct ldb_message_element *out) 2217 { 2218 unsigned int i; 2219 2220 out->flags = 0; 2221 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName); 2222 W_ERROR_HAVE_NO_MEMORY(out->name); 2223 2224 out->num_values = in->value_ctr.num_values; 2225 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values); 2226 W_ERROR_HAVE_NO_MEMORY(out->values); 2227 2228 for (i=0; i < out->num_values; i++) { 2229 size_t len; 2230 char *str; 2231 2232 if (in->value_ctr.values[i].blob == NULL) { 2233 return WERR_FOOBAR; 2234 } 2235 2236 if (in->value_ctr.values[i].blob->length < 4) { 2237 return WERR_FOOBAR; 2238 } 2239 2240 len = IVAL(in->value_ctr.values[i].blob->data, 0); 2241 2242 if (len != in->value_ctr.values[i].blob->length) { 2243 return WERR_FOOBAR; 2244 } 2245 2246 if (!convert_string_talloc(out->values, CH_UTF16, CH_UNIX, 2247 in->value_ctr.values[i].blob->data+4, 2248 in->value_ctr.values[i].blob->length-4, 2249 (void **)&str, NULL, false)) { 2250 return WERR_FOOBAR; 2251 } 2252 2253 out->values[i] = data_blob_string_const(str); 2254 } 2255 2256 return WERR_OK; 2257 } 2258 2259 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx, 2260 const struct dsdb_attribute *attr, 2261 const struct ldb_message_element *in, 2262 TALLOC_CTX *mem_ctx, 2263 struct drsuapi_DsReplicaAttribute *out) 2264 { 2265 unsigned int i; 1271 2266 DATA_BLOB *blobs; 1272 2267 1273 if (attr->attributeID_id == 0xFFFFFFFF) { 1274 return WERR_FOOBAR; 1275 } 1276 1277 out->attid = attr->attributeID_id; 2268 if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) { 2269 return WERR_FOOBAR; 2270 } 2271 2272 out->attid = dsdb_attribute_get_attid(attr, 2273 ctx->is_schema_nc); 1278 2274 out->value_ctr.num_values = in->num_values; 1279 2275 out->value_ctr.values = talloc_array(mem_ctx, … … 1286 2282 1287 2283 for (i=0; i < in->num_values; i++) { 1288 struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;1289 enum ndr_err_code ndr_err;1290 1291 out->value_ctr.values[i].blob = &blobs[i];1292 1293 /* TODO: handle id3b.guid and id3b.sid, id3.binary */1294 ZERO_STRUCT(id3b);1295 id3b.dn = (const char *)in->values[i].data;1296 id3b.binary = data_blob(NULL, 0);1297 1298 ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3b,1299 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);1300 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {1301 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);1302 return ntstatus_to_werror(status);1303 }1304 }1305 1306 return WERR_OK;1307 }1308 1309 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb(struct ldb_context *ldb,1310 const struct dsdb_schema *schema,1311 const struct dsdb_attribute *attr,1312 const struct drsuapi_DsReplicaAttribute *in,1313 TALLOC_CTX *mem_ctx,1314 struct ldb_message_element *out)1315 {1316 uint32_t i;1317 1318 out->flags = 0;1319 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);1320 W_ERROR_HAVE_NO_MEMORY(out->name);1321 1322 out->num_values = in->value_ctr.num_values;1323 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);1324 W_ERROR_HAVE_NO_MEMORY(out->values);1325 1326 for (i=0; i < out->num_values; i++) {1327 uint32_t len;1328 char *str;1329 1330 if (in->value_ctr.values[i].blob == NULL) {1331 return WERR_FOOBAR;1332 }1333 1334 if (in->value_ctr.values[i].blob->length < 4) {1335 return WERR_FOOBAR;1336 }1337 1338 len = IVAL(in->value_ctr.values[i].blob->data, 0);1339 1340 if (len != in->value_ctr.values[i].blob->length) {1341 return WERR_FOOBAR;1342 }1343 1344 if (!convert_string_talloc_convenience(out->values, schema->iconv_convenience, CH_UTF16, CH_UNIX,1345 in->value_ctr.values[i].blob->data+4,1346 in->value_ctr.values[i].blob->length-4,1347 (void **)&str, NULL, false)) {1348 return WERR_FOOBAR;1349 }1350 1351 out->values[i] = data_blob_string_const(str);1352 }1353 1354 return WERR_OK;1355 }1356 1357 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi(struct ldb_context *ldb,1358 const struct dsdb_schema *schema,1359 const struct dsdb_attribute *attr,1360 const struct ldb_message_element *in,1361 TALLOC_CTX *mem_ctx,1362 struct drsuapi_DsReplicaAttribute *out)1363 {1364 uint32_t i;1365 DATA_BLOB *blobs;1366 1367 if (attr->attributeID_id == 0xFFFFFFFF) {1368 return WERR_FOOBAR;1369 }1370 1371 out->attid = attr->attributeID_id;1372 out->value_ctr.num_values = in->num_values;1373 out->value_ctr.values = talloc_array(mem_ctx,1374 struct drsuapi_DsAttributeValue,1375 in->num_values);1376 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);1377 1378 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);1379 W_ERROR_HAVE_NO_MEMORY(blobs);1380 1381 for (i=0; i < in->num_values; i++) {1382 2284 uint8_t *data; 1383 2285 size_t ret; … … 1385 2287 out->value_ctr.values[i].blob = &blobs[i]; 1386 2288 1387 if (!convert_string_talloc _convenience(blobs, schema->iconv_convenience, CH_UNIX, CH_UTF16,1388 1389 1390 2289 if (!convert_string_talloc(blobs, CH_UNIX, CH_UTF16, 2290 in->values[i].data, 2291 in->values[i].length, 2292 (void **)&data, &ret, false)) { 1391 2293 return WERR_FOOBAR; 1392 2294 } … … 1404 2306 1405 2307 return WERR_OK; 2308 } 2309 2310 static WERROR dsdb_syntax_PRESENTATION_ADDRESS_validate_ldb(const struct dsdb_syntax_ctx *ctx, 2311 const struct dsdb_attribute *attr, 2312 const struct ldb_message_element *in) 2313 { 2314 return dsdb_syntax_UNICODE_validate_ldb(ctx, 2315 attr, 2316 in); 1406 2317 } 1407 2318 … … 1416 2327 .drsuapi_to_ldb = dsdb_syntax_BOOL_drsuapi_to_ldb, 1417 2328 .ldb_to_drsuapi = dsdb_syntax_BOOL_ldb_to_drsuapi, 2329 .validate_ldb = dsdb_syntax_BOOL_validate_ldb, 1418 2330 .equality = "booleanMatch", 1419 .comment = "Boolean" 2331 .comment = "Boolean" 1420 2332 },{ 1421 2333 .name = "Integer", … … 1425 2337 .drsuapi_to_ldb = dsdb_syntax_INT32_drsuapi_to_ldb, 1426 2338 .ldb_to_drsuapi = dsdb_syntax_INT32_ldb_to_drsuapi, 2339 .validate_ldb = dsdb_syntax_INT32_validate_ldb, 1427 2340 .equality = "integerMatch", 1428 2341 .comment = "Integer", … … 1435 2348 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1436 2349 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2350 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1437 2351 .equality = "octetStringMatch", 1438 2352 .comment = "Octet String", … … 1444 2358 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1445 2359 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2360 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1446 2361 .equality = "octetStringMatch", 1447 2362 .comment = "Octet String - Security Identifier (SID)", … … 1454 2369 .drsuapi_to_ldb = dsdb_syntax_OID_drsuapi_to_ldb, 1455 2370 .ldb_to_drsuapi = dsdb_syntax_OID_ldb_to_drsuapi, 2371 .validate_ldb = dsdb_syntax_OID_validate_ldb, 1456 2372 .equality = "caseIgnoreMatch", /* Would use "objectIdentifierMatch" but most are ldap attribute/class names */ 1457 2373 .comment = "OID String", … … 1464 2380 .drsuapi_to_ldb = dsdb_syntax_INT32_drsuapi_to_ldb, 1465 2381 .ldb_to_drsuapi = dsdb_syntax_INT32_ldb_to_drsuapi, 2382 .validate_ldb = dsdb_syntax_INT32_validate_ldb, 1466 2383 .ldb_syntax = LDB_SYNTAX_SAMBA_INT32 1467 2384 },{ … … 1473 2390 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1474 2391 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2392 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1475 2393 .equality = "numericStringMatch", 1476 2394 .substring = "numericStringSubstringsMatch", … … 1484 2402 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1485 2403 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2404 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1486 2405 .ldb_syntax = LDB_SYNTAX_OCTET_STRING, 1487 2406 },{ … … 1492 2411 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1493 2412 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2413 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1494 2414 .equality = "caseIgnoreMatch", 1495 2415 .substring = "caseIgnoreSubstringsMatch", … … 1503 2423 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1504 2424 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2425 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1505 2426 .equality = "caseExactIA5Match", 1506 2427 .comment = "Printable String", … … 1513 2434 .drsuapi_to_ldb = dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb, 1514 2435 .ldb_to_drsuapi = dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi, 2436 .validate_ldb = dsdb_syntax_NTTIME_UTC_validate_ldb, 1515 2437 .equality = "generalizedTimeMatch", 1516 2438 .comment = "UTC Time", … … 1522 2444 .drsuapi_to_ldb = dsdb_syntax_NTTIME_drsuapi_to_ldb, 1523 2445 .ldb_to_drsuapi = dsdb_syntax_NTTIME_ldb_to_drsuapi, 2446 .validate_ldb = dsdb_syntax_NTTIME_validate_ldb, 1524 2447 .equality = "generalizedTimeMatch", 1525 2448 .comment = "Generalized Time", … … 1531 2454 .oMSyntax = 27, 1532 2455 .attributeSyntax_oid = "2.5.5.3", 1533 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb, 1534 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi, 2456 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 2457 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2458 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 2459 .equality = "caseExactMatch", 2460 .substring = "caseExactSubstringsMatch", 2461 /* TODO (kim): according to LDAP rfc we should be using same comparison 2462 * as Directory String (LDB_SYNTAX_DIRECTORY_STRING), but case sensitive. 2463 * But according to ms docs binary compare should do the job: 2464 * http://msdn.microsoft.com/en-us/library/cc223200(v=PROT.10).aspx */ 2465 .ldb_syntax = LDB_SYNTAX_OCTET_STRING, 1535 2466 },{ 1536 2467 .name = "String(Unicode)", … … 1540 2471 .drsuapi_to_ldb = dsdb_syntax_UNICODE_drsuapi_to_ldb, 1541 2472 .ldb_to_drsuapi = dsdb_syntax_UNICODE_ldb_to_drsuapi, 2473 .validate_ldb = dsdb_syntax_UNICODE_validate_ldb, 1542 2474 .equality = "caseIgnoreMatch", 1543 2475 .substring = "caseIgnoreSubstringsMatch", … … 1550 2482 .drsuapi_to_ldb = dsdb_syntax_INT64_drsuapi_to_ldb, 1551 2483 .ldb_to_drsuapi = dsdb_syntax_INT64_ldb_to_drsuapi, 2484 .validate_ldb = dsdb_syntax_INT64_validate_ldb, 1552 2485 .equality = "integerMatch", 1553 2486 .comment = "Large Integer", … … 1560 2493 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1561 2494 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2495 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1562 2496 },{ 1563 2497 .name = "Object(DS-DN)", … … 1568 2502 .drsuapi_to_ldb = dsdb_syntax_DN_drsuapi_to_ldb, 1569 2503 .ldb_to_drsuapi = dsdb_syntax_DN_ldb_to_drsuapi, 2504 .validate_ldb = dsdb_syntax_DN_validate_ldb, 1570 2505 .equality = "distinguishedNameMatch", 1571 2506 .comment = "Object(DS-DN) == a DN", 1572 2507 },{ 1573 2508 .name = "Object(DN-Binary)", 1574 .ldap_oid = "1.2.840.113556.1.4.903",2509 .ldap_oid = DSDB_SYNTAX_BINARY_DN, 1575 2510 .oMSyntax = 127, 1576 2511 .oMObjectClass = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0b"), … … 1578 2513 .drsuapi_to_ldb = dsdb_syntax_DN_BINARY_drsuapi_to_ldb, 1579 2514 .ldb_to_drsuapi = dsdb_syntax_DN_BINARY_ldb_to_drsuapi, 2515 .validate_ldb = dsdb_syntax_DN_BINARY_validate_ldb, 1580 2516 .equality = "octetStringMatch", 1581 2517 .comment = "OctetString: Binary+DN", 1582 .ldb_syntax = LDB_SYNTAX_OCTET_STRING,1583 2518 },{ 1584 /* not used in w2k3 schema 2519 /* not used in w2k3 schema, but used in Exchange schema*/ 1585 2520 .name = "Object(OR-Name)", 1586 .ldap_oid = "1.2.840.113556.1.4.1221",2521 .ldap_oid = DSDB_SYNTAX_OR_NAME, 1587 2522 .oMSyntax = 127, 1588 2523 .oMObjectClass = OMOBJECTCLASS("\x56\x06\x01\x02\x05\x0b\x1D"), 1589 2524 .attributeSyntax_oid = "2.5.5.7", 1590 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb, 1591 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi, 2525 .drsuapi_to_ldb = dsdb_syntax_DN_BINARY_drsuapi_to_ldb, 2526 .ldb_to_drsuapi = dsdb_syntax_DN_BINARY_ldb_to_drsuapi, 2527 .validate_ldb = dsdb_syntax_DN_BINARY_validate_ldb, 2528 .equality = "caseIgnoreMatch", 2529 .ldb_syntax = LDB_SYNTAX_DN, 1592 2530 },{ 1593 /* 2531 /* 1594 2532 * TODO: verify if DATA_BLOB is correct here...! 1595 2533 * 1596 2534 * repsFrom and repsTo are the only attributes using 1597 * this attribute syntax, but they're not replicated... 2535 * this attribute syntax, but they're not replicated... 1598 2536 */ 1599 2537 .name = "Object(Replica-Link)", … … 1604 2542 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb, 1605 2543 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi, 2544 .validate_ldb = dsdb_syntax_DATA_BLOB_validate_ldb, 1606 2545 },{ 1607 2546 .name = "Object(Presentation-Address)", … … 1612 2551 .drsuapi_to_ldb = dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb, 1613 2552 .ldb_to_drsuapi = dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi, 2553 .validate_ldb = dsdb_syntax_PRESENTATION_ADDRESS_validate_ldb, 1614 2554 .comment = "Presentation Address", 1615 2555 .ldb_syntax = LDB_SYNTAX_DIRECTORY_STRING, … … 1623 2563 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb, 1624 2564 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi, 2565 .validate_ldb = dsdb_syntax_FOOBAR_validate_ldb, 1625 2566 .ldb_syntax = LDB_SYNTAX_DIRECTORY_STRING, 1626 2567 },{ 1627 2568 /* not used in w2k3 schema */ 1628 2569 .name = "Object(DN-String)", 1629 .ldap_oid = "1.2.840.113556.1.4.904",2570 .ldap_oid = DSDB_SYNTAX_STRING_DN, 1630 2571 .oMSyntax = 127, 1631 2572 .oMObjectClass = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0c"), 1632 2573 .attributeSyntax_oid = "2.5.5.14", 1633 .drsuapi_to_ldb = dsdb_syntax_DN_BINARY_drsuapi_to_ldb, 1634 .ldb_to_drsuapi = dsdb_syntax_DN_BINARY_ldb_to_drsuapi, 2574 .drsuapi_to_ldb = dsdb_syntax_DN_STRING_drsuapi_to_ldb, 2575 .ldb_to_drsuapi = dsdb_syntax_DN_STRING_ldb_to_drsuapi, 2576 .validate_ldb = dsdb_syntax_DN_STRING_validate_ldb, 1635 2577 .equality = "octetStringMatch", 1636 2578 .comment = "OctetString: String+DN", 1637 .ldb_syntax = LDB_SYNTAX_OCTET_STRING,1638 2579 } 1639 2580 }; 1640 2581 1641 const struct dsdb_syntax *find_syntax_map_by_ad_oid(const char *ad_oid) 1642 { 1643 int i;2582 const struct dsdb_syntax *find_syntax_map_by_ad_oid(const char *ad_oid) 2583 { 2584 unsigned int i; 1644 2585 for (i=0; dsdb_syntaxes[i].ldap_oid; i++) { 1645 2586 if (strcasecmp(ad_oid, dsdb_syntaxes[i].attributeSyntax_oid) == 0) { … … 1650 2591 } 1651 2592 1652 const struct dsdb_syntax *find_syntax_map_by_ad_syntax(int oMSyntax) 1653 { 1654 int i;2593 const struct dsdb_syntax *find_syntax_map_by_ad_syntax(int oMSyntax) 2594 { 2595 unsigned int i; 1655 2596 for (i=0; dsdb_syntaxes[i].ldap_oid; i++) { 1656 2597 if (oMSyntax == dsdb_syntaxes[i].oMSyntax) { … … 1661 2602 } 1662 2603 1663 const struct dsdb_syntax *find_syntax_map_by_standard_oid(const char *standard_oid) 1664 { 1665 int i;2604 const struct dsdb_syntax *find_syntax_map_by_standard_oid(const char *standard_oid) 2605 { 2606 unsigned int i; 1666 2607 for (i=0; dsdb_syntaxes[i].ldap_oid; i++) { 1667 2608 if (strcasecmp(standard_oid, dsdb_syntaxes[i].ldap_oid) == 0) { … … 1671 2612 return NULL; 1672 2613 } 2614 1673 2615 const struct dsdb_syntax *dsdb_syntax_for_attribute(const struct dsdb_attribute *attr) 1674 2616 { 1675 u int32_t i;2617 unsigned int i; 1676 2618 1677 2619 for (i=0; i < ARRAY_SIZE(dsdb_syntaxes); i++) { … … 1696 2638 } 1697 2639 1698 WERROR dsdb_attribute_drsuapi_to_ldb(struct ldb_context *ldb, 2640 WERROR dsdb_attribute_drsuapi_to_ldb(struct ldb_context *ldb, 1699 2641 const struct dsdb_schema *schema, 2642 const struct dsdb_schema_prefixmap *pfm_remote, 1700 2643 const struct drsuapi_DsReplicaAttribute *in, 1701 2644 TALLOC_CTX *mem_ctx, … … 1703 2646 { 1704 2647 const struct dsdb_attribute *sa; 1705 1706 sa = dsdb_attribute_by_attributeID_id(schema, in->attid); 2648 struct dsdb_syntax_ctx syntax_ctx; 2649 uint32_t attid_local; 2650 2651 /* use default syntax conversion context */ 2652 dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema); 2653 syntax_ctx.pfm_remote = pfm_remote; 2654 2655 switch (dsdb_pfm_get_attid_type(in->attid)) { 2656 case DSDB_ATTID_TYPE_PFM: 2657 /* map remote ATTID to local ATTID */ 2658 if (!dsdb_syntax_attid_from_remote_attid(&syntax_ctx, mem_ctx, in->attid, &attid_local)) { 2659 DEBUG(0,(__location__ ": Can't find local ATTID for 0x%08X\n", 2660 in->attid)); 2661 return WERR_FOOBAR; 2662 } 2663 break; 2664 case DSDB_ATTID_TYPE_INTID: 2665 /* use IntId value directly */ 2666 attid_local = in->attid; 2667 break; 2668 default: 2669 /* we should never get here */ 2670 DEBUG(0,(__location__ ": Invalid ATTID type passed for conversion - 0x%08X\n", 2671 in->attid)); 2672 return WERR_INVALID_PARAMETER; 2673 } 2674 2675 sa = dsdb_attribute_by_attributeID_id(schema, attid_local); 1707 2676 if (!sa) { 1708 return WERR_FOOBAR; 1709 } 1710 1711 return sa->syntax->drsuapi_to_ldb(ldb, schema, sa, in, mem_ctx, out); 1712 } 1713 1714 WERROR dsdb_attribute_ldb_to_drsuapi(struct ldb_context *ldb, 2677 DEBUG(1,(__location__ ": Unknown attributeID_id 0x%08X\n", in->attid)); 2678 return WERR_FOOBAR; 2679 } 2680 2681 return sa->syntax->drsuapi_to_ldb(&syntax_ctx, sa, in, mem_ctx, out); 2682 } 2683 2684 WERROR dsdb_attribute_ldb_to_drsuapi(struct ldb_context *ldb, 1715 2685 const struct dsdb_schema *schema, 1716 2686 const struct ldb_message_element *in, … … 1719 2689 { 1720 2690 const struct dsdb_attribute *sa; 2691 struct dsdb_syntax_ctx syntax_ctx; 1721 2692 1722 2693 sa = dsdb_attribute_by_lDAPDisplayName(schema, in->name); … … 1725 2696 } 1726 2697 1727 return sa->syntax->ldb_to_drsuapi(ldb, schema, sa, in, mem_ctx, out); 1728 } 2698 /* use default syntax conversion context */ 2699 dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema); 2700 2701 return sa->syntax->ldb_to_drsuapi(&syntax_ctx, sa, in, mem_ctx, out); 2702 } 2703
Note:
See TracChangeset
for help on using the changeset viewer.
