?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r20453: add conversation for the DN_BINARY attribute syntax
[Samba/gbeck.git] / source / dsdb / schema / schema_syntax.c
blob6b82968d2e4f940747660fe07cfc2bf25522382b
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/ndr_drsuapi.h"
25 #include "lib/ldb/include/ldb.h"
26 #include "system/time.h"
27 #include "lib/charset/charset.h"
28 #include "librpc/ndr/libndr.h"
29
30 static WERROR dsdb_syntax_FOOBAR_drsuapi_to_ldb(const struct dsdb_schema *schema,
31 const struct dsdb_attribute *attr,
32 const struct drsuapi_DsReplicaAttribute *in,
33 TALLOC_CTX *mem_ctx,
34 struct ldb_message_element *out)
35 {
36 uint32_t i;
37
38 out->flags = 0;
39 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
40 W_ERROR_HAVE_NO_MEMORY(out->name);
41
42 out->num_values = in->value_ctr.data_blob.num_values;
43 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
44 W_ERROR_HAVE_NO_MEMORY(out->values);
45
46 for (i=0; i < out->num_values; i++) {
47 char *str;
48
49 if (in->value_ctr.data_blob.values[i].data == NULL) {
50 return WERR_FOOBAR;
51 }
52
53 str = talloc_asprintf(out->values, "%s: not implemented",
54 attr->syntax->name);
55 W_ERROR_HAVE_NO_MEMORY(str);
56
57 out->values[i] = data_blob_string_const(str);
58 }
59
60 return WERR_OK;
61 }
62
63 static WERROR dsdb_syntax_FOOBAR_ldb_to_drsuapi(const struct dsdb_schema *schema,
64 const struct dsdb_attribute *attr,
65 const struct ldb_message_element *in,
66 TALLOC_CTX *mem_ctx,
67 struct drsuapi_DsReplicaAttribute *out)
68 {
69 return WERR_FOOBAR;
70 }
71
72 static WERROR dsdb_syntax_BOOL_drsuapi_to_ldb(const struct dsdb_schema *schema,
73 const struct dsdb_attribute *attr,
74 const struct drsuapi_DsReplicaAttribute *in,
75 TALLOC_CTX *mem_ctx,
76 struct ldb_message_element *out)
77 {
78 uint32_t i;
79
80 switch (attr->attributeID_id) {
81 case DRSUAPI_ATTRIBUTE_isSingleValued:
82 case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly:
83 case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet:
84 return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
85 }
86
87 out->flags = 0;
88 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
89 W_ERROR_HAVE_NO_MEMORY(out->name);
90
91 out->num_values = in->value_ctr.data_blob.num_values;
92 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
93 W_ERROR_HAVE_NO_MEMORY(out->values);
94
95 for (i=0; i < out->num_values; i++) {
96 uint32_t v;
97 char *str;
98
99 if (in->value_ctr.data_blob.values[i].data == NULL) {
100 return WERR_FOOBAR;
101 }
102
103 if (in->value_ctr.data_blob.values[i].data->length != 4) {
104 return WERR_FOOBAR;
105 }
106
107 v = IVAL(in->value_ctr.data_blob.values[i].data->data, 0);
108
109 if (v != 0) {
110 str = talloc_strdup(out->values, "TRUE");
111 W_ERROR_HAVE_NO_MEMORY(str);
112 } else {
113 str = talloc_strdup(out->values, "FALSE");
114 W_ERROR_HAVE_NO_MEMORY(str);
115 }
116
117 out->values[i] = data_blob_string_const(str);
118 }
119
120 return WERR_OK;
121 }
122
123 static WERROR dsdb_syntax_BOOL_ldb_to_drsuapi(const struct dsdb_schema *schema,
124 const struct dsdb_attribute *attr,
125 const struct ldb_message_element *in,
126 TALLOC_CTX *mem_ctx,
127 struct drsuapi_DsReplicaAttribute *out)
128 {
129 uint32_t i;
130 DATA_BLOB *blobs;
131
132 if (attr->attributeID_id == 0xFFFFFFFF) {
133 return WERR_FOOBAR;
134 }
135
136 out->attid = attr->attributeID_id;
137 out->value_ctr.data_blob.num_values = in->num_values;
138 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
139 struct drsuapi_DsAttributeValueDataBlob,
140 in->num_values);
141 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
142
143 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
144 W_ERROR_HAVE_NO_MEMORY(blobs);
145
146 for (i=0; i < in->num_values; i++) {
147 out->value_ctr.data_blob.values[i].data = &blobs[i];
148
149 blobs[i] = data_blob_talloc(blobs, NULL, 4);
150 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
151
152 if (strcmp("TRUE", (const char *)in->values[i].data) == 0) {
153 SIVAL(blobs[i].data, 0, 0x00000001);
154 } else if (strcmp("FALSE", (const char *)in->values[i].data) == 0) {
155 SIVAL(blobs[i].data, 0, 0x00000000);
156 } else {
157 return WERR_FOOBAR;
158 }
159 }
160
161 return WERR_OK;
162 }
163
164 static WERROR dsdb_syntax_INT32_drsuapi_to_ldb(const struct dsdb_schema *schema,
165 const struct dsdb_attribute *attr,
166 const struct drsuapi_DsReplicaAttribute *in,
167 TALLOC_CTX *mem_ctx,
168 struct ldb_message_element *out)
169 {
170 uint32_t i;
171
172 switch (attr->attributeID_id) {
173 case DRSUAPI_ATTRIBUTE_instanceType:
174 case DRSUAPI_ATTRIBUTE_rangeLower:
175 case DRSUAPI_ATTRIBUTE_rangeUpper:
176 case DRSUAPI_ATTRIBUTE_objectVersion:
177 case DRSUAPI_ATTRIBUTE_oMSyntax:
178 case DRSUAPI_ATTRIBUTE_searchFlags:
179 case DRSUAPI_ATTRIBUTE_systemFlags:
180 case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version:
181 return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
182 }
183
184 out->flags = 0;
185 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
186 W_ERROR_HAVE_NO_MEMORY(out->name);
187
188 out->num_values = in->value_ctr.data_blob.num_values;
189 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
190 W_ERROR_HAVE_NO_MEMORY(out->values);
191
192 for (i=0; i < out->num_values; i++) {
193 int32_t v;
194 char *str;
195
196 if (in->value_ctr.data_blob.values[i].data == NULL) {
197 return WERR_FOOBAR;
198 }
199
200 if (in->value_ctr.data_blob.values[i].data->length != 4) {
201 return WERR_FOOBAR;
202 }
203
204 v = IVALS(in->value_ctr.data_blob.values[i].data->data, 0);
205
206 str = talloc_asprintf(out->values, "%d", v);
207 W_ERROR_HAVE_NO_MEMORY(str);
208
209 out->values[i] = data_blob_string_const(str);
210 }
211
212 return WERR_OK;
213 }
214
215 static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(const struct dsdb_schema *schema,
216 const struct dsdb_attribute *attr,
217 const struct ldb_message_element *in,
218 TALLOC_CTX *mem_ctx,
219 struct drsuapi_DsReplicaAttribute *out)
220 {
221 uint32_t i;
222 DATA_BLOB *blobs;
223
224 if (attr->attributeID_id == 0xFFFFFFFF) {
225 return WERR_FOOBAR;
226 }
227
228 out->attid = attr->attributeID_id;
229 out->value_ctr.data_blob.num_values = in->num_values;
230 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
231 struct drsuapi_DsAttributeValueDataBlob,
232 in->num_values);
233 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
234
235 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
236 W_ERROR_HAVE_NO_MEMORY(blobs);
237
238 for (i=0; i < in->num_values; i++) {
239 int32_t v;
240
241 out->value_ctr.data_blob.values[i].data = &blobs[i];
242
243 blobs[i] = data_blob_talloc(blobs, NULL, 4);
244 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
245
246 v = strtol((const char *)in->values[i].data, NULL, 10);
247
248 SIVALS(blobs[i].data, 0, v);
249 }
250
251 return WERR_OK;
252 }
253
254 static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(const struct dsdb_schema *schema,
255 const struct dsdb_attribute *attr,
256 const struct drsuapi_DsReplicaAttribute *in,
257 TALLOC_CTX *mem_ctx,
258 struct ldb_message_element *out)
259 {
260 uint32_t i;
261
262 out->flags = 0;
263 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
264 W_ERROR_HAVE_NO_MEMORY(out->name);
265
266 out->num_values = in->value_ctr.data_blob.num_values;
267 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
268 W_ERROR_HAVE_NO_MEMORY(out->values);
269
270 for (i=0; i < out->num_values; i++) {
271 int64_t v;
272 char *str;
273
274 if (in->value_ctr.data_blob.values[i].data == NULL) {
275 return WERR_FOOBAR;
276 }
277
278 if (in->value_ctr.data_blob.values[i].data->length != 8) {
279 return WERR_FOOBAR;
280 }
281
282 v = BVALS(in->value_ctr.data_blob.values[i].data->data, 0);
283
284 str = talloc_asprintf(out->values, "%lld", v);
285 W_ERROR_HAVE_NO_MEMORY(str);
286
287 out->values[i] = data_blob_string_const(str);
288 }
289
290 return WERR_OK;
291 }
292
293 static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(const struct dsdb_schema *schema,
294 const struct dsdb_attribute *attr,
295 const struct ldb_message_element *in,
296 TALLOC_CTX *mem_ctx,
297 struct drsuapi_DsReplicaAttribute *out)
298 {
299 uint32_t i;
300 DATA_BLOB *blobs;
301
302 if (attr->attributeID_id == 0xFFFFFFFF) {
303 return WERR_FOOBAR;
304 }
305
306 out->attid = attr->attributeID_id;
307 out->value_ctr.data_blob.num_values = in->num_values;
308 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
309 struct drsuapi_DsAttributeValueDataBlob,
310 in->num_values);
311 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
312
313 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
314 W_ERROR_HAVE_NO_MEMORY(blobs);
315
316 for (i=0; i < in->num_values; i++) {
317 int64_t v;
318
319 out->value_ctr.data_blob.values[i].data = &blobs[i];
320
321 blobs[i] = data_blob_talloc(blobs, NULL, 8);
322 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
323
324 v = strtoll((const char *)in->values[i].data, NULL, 10);
325
326 SBVALS(blobs[i].data, 0, v);
327 }
328
329 return WERR_OK;
330 }
331
332 static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(const struct dsdb_schema *schema,
333 const struct dsdb_attribute *attr,
334 const struct drsuapi_DsReplicaAttribute *in,
335 TALLOC_CTX *mem_ctx,
336 struct ldb_message_element *out)
337 {
338 uint32_t i;
339
340 out->flags = 0;
341 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
342 W_ERROR_HAVE_NO_MEMORY(out->name);
343
344 out->num_values = in->value_ctr.data_blob.num_values;
345 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
346 W_ERROR_HAVE_NO_MEMORY(out->values);
347
348 for (i=0; i < out->num_values; i++) {
349 NTTIME v;
350 time_t t;
351 char *str;
352
353 if (in->value_ctr.data_blob.values[i].data == NULL) {
354 return WERR_FOOBAR;
355 }
356
357 if (in->value_ctr.data_blob.values[i].data->length != 8) {
358 return WERR_FOOBAR;
359 }
360
361 v = BVAL(in->value_ctr.data_blob.values[i].data->data, 0);
362 v *= 10000000;
363 t = nt_time_to_unix(v);
364
365 str = ldb_timestring(out->values, t);
366 W_ERROR_HAVE_NO_MEMORY(str);
367
368 out->values[i] = data_blob_string_const(str);
369 }
370
371 return WERR_OK;
372 }
373
374 static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(const struct dsdb_schema *schema,
375 const struct dsdb_attribute *attr,
376 const struct ldb_message_element *in,
377 TALLOC_CTX *mem_ctx,
378 struct drsuapi_DsReplicaAttribute *out)
379 {
380 uint32_t i;
381 DATA_BLOB *blobs;
382
383 if (attr->attributeID_id == 0xFFFFFFFF) {
384 return WERR_FOOBAR;
385 }
386
387 out->attid = attr->attributeID_id;
388 out->value_ctr.data_blob.num_values = in->num_values;
389 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
390 struct drsuapi_DsAttributeValueDataBlob,
391 in->num_values);
392 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
393
394 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
395 W_ERROR_HAVE_NO_MEMORY(blobs);
396
397 for (i=0; i < in->num_values; i++) {
398 NTTIME v;
399 time_t t;
400
401 out->value_ctr.data_blob.values[i].data = &blobs[i];
402
403 blobs[i] = data_blob_talloc(blobs, NULL, 8);
404 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
405
406 t = ldb_string_to_time((const char *)in->values[i].data);
407 unix_to_nt_time(&v, t);
408
409 SBVAL(blobs[i].data, 0, v);
410 }
411
412 return WERR_OK;
413 }
414
415 static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(const struct dsdb_schema *schema,
416 const struct dsdb_attribute *attr,
417 const struct drsuapi_DsReplicaAttribute *in,
418 TALLOC_CTX *mem_ctx,
419 struct ldb_message_element *out)
420 {
421 uint32_t i;
422
423 switch (attr->attributeID_id) {
424 case DRSUAPI_ATTRIBUTE_invocationId:
425 case DRSUAPI_ATTRIBUTE_schemaIDGUID:
426 return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
427 }
428
429 out->flags = 0;
430 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
431 W_ERROR_HAVE_NO_MEMORY(out->name);
432
433 out->num_values = in->value_ctr.data_blob.num_values;
434 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
435 W_ERROR_HAVE_NO_MEMORY(out->values);
436
437 for (i=0; i < out->num_values; i++) {
438 if (in->value_ctr.data_blob.values[i].data == NULL) {
439 return WERR_FOOBAR;
440 }
441
442 if (in->value_ctr.data_blob.values[i].data->length == 0) {
443 return WERR_FOOBAR;
444 }
445
446 out->values[i] = data_blob_dup_talloc(out->values,
447 in->value_ctr.data_blob.values[i].data);
448 W_ERROR_HAVE_NO_MEMORY(out->values[i].data);
449 }
450
451 return WERR_OK;
452 }
453
454 static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(const struct dsdb_schema *schema,
455 const struct dsdb_attribute *attr,
456 const struct ldb_message_element *in,
457 TALLOC_CTX *mem_ctx,
458 struct drsuapi_DsReplicaAttribute *out)
459 {
460 uint32_t i;
461 DATA_BLOB *blobs;
462
463 if (attr->attributeID_id == 0xFFFFFFFF) {
464 return WERR_FOOBAR;
465 }
466
467 out->attid = attr->attributeID_id;
468 out->value_ctr.data_blob.num_values = in->num_values;
469 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
470 struct drsuapi_DsAttributeValueDataBlob,
471 in->num_values);
472 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
473
474 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
475 W_ERROR_HAVE_NO_MEMORY(blobs);
476
477 for (i=0; i < in->num_values; i++) {
478 out->value_ctr.data_blob.values[i].data = &blobs[i];
479
480 blobs[i] = data_blob_dup_talloc(blobs, &in->values[i]);
481 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
482 }
483
484 return WERR_OK;
485 }
486
487 static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(const struct dsdb_schema *schema,
488 const struct dsdb_attribute *attr,
489 const struct drsuapi_DsReplicaAttribute *in,
490 TALLOC_CTX *mem_ctx,
491 struct ldb_message_element *out)
492 {
493 uint32_t i;
494
495 out->flags = 0;
496 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
497 W_ERROR_HAVE_NO_MEMORY(out->name);
498
499 out->num_values = in->value_ctr.data_blob.num_values;
500 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
501 W_ERROR_HAVE_NO_MEMORY(out->values);
502
503 for (i=0; i < out->num_values; i++) {
504 uint32_t v;
505 const struct dsdb_class *c;
506 const char *str;
507
508 if (in->value_ctr.object_class_id.values[i].objectClassId == NULL) {
509 return WERR_FOOBAR;
510 }
511
512 v = *in->value_ctr.object_class_id.values[i].objectClassId;
513
514 c = dsdb_class_by_governsID_id(schema, v);
515 if (!c) {
516 return WERR_FOOBAR;
517 }
518
519 str = talloc_strdup(out->values, c->lDAPDisplayName);
520 W_ERROR_HAVE_NO_MEMORY(str);
521
522 /* the values need to be reversed */
523 out->values[out->num_values - (i + 1)] = data_blob_string_const(str);
524 }
525
526 return WERR_OK;
527 }
528
529 static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(const struct dsdb_schema *schema,
530 const struct dsdb_attribute *attr,
531 const struct drsuapi_DsReplicaAttribute *in,
532 TALLOC_CTX *mem_ctx,
533 struct ldb_message_element *out)
534 {
535 uint32_t i;
536
537 out->flags = 0;
538 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
539 W_ERROR_HAVE_NO_MEMORY(out->name);
540
541 out->num_values = in->value_ctr.data_blob.num_values;
542 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
543 W_ERROR_HAVE_NO_MEMORY(out->values);
544
545 for (i=0; i < out->num_values; i++) {
546 uint32_t v;
547 WERROR status;
548 const char *str;
549
550 if (in->value_ctr.oid.values[i].value == NULL) {
551 return WERR_FOOBAR;
552 }
553
554 v = *in->value_ctr.oid.values[i].value;
555
556 status = dsdb_map_int2oid(schema, v, out->values, &str);
557 W_ERROR_NOT_OK_RETURN(status);
558
559 out->values[i] = data_blob_string_const(str);
560 }
561
562 return WERR_OK;
563 }
564
565 static WERROR dsdb_syntax_OID_drsuapi_to_ldb(const struct dsdb_schema *schema,
566 const struct dsdb_attribute *attr,
567 const struct drsuapi_DsReplicaAttribute *in,
568 TALLOC_CTX *mem_ctx,
569 struct ldb_message_element *out)
570 {
571 uint32_t i;
572
573 switch (attr->attributeID_id) {
574 case DRSUAPI_ATTRIBUTE_objectClass:
575 return _dsdb_syntax_OID_obj_drsuapi_to_ldb(schema, attr, in, mem_ctx, out);
576 case DRSUAPI_ATTRIBUTE_governsID:
577 case DRSUAPI_ATTRIBUTE_attributeID:
578 case DRSUAPI_ATTRIBUTE_attributeSyntax:
579 return _dsdb_syntax_OID_oid_drsuapi_to_ldb(schema, attr, in, mem_ctx, out);
580 }
581
582 out->flags = 0;
583 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
584 W_ERROR_HAVE_NO_MEMORY(out->name);
585
586 out->num_values = in->value_ctr.data_blob.num_values;
587 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
588 W_ERROR_HAVE_NO_MEMORY(out->values);
589
590 for (i=0; i < out->num_values; i++) {
591 uint32_t v;
592 const char *name;
593 char *str;
594
595 if (in->value_ctr.data_blob.values[i].data == NULL) {
596 return WERR_FOOBAR;
597 }
598
599 if (in->value_ctr.data_blob.values[i].data->length != 4) {
600 return WERR_FOOBAR;
601 }
602
603 v = IVAL(in->value_ctr.data_blob.values[i].data->data, 0);
604
605 name = dsdb_lDAPDisplayName_by_id(schema, v);
606 if (!name) {
607 return WERR_FOOBAR;
608 }
609
610 str = talloc_strdup(out->values, name);
611 W_ERROR_HAVE_NO_MEMORY(str);
612
613 out->values[i] = data_blob_string_const(str);
614 }
615
616 return WERR_OK;
617 }
618
619 static WERROR dsdb_syntax_OID_ldb_to_drsuapi(const struct dsdb_schema *schema,
620 const struct dsdb_attribute *attr,
621 const struct ldb_message_element *in,
622 TALLOC_CTX *mem_ctx,
623 struct drsuapi_DsReplicaAttribute *out)
624 {
625 uint32_t i;
626 DATA_BLOB *blobs;
627
628 if (attr->attributeID_id == 0xFFFFFFFF) {
629 return WERR_FOOBAR;
630 }
631
632 switch (attr->attributeID_id) {
633 case DRSUAPI_ATTRIBUTE_objectClass:
634 case DRSUAPI_ATTRIBUTE_governsID:
635 case DRSUAPI_ATTRIBUTE_attributeID:
636 case DRSUAPI_ATTRIBUTE_attributeSyntax:
637 return dsdb_syntax_FOOBAR_ldb_to_drsuapi(schema, attr, in, mem_ctx, out);
638 }
639
640 out->attid = attr->attributeID_id;
641 out->value_ctr.data_blob.num_values = in->num_values;
642 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
643 struct drsuapi_DsAttributeValueDataBlob,
644 in->num_values);
645 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
646
647 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
648 W_ERROR_HAVE_NO_MEMORY(blobs);
649
650 for (i=0; i < in->num_values; i++) {
651 uint32_t v;
652
653 out->value_ctr.data_blob.values[i].data = &blobs[i];
654
655 blobs[i] = data_blob_talloc(blobs, NULL, 4);
656 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
657
658 v = strtol((const char *)in->values[i].data, NULL, 10);
659
660 SIVAL(blobs[i].data, 0, v);
661 }
662
663 return WERR_OK;
664 }
665
666 static WERROR dsdb_syntax_UNICODE_drsuapi_to_ldb(const struct dsdb_schema *schema,
667 const struct dsdb_attribute *attr,
668 const struct drsuapi_DsReplicaAttribute *in,
669 TALLOC_CTX *mem_ctx,
670 struct ldb_message_element *out)
671 {
672 uint32_t i;
673
674 switch (attr->attributeID_id) {
675 case DRSUAPI_ATTRIBUTE_description:
676 case DRSUAPI_ATTRIBUTE_adminDisplayName:
677 case DRSUAPI_ATTRIBUTE_adminDescription:
678 case DRSUAPI_ATTRIBUTE_lDAPDisplayName:
679 case DRSUAPI_ATTRIBUTE_name:
680 case DRSUAPI_ATTRIBUTE_sAMAccountName:
681 case DRSUAPI_ATTRIBUTE_gPLink:
682 return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
683 }
684
685 out->flags = 0;
686 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
687 W_ERROR_HAVE_NO_MEMORY(out->name);
688
689 out->num_values = in->value_ctr.data_blob.num_values;
690 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
691 W_ERROR_HAVE_NO_MEMORY(out->values);
692
693 for (i=0; i < out->num_values; i++) {
694 ssize_t ret;
695 char *str;
696
697 if (in->value_ctr.data_blob.values[i].data == NULL) {
698 return WERR_FOOBAR;
699 }
700
701 if (in->value_ctr.data_blob.values[i].data->length == 0) {
702 return WERR_FOOBAR;
703 }
704
705 ret = convert_string_talloc(out->values, CH_UTF16, CH_UNIX,
706 in->value_ctr.data_blob.values[i].data->data,
707 in->value_ctr.data_blob.values[i].data->length,
708 (void **)&str);
709 if (ret == -1) {
710 return WERR_FOOBAR;
711 }
712
713 out->values[i] = data_blob_string_const(str);
714 }
715
716 return WERR_OK;
717 }
718
719 static WERROR dsdb_syntax_UNICODE_ldb_to_drsuapi(const struct dsdb_schema *schema,
720 const struct dsdb_attribute *attr,
721 const struct ldb_message_element *in,
722 TALLOC_CTX *mem_ctx,
723 struct drsuapi_DsReplicaAttribute *out)
724 {
725 uint32_t i;
726 DATA_BLOB *blobs;
727
728 if (attr->attributeID_id == 0xFFFFFFFF) {
729 return WERR_FOOBAR;
730 }
731
732 out->attid = attr->attributeID_id;
733 out->value_ctr.data_blob.num_values = in->num_values;
734 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
735 struct drsuapi_DsAttributeValueDataBlob,
736 in->num_values);
737 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
738
739 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
740 W_ERROR_HAVE_NO_MEMORY(blobs);
741
742 for (i=0; i < in->num_values; i++) {
743 ssize_t ret;
744
745 out->value_ctr.data_blob.values[i].data = &blobs[i];
746
747 ret = convert_string_talloc(blobs, CH_UNIX, CH_UTF16,
748 in->values[i].data,
749 in->values[i].length,
750 (void **)&blobs[i].data);
751 if (ret == -1) {
752 return WERR_FOOBAR;
753 }
754 blobs[i].length = ret;
755 }
756
757 return WERR_OK;
758 }
759
760 static WERROR dsdb_syntax_DN_drsuapi_to_ldb(const struct dsdb_schema *schema,
761 const struct dsdb_attribute *attr,
762 const struct drsuapi_DsReplicaAttribute *in,
763 TALLOC_CTX *mem_ctx,
764 struct ldb_message_element *out)
765 {
766 uint32_t i;
767
768 switch (attr->attributeID_id) {
769 case DRSUAPI_ATTRIBUTE_member:
770 case DRSUAPI_ATTRIBUTE_objectCategory:
771 case DRSUAPI_ATTRIBUTE_hasMasterNCs:
772 case DRSUAPI_ATTRIBUTE_dMDLocation:
773 case DRSUAPI_ATTRIBUTE_fSMORoleOwner:
774 case DRSUAPI_ATTRIBUTE_wellKnownObjects:
775 case DRSUAPI_ATTRIBUTE_serverReference:
776 case DRSUAPI_ATTRIBUTE_serverReferenceBL:
777 case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs:
778 case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs:
779 return dsdb_syntax_FOOBAR_drsuapi_to_ldb(schema,attr, in, mem_ctx, out);
780 }
781
782 out->flags = 0;
783 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
784 W_ERROR_HAVE_NO_MEMORY(out->name);
785
786 out->num_values = in->value_ctr.data_blob.num_values;
787 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
788 W_ERROR_HAVE_NO_MEMORY(out->values);
789
790 for (i=0; i < out->num_values; i++) {
791 struct drsuapi_DsReplicaObjectIdentifier3 id3;
792 NTSTATUS status;
793
794 if (in->value_ctr.data_blob.values[i].data == NULL) {
795 return WERR_FOOBAR;
796 }
797
798 if (in->value_ctr.data_blob.values[i].data->length == 0) {
799 return WERR_FOOBAR;
800 }
801
802 status = ndr_pull_struct_blob_all(in->value_ctr.data_blob.values[i].data,
803 out->values, &id3,
804 (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
805 if (!NT_STATUS_IS_OK(status)) {
806 return ntstatus_to_werror(status);
807 }
808
809 /* TODO: handle id3.guid and id3.sid */
810 out->values[i] = data_blob_string_const(id3.dn);
811 }
812
813 return WERR_OK;
814 }
815
816 static WERROR dsdb_syntax_DN_ldb_to_drsuapi(const struct dsdb_schema *schema,
817 const struct dsdb_attribute *attr,
818 const struct ldb_message_element *in,
819 TALLOC_CTX *mem_ctx,
820 struct drsuapi_DsReplicaAttribute *out)
821 {
822 uint32_t i;
823 DATA_BLOB *blobs;
824
825 if (attr->attributeID_id == 0xFFFFFFFF) {
826 return WERR_FOOBAR;
827 }
828
829 out->attid = attr->attributeID_id;
830 out->value_ctr.data_blob.num_values = in->num_values;
831 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
832 struct drsuapi_DsAttributeValueDataBlob,
833 in->num_values);
834 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
835
836 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
837 W_ERROR_HAVE_NO_MEMORY(blobs);
838
839 for (i=0; i < in->num_values; i++) {
840 NTSTATUS status;
841 struct drsuapi_DsReplicaObjectIdentifier3 id3;
842
843 out->value_ctr.data_blob.values[i].data = &blobs[i];
844
845 /* TODO: handle id3.guid and id3.sid */
846 ZERO_STRUCT(id3);
847 id3.dn = (const char *)in->values[i].data;
848
849 status = ndr_push_struct_blob(&blobs[i], blobs, &id3,
850 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
851 if (!NT_STATUS_IS_OK(status)) {
852 return ntstatus_to_werror(status);
853 }
854 }
855
856 return WERR_OK;
857 }
858
859 static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(const struct dsdb_schema *schema,
860 const struct dsdb_attribute *attr,
861 const struct drsuapi_DsReplicaAttribute *in,
862 TALLOC_CTX *mem_ctx,
863 struct ldb_message_element *out)
864 {
865 uint32_t i;
866
867 out->flags = 0;
868 out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
869 W_ERROR_HAVE_NO_MEMORY(out->name);
870
871 out->num_values = in->value_ctr.data_blob.num_values;
872 out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
873 W_ERROR_HAVE_NO_MEMORY(out->values);
874
875 for (i=0; i < out->num_values; i++) {
876 struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
877 char *binary;
878 char *str;
879 NTSTATUS status;
880
881 if (in->value_ctr.data_blob.values[i].data == NULL) {
882 return WERR_FOOBAR;
883 }
884
885 if (in->value_ctr.data_blob.values[i].data->length == 0) {
886 return WERR_FOOBAR;
887 }
888
889 status = ndr_pull_struct_blob(in->value_ctr.data_blob.values[i].data,
890 out->values, &id3b,
891 (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
892 if (!NT_STATUS_IS_OK(status)) {
893 return ntstatus_to_werror(status);
894 }
895
896 /* TODO: handle id3.guid and id3.sid */
897 binary = data_blob_hex_string(out->values, &id3b.binary);
898 W_ERROR_HAVE_NO_MEMORY(binary);
899
900 str = talloc_asprintf(out->values, "B:%u:%s:%s",
901 id3b.binary.length * 2, /* because of 2 hex chars per byte */
902 binary,
903 id3b.dn);
904 W_ERROR_HAVE_NO_MEMORY(str);
905
906 /* TODO: handle id3.guid and id3.sid */
907 out->values[i] = data_blob_string_const(str);
908 }
909
910 return WERR_OK;
911 }
912
913 static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(const struct dsdb_schema *schema,
914 const struct dsdb_attribute *attr,
915 const struct ldb_message_element *in,
916 TALLOC_CTX *mem_ctx,
917 struct drsuapi_DsReplicaAttribute *out)
918 {
919 uint32_t i;
920 DATA_BLOB *blobs;
921
922 if (attr->attributeID_id == 0xFFFFFFFF) {
923 return WERR_FOOBAR;
924 }
925
926 out->attid = attr->attributeID_id;
927 out->value_ctr.data_blob.num_values = in->num_values;
928 out->value_ctr.data_blob.values = talloc_array(mem_ctx,
929 struct drsuapi_DsAttributeValueDataBlob,
930 in->num_values);
931 W_ERROR_HAVE_NO_MEMORY(out->value_ctr.data_blob.values);
932
933 blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
934 W_ERROR_HAVE_NO_MEMORY(blobs);
935
936 for (i=0; i < in->num_values; i++) {
937 NTSTATUS status;
938 struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
939
940 out->value_ctr.data_blob.values[i].data = &blobs[i];
941
942 /* TODO: handle id3b.guid and id3b.sid, id3.binary */
943 ZERO_STRUCT(id3b);
944 id3b.dn = (const char *)in->values[i].data;
945 id3b.binary = data_blob(NULL, 0);
946
947 status = ndr_push_struct_blob(&blobs[i], blobs, &id3b,
948 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
949 if (!NT_STATUS_IS_OK(status)) {
950 return ntstatus_to_werror(status);
951 }
952 }
953
954 return WERR_OK;
955 }
956
957 #define OMOBJECTCLASS(val) { .length = sizeof(val) - 1, .data = discard_const_p(uint8_t, val) }
958
959 static const struct dsdb_syntax dsdb_syntaxes[] = {
960 {
961 .name = "Boolean",
962 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.7",
963 .oMSyntax = 1,
964 .attributeSyntax_oid = "2.5.5.8",
965 .drsuapi_to_ldb = dsdb_syntax_BOOL_drsuapi_to_ldb,
966 .ldb_to_drsuapi = dsdb_syntax_BOOL_ldb_to_drsuapi,
967 },{
968 .name = "Integer",
969 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.27",
970 .oMSyntax = 2,
971 .attributeSyntax_oid = "2.5.5.9",
972 .drsuapi_to_ldb = dsdb_syntax_INT32_drsuapi_to_ldb,
973 .ldb_to_drsuapi = dsdb_syntax_INT32_ldb_to_drsuapi,
974 },{
975 .name = "String(Octet)",
976 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.40",
977 .oMSyntax = 4,
978 .attributeSyntax_oid = "2.5.5.10",
979 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
980 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
981 },{
982 .name = "String(Sid)",
983 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.40",
984 .oMSyntax = 4,
985 .attributeSyntax_oid = "2.5.5.17",
986 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
987 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
988 },{
989 .name = "String(Object-Identifier)",
990 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.38",
991 .oMSyntax = 6,
992 .attributeSyntax_oid = "2.5.5.2",
993 .drsuapi_to_ldb = dsdb_syntax_OID_drsuapi_to_ldb,
994 .ldb_to_drsuapi = dsdb_syntax_OID_ldb_to_drsuapi,
995 },{
996 .name = "Enumeration",
997 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.27",
998 .oMSyntax = 10,
999 .attributeSyntax_oid = "2.5.5.9",
1000 .drsuapi_to_ldb = dsdb_syntax_INT32_drsuapi_to_ldb,
1001 .ldb_to_drsuapi = dsdb_syntax_INT32_ldb_to_drsuapi,
1002 },{
1003 /* not used in w2k3 forest */
1004 .name = "String(Numeric)",
1005 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.36",
1006 .oMSyntax = 18,
1007 .attributeSyntax_oid = "2.5.5.6",
1008 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1009 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1010 },{
1011 /* not used in w2k3 forest */
1012 .name = "String(Printable)",
1013 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.44",
1014 .oMSyntax = 19,
1015 .attributeSyntax_oid = "2.5.5.5",
1016 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1017 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1018 },{
1019 /* not used in w2k3 forest */
1020 .name = "String(Teletex)",
1021 .ldap_oid = "1.2.840.113556.1.4.905",
1022 .oMSyntax = 20,
1023 .attributeSyntax_oid = "2.5.5.4",
1024 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1025 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1026 },{
1027 /* not used in w2k3 forest */
1028 .name = "String(IA5)",
1029 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.26",
1030 .oMSyntax = 22,
1031 .attributeSyntax_oid = "2.5.5.5",
1032 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1033 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1034 },{
1035 /* not used in w2k3 forest */
1036 .name = "String(UTC-Time)",
1037 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.53",
1038 .oMSyntax = 23,
1039 .attributeSyntax_oid = "2.5.5.11",
1040 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1041 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1042 },{
1043 .name = "String(Generalized-Time)",
1044 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.24",
1045 .oMSyntax = 24,
1046 .attributeSyntax_oid = "2.5.5.11",
1047 .drsuapi_to_ldb = dsdb_syntax_NTTIME_drsuapi_to_ldb,
1048 .ldb_to_drsuapi = dsdb_syntax_NTTIME_ldb_to_drsuapi,
1049 },{
1050 /* not used in w2k3 forest */
1051 .name = "String(Case Sensitive)",
1052 .ldap_oid = "1.2.840.113556.1.4.1362",
1053 .oMSyntax = 27,
1054 .attributeSyntax_oid = "2.5.5.3",
1055 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1056 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1057 },{
1058 .name = "String(Unicode)",
1059 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.15",
1060 .oMSyntax = 64,
1061 .attributeSyntax_oid = "2.5.5.12",
1062 .drsuapi_to_ldb = dsdb_syntax_UNICODE_drsuapi_to_ldb,
1063 .ldb_to_drsuapi = dsdb_syntax_UNICODE_ldb_to_drsuapi,
1064 },{
1065 .name = "Interval/LargeInteger",
1066 .ldap_oid = "1.2.840.113556.1.4.906",
1067 .oMSyntax = 65,
1068 .attributeSyntax_oid = "2.5.5.16",
1069 .drsuapi_to_ldb = dsdb_syntax_INT64_drsuapi_to_ldb,
1070 .ldb_to_drsuapi = dsdb_syntax_INT64_ldb_to_drsuapi,
1071 },{
1072 .name = "String(NT-Sec-Desc)",
1073 .ldap_oid = "1.2.840.113556.1.4.907",
1074 .oMSyntax = 66,
1075 .attributeSyntax_oid = "2.5.5.15",
1076 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1077 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1078 },{
1079 .name = "Object(DS-DN)",
1080 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.12",
1081 .oMSyntax = 127,
1082 .oMObjectClass = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x4a"),
1083 .attributeSyntax_oid = "2.5.5.1",
1084 .drsuapi_to_ldb = dsdb_syntax_DN_drsuapi_to_ldb,
1085 .ldb_to_drsuapi = dsdb_syntax_DN_ldb_to_drsuapi,
1086 },{
1087 .name = "Object(DN-Binary)",
1088 .ldap_oid = "1.2.840.113556.1.4.903",
1089 .oMSyntax = 127,
1090 .oMObjectClass = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0b"),
1091 .attributeSyntax_oid = "2.5.5.7",
1092 .drsuapi_to_ldb = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
1093 .ldb_to_drsuapi = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
1094 },{
1095 /* not used in w2k3 forest */
1096 .name = "Object(OR-Name)",
1097 .ldap_oid = "1.2.840.113556.1.4.1221",
1098 .oMSyntax = 127,
1099 .oMObjectClass = OMOBJECTCLASS("\x56\x06\x01\x02\x05\x0b\x1D"),
1100 .attributeSyntax_oid = "2.5.5.7",
1101 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1102 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1103 },{
1104 .name = "Object(Replica-Link)",
1105 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.40",
1106 .oMSyntax = 127,
1107 .oMObjectClass = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x06"),
1108 .attributeSyntax_oid = "2.5.5.10",
1109 .drsuapi_to_ldb = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
1110 .ldb_to_drsuapi = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
1111 },{
1112 /* not used in w2k3 forest */
1113 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.43",
1114 .oMSyntax = 127,
1115 .oMObjectClass = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x5c"),
1116 .attributeSyntax_oid = "2.5.5.13",
1117 .name = "Object(Presentation-Address)",
1118 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1119 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1120 },{
1121 /* not used in w2k3 forest */
1122 .name = "Object(Access-Point)",
1123 .ldap_oid = "1.3.6.1.4.1.1466.115.121.1.2",
1124 .oMSyntax = 127,
1125 .oMObjectClass = OMOBJECTCLASS("\x2b\x0c\x02\x87\x73\x1c\x00\x85\x3e"),
1126 .attributeSyntax_oid = "2.5.5.14",
1127 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1128 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1129 },{
1130 /* not used in w2k3 forest */
1131 .name = "Object(DN-String)",
1132 .ldap_oid = "1.2.840.113556.1.4.904",
1133 .oMSyntax = 127,
1134 .oMObjectClass = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0c"),
1135 .attributeSyntax_oid = "2.5.5.14",
1136 .drsuapi_to_ldb = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
1137 .ldb_to_drsuapi = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
1138 }
1139 };
1140
1141 const struct dsdb_syntax *dsdb_syntax_for_attribute(const struct dsdb_attribute *attr)
1142 {
1143 uint32_t i;
1144
1145 for (i=0; i < ARRAY_SIZE(dsdb_syntaxes); i++) {
1146 if (attr->oMSyntax != dsdb_syntaxes[i].oMSyntax) continue;
1147
1148 if (attr->oMObjectClass.length != dsdb_syntaxes[i].oMObjectClass.length) continue;
1149
1150 if (attr->oMObjectClass.length) {
1151 int ret;
1152 ret = memcmp(attr->oMObjectClass.data,
1153 dsdb_syntaxes[i].oMObjectClass.data,
1154 attr->oMObjectClass.length);
1155 if (ret != 0) continue;
1156 }
1157
1158 if (strcmp(attr->attributeSyntax_oid, dsdb_syntaxes[i].attributeSyntax_oid) != 0) continue;
1159
1160 return &dsdb_syntaxes[i];
1161 }
1162
1163 return NULL;
1164 }
1165
1166 WERROR dsdb_attribute_drsuapi_to_ldb(const struct dsdb_schema *schema,
1167 const struct drsuapi_DsReplicaAttribute *in,
1168 TALLOC_CTX *mem_ctx,
1169 struct ldb_message_element *out)
1170 {
1171 const struct dsdb_attribute *sa;
1172
1173 sa = dsdb_attribute_by_attributeID_id(schema, in->attid);
1174 if (!sa) {
1175 return WERR_FOOBAR;
1176 }
1177
1178 return sa->syntax->drsuapi_to_ldb(schema, sa, in, mem_ctx, out);
1179 }
1180
1181 WERROR dsdb_attribute_ldb_to_drsuapi(const struct dsdb_schema *schema,
1182 const struct ldb_message_element *in,
1183 TALLOC_CTX *mem_ctx,
1184 struct drsuapi_DsReplicaAttribute *out)
1185 {
1186 const struct dsdb_attribute *sa;
1187
1188 sa = dsdb_attribute_by_lDAPDisplayName(schema, in->name);
1189 if (!sa) {
1190 return WERR_FOOBAR;
1191 }
1192
1193 return sa->syntax->ldb_to_drsuapi(schema, sa, in, mem_ctx, out);
1194 }
WIP