source: trunk/server/source4/libcli/ldap/ldap_controls.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 28.1 KB
Line 
1/*
2 Unix SMB/CIFS mplementation.
3 LDAP protocol helper functions for SAMBA
4
5 Copyright (C) Simo Sorce 2005
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 3 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, see <http://www.gnu.org/licenses/>.
19
20*/
21
22#include "includes.h"
23#include "../lib/util/asn1.h"
24#include "libcli/ldap/libcli_ldap.h"
25#include "libcli/ldap/ldap_proto.h"
26#include "dsdb/samdb/samdb.h"
27
28static bool decode_server_sort_response(void *mem_ctx, DATA_BLOB in, void *_out)
29{
30 void **out = (void **)_out;
31 DATA_BLOB attr;
32 struct asn1_data *data = asn1_init(mem_ctx);
33 struct ldb_sort_resp_control *lsrc;
34
35 if (!data) return false;
36
37 if (!asn1_load(data, in)) {
38 return false;
39 }
40
41 lsrc = talloc(mem_ctx, struct ldb_sort_resp_control);
42 if (!lsrc) {
43 return false;
44 }
45
46 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
47 return false;
48 }
49
50 if (!asn1_read_enumerated(data, &(lsrc->result))) {
51 return false;
52 }
53
54 lsrc->attr_desc = NULL;
55 if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
56 if (!asn1_read_OctetString(data, mem_ctx, &attr)) {
57 return false;
58 }
59 lsrc->attr_desc = talloc_strndup(lsrc, (const char *)attr.data, attr.length);
60 if (!lsrc->attr_desc) {
61 return false;
62 }
63 }
64
65 if (!asn1_end_tag(data)) {
66 return false;
67 }
68
69 *out = lsrc;
70
71 return true;
72}
73
74static bool decode_server_sort_request(void *mem_ctx, DATA_BLOB in, void *_out)
75{
76 void **out = (void **)_out;
77 DATA_BLOB attr;
78 DATA_BLOB rule;
79 struct asn1_data *data = asn1_init(mem_ctx);
80 struct ldb_server_sort_control **lssc;
81 int num;
82
83 if (!data) return false;
84
85 if (!asn1_load(data, in)) {
86 return false;
87 }
88
89 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
90 return false;
91 }
92
93 lssc = NULL;
94
95 for (num = 0; asn1_peek_tag(data, ASN1_SEQUENCE(0)); num++) {
96 lssc = talloc_realloc(mem_ctx, lssc, struct ldb_server_sort_control *, num + 2);
97 if (!lssc) {
98 return false;
99 }
100 lssc[num] = talloc_zero(lssc, struct ldb_server_sort_control);
101 if (!lssc[num]) {
102 return false;
103 }
104
105 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
106 return false;
107 }
108
109 if (!asn1_read_OctetString(data, mem_ctx, &attr)) {
110 return false;
111 }
112
113 lssc[num]->attributeName = talloc_strndup(lssc[num], (const char *)attr.data, attr.length);
114 if (!lssc [num]->attributeName) {
115 return false;
116 }
117
118 if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
119 if (!asn1_read_OctetString(data, mem_ctx, &rule)) {
120 return false;
121 }
122 lssc[num]->orderingRule = talloc_strndup(lssc[num], (const char *)rule.data, rule.length);
123 if (!lssc[num]->orderingRule) {
124 return false;
125 }
126 }
127
128 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(1))) {
129 bool reverse;
130 if (!asn1_read_BOOLEAN_context(data, &reverse, 1)) {
131 return false;
132 }
133 lssc[num]->reverse = reverse;
134 }
135
136 if (!asn1_end_tag(data)) {
137 return false;
138 }
139 }
140
141 if (lssc != NULL) {
142 lssc[num] = NULL;
143 }
144
145 if (!asn1_end_tag(data)) {
146 return false;
147 }
148
149 *out = lssc;
150
151 return true;
152}
153
154static bool decode_extended_dn_request(void *mem_ctx, DATA_BLOB in, void *_out)
155{
156 void **out = (void **)_out;
157 struct asn1_data *data;
158 struct ldb_extended_dn_control *ledc;
159
160 /* The content of this control is optional */
161 if (in.length == 0) {
162 *out = NULL;
163 return true;
164 }
165
166 data = asn1_init(mem_ctx);
167 if (!data) return false;
168
169 if (!asn1_load(data, in)) {
170 return false;
171 }
172
173 ledc = talloc(mem_ctx, struct ldb_extended_dn_control);
174 if (!ledc) {
175 return false;
176 }
177
178 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
179 return false;
180 }
181
182 if (!asn1_read_Integer(data, &(ledc->type))) {
183 return false;
184 }
185
186 if (!asn1_end_tag(data)) {
187 return false;
188 }
189
190 *out = ledc;
191
192 return true;
193}
194
195static bool decode_sd_flags_request(void *mem_ctx, DATA_BLOB in, void *_out)
196{
197 void **out = (void **)_out;
198 struct asn1_data *data = asn1_init(mem_ctx);
199 struct ldb_sd_flags_control *lsdfc;
200
201 if (!data) return false;
202
203 if (!asn1_load(data, in)) {
204 return false;
205 }
206
207 lsdfc = talloc(mem_ctx, struct ldb_sd_flags_control);
208 if (!lsdfc) {
209 return false;
210 }
211
212 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
213 return false;
214 }
215
216 if (!asn1_read_Integer(data, (int *) &(lsdfc->secinfo_flags))) {
217 return false;
218 }
219
220 if (!asn1_end_tag(data)) {
221 return false;
222 }
223
224 *out = lsdfc;
225
226 return true;
227}
228
229static bool decode_search_options_request(void *mem_ctx, DATA_BLOB in, void *_out)
230{
231 void **out = (void **)_out;
232 struct asn1_data *data = asn1_init(mem_ctx);
233 struct ldb_search_options_control *lsoc;
234
235 if (!data) return false;
236
237 if (!asn1_load(data, in)) {
238 return false;
239 }
240
241 lsoc = talloc(mem_ctx, struct ldb_search_options_control);
242 if (!lsoc) {
243 return false;
244 }
245
246 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
247 return false;
248 }
249
250 if (!asn1_read_Integer(data, (int *) &(lsoc->search_options))) {
251 return false;
252 }
253
254 if (!asn1_end_tag(data)) {
255 return false;
256 }
257
258 *out = lsoc;
259
260 return true;
261}
262
263static bool decode_paged_results_request(void *mem_ctx, DATA_BLOB in, void *_out)
264{
265 void **out = (void **)_out;
266 DATA_BLOB cookie;
267 struct asn1_data *data = asn1_init(mem_ctx);
268 struct ldb_paged_control *lprc;
269
270 if (!data) return false;
271
272 if (!asn1_load(data, in)) {
273 return false;
274 }
275
276 lprc = talloc(mem_ctx, struct ldb_paged_control);
277 if (!lprc) {
278 return false;
279 }
280
281 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
282 return false;
283 }
284
285 if (!asn1_read_Integer(data, &(lprc->size))) {
286 return false;
287 }
288
289 if (!asn1_read_OctetString(data, mem_ctx, &cookie)) {
290 return false;
291 }
292 lprc->cookie_len = cookie.length;
293 if (lprc->cookie_len) {
294 lprc->cookie = talloc_memdup(lprc, cookie.data, cookie.length);
295
296 if (!(lprc->cookie)) {
297 return false;
298 }
299 } else {
300 lprc->cookie = NULL;
301 }
302
303 if (!asn1_end_tag(data)) {
304 return false;
305 }
306
307 *out = lprc;
308
309 return true;
310}
311
312static bool decode_dirsync_request(void *mem_ctx, DATA_BLOB in, void *_out)
313{
314 void **out = (void **)_out;
315 DATA_BLOB cookie;
316 struct asn1_data *data = asn1_init(mem_ctx);
317 struct ldb_dirsync_control *ldc;
318
319 if (!data) return false;
320
321 if (!asn1_load(data, in)) {
322 return false;
323 }
324
325 ldc = talloc(mem_ctx, struct ldb_dirsync_control);
326 if (!ldc) {
327 return false;
328 }
329
330 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
331 return false;
332 }
333
334 if (!asn1_read_Integer(data, &(ldc->flags))) {
335 return false;
336 }
337
338 if (!asn1_read_Integer(data, &(ldc->max_attributes))) {
339 return false;
340 }
341
342 if (!asn1_read_OctetString(data, mem_ctx, &cookie)) {
343 return false;
344 }
345 ldc->cookie_len = cookie.length;
346 if (ldc->cookie_len) {
347 ldc->cookie = talloc_memdup(ldc, cookie.data, cookie.length);
348
349 if (!(ldc->cookie)) {
350 return false;
351 }
352 } else {
353 ldc->cookie = NULL;
354 }
355
356 if (!asn1_end_tag(data)) {
357 return false;
358 }
359
360 *out = ldc;
361
362 return true;
363}
364
365/* seem that this controls has 2 forms one in case it is used with
366 * a Search Request and another when used ina Search Response
367 */
368static bool decode_asq_control(void *mem_ctx, DATA_BLOB in, void *_out)
369{
370 void **out = (void **)_out;
371 DATA_BLOB source_attribute;
372 struct asn1_data *data = asn1_init(mem_ctx);
373 struct ldb_asq_control *lac;
374
375 if (!data) return false;
376
377 if (!asn1_load(data, in)) {
378 return false;
379 }
380
381 lac = talloc(mem_ctx, struct ldb_asq_control);
382 if (!lac) {
383 return false;
384 }
385
386 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
387 return false;
388 }
389
390 if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
391
392 if (!asn1_read_OctetString(data, mem_ctx, &source_attribute)) {
393 return false;
394 }
395 lac->src_attr_len = source_attribute.length;
396 if (lac->src_attr_len) {
397 lac->source_attribute = talloc_strndup(lac, (const char *)source_attribute.data, source_attribute.length);
398
399 if (!(lac->source_attribute)) {
400 return false;
401 }
402 } else {
403 lac->source_attribute = NULL;
404 }
405
406 lac->request = 1;
407
408 } else if (asn1_peek_tag(data, ASN1_ENUMERATED)) {
409
410 if (!asn1_read_enumerated(data, &(lac->result))) {
411 return false;
412 }
413
414 lac->request = 0;
415
416 } else {
417 return false;
418 }
419
420 if (!asn1_end_tag(data)) {
421 return false;
422 }
423
424 *out = lac;
425
426 return true;
427}
428
429static bool decode_vlv_request(void *mem_ctx, DATA_BLOB in, void *_out)
430{
431 void **out = (void **)_out;
432 DATA_BLOB assertion_value, context_id;
433 struct asn1_data *data = asn1_init(mem_ctx);
434 struct ldb_vlv_req_control *lvrc;
435
436 if (!data) return false;
437
438 if (!asn1_load(data, in)) {
439 return false;
440 }
441
442 lvrc = talloc(mem_ctx, struct ldb_vlv_req_control);
443 if (!lvrc) {
444 return false;
445 }
446
447 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
448 return false;
449 }
450
451 if (!asn1_read_Integer(data, &(lvrc->beforeCount))) {
452 return false;
453 }
454
455 if (!asn1_read_Integer(data, &(lvrc->afterCount))) {
456 return false;
457 }
458
459 if (asn1_peek_tag(data, ASN1_CONTEXT(0))) {
460
461 lvrc->type = 0;
462
463 if (!asn1_start_tag(data, ASN1_CONTEXT(0))) {
464 return false;
465 }
466
467 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
468 return false;
469 }
470
471 if (!asn1_read_Integer(data, &(lvrc->match.byOffset.offset))) {
472 return false;
473 }
474
475 if (!asn1_read_Integer(data, &(lvrc->match.byOffset.contentCount))) {
476 return false;
477 }
478
479 if (!asn1_end_tag(data)) { /*SEQUENCE*/
480 return false;
481 }
482
483 if (!asn1_end_tag(data)) { /*CONTEXT*/
484 return false;
485 }
486
487 } else {
488
489 lvrc->type = 1;
490
491 if (!asn1_start_tag(data, ASN1_CONTEXT(1))) {
492 return false;
493 }
494
495 if (!asn1_read_OctetString(data, mem_ctx, &assertion_value)) {
496 return false;
497 }
498 lvrc->match.gtOrEq.value_len = assertion_value.length;
499 if (lvrc->match.gtOrEq.value_len) {
500 lvrc->match.gtOrEq.value = talloc_memdup(lvrc, assertion_value.data, assertion_value.length);
501
502 if (!(lvrc->match.gtOrEq.value)) {
503 return false;
504 }
505 } else {
506 lvrc->match.gtOrEq.value = NULL;
507 }
508
509 if (!asn1_end_tag(data)) { /*CONTEXT*/
510 return false;
511 }
512 }
513
514 if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
515 if (!asn1_read_OctetString(data, mem_ctx, &context_id)) {
516 return false;
517 }
518 lvrc->ctxid_len = context_id.length;
519 if (lvrc->ctxid_len) {
520 lvrc->contextId = talloc_memdup(lvrc, context_id.data, context_id.length);
521
522 if (!(lvrc->contextId)) {
523 return false;
524 }
525 } else {
526 lvrc->contextId = NULL;
527 }
528 } else {
529 lvrc->contextId = NULL;
530 lvrc->ctxid_len = 0;
531 }
532
533 if (!asn1_end_tag(data)) {
534 return false;
535 }
536
537 *out = lvrc;
538
539 return true;
540}
541
542static bool decode_vlv_response(void *mem_ctx, DATA_BLOB in, void *_out)
543{
544 void **out = (void **)_out;
545 DATA_BLOB context_id;
546 struct asn1_data *data = asn1_init(mem_ctx);
547 struct ldb_vlv_resp_control *lvrc;
548
549 if (!data) return false;
550
551 if (!asn1_load(data, in)) {
552 return false;
553 }
554
555 lvrc = talloc(mem_ctx, struct ldb_vlv_resp_control);
556 if (!lvrc) {
557 return false;
558 }
559
560 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
561 return false;
562 }
563
564 if (!asn1_read_Integer(data, &(lvrc->targetPosition))) {
565 return false;
566 }
567
568 if (!asn1_read_Integer(data, &(lvrc->contentCount))) {
569 return false;
570 }
571
572 if (!asn1_read_enumerated(data, &(lvrc->vlv_result))) {
573 return false;
574 }
575
576 if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
577 if (!asn1_read_OctetString(data, mem_ctx, &context_id)) {
578 return false;
579 }
580 lvrc->contextId = talloc_strndup(lvrc, (const char *)context_id.data, context_id.length);
581 if (!lvrc->contextId) {
582 return false;
583 }
584 lvrc->ctxid_len = context_id.length;
585 } else {
586 lvrc->contextId = NULL;
587 lvrc->ctxid_len = 0;
588 }
589
590 if (!asn1_end_tag(data)) {
591 return false;
592 }
593
594 *out = lvrc;
595
596 return true;
597}
598
599static bool encode_server_sort_response(void *mem_ctx, void *in, DATA_BLOB *out)
600{
601 struct ldb_sort_resp_control *lsrc = talloc_get_type(in, struct ldb_sort_resp_control);
602 struct asn1_data *data = asn1_init(mem_ctx);
603
604 if (!data) return false;
605
606 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
607 return false;
608 }
609
610 if (!asn1_write_enumerated(data, lsrc->result)) {
611 return false;
612 }
613
614 if (lsrc->attr_desc) {
615 if (!asn1_write_OctetString(data, lsrc->attr_desc, strlen(lsrc->attr_desc))) {
616 return false;
617 }
618 }
619
620 if (!asn1_pop_tag(data)) {
621 return false;
622 }
623
624 *out = data_blob_talloc(mem_ctx, data->data, data->length);
625 if (out->data == NULL) {
626 return false;
627 }
628 talloc_free(data);
629
630 return true;
631}
632
633static bool encode_server_sort_request(void *mem_ctx, void *in, DATA_BLOB *out)
634{
635 struct ldb_server_sort_control **lssc = talloc_get_type(in, struct ldb_server_sort_control *);
636 struct asn1_data *data = asn1_init(mem_ctx);
637 int num;
638
639 if (!data) return false;
640
641 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
642 return false;
643 }
644
645 /*
646 RFC2891 section 1.1:
647 SortKeyList ::= SEQUENCE OF SEQUENCE {
648 attributeType AttributeDescription,
649 orderingRule [0] MatchingRuleId OPTIONAL,
650 reverseOrder [1] BOOLEAN DEFAULT FALSE }
651 */
652 for (num = 0; lssc[num]; num++) {
653 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
654 return false;
655 }
656
657 if (!asn1_write_OctetString(data, lssc[num]->attributeName, strlen(lssc[num]->attributeName))) {
658 return false;
659 }
660
661 if (lssc[num]->orderingRule) {
662 if (!asn1_write_OctetString(data, lssc[num]->orderingRule, strlen(lssc[num]->orderingRule))) {
663 return false;
664 }
665 }
666
667 if (lssc[num]->reverse) {
668 if (!asn1_write_BOOLEAN_context(data, lssc[num]->reverse, 1)) {
669 return false;
670 }
671 }
672
673 if (!asn1_pop_tag(data)) {
674 return false;
675 }
676 }
677
678 if (!asn1_pop_tag(data)) {
679 return false;
680 }
681
682 *out = data_blob_talloc(mem_ctx, data->data, data->length);
683 if (out->data == NULL) {
684 return false;
685 }
686 talloc_free(data);
687
688 return true;
689}
690
691static bool encode_extended_dn_request(void *mem_ctx, void *in, DATA_BLOB *out)
692{
693 struct ldb_extended_dn_control *ledc = talloc_get_type(in, struct ldb_extended_dn_control);
694 struct asn1_data *data;
695
696 if (!in) {
697 *out = data_blob(NULL, 0);
698 return true;
699 }
700
701 data = asn1_init(mem_ctx);
702
703 if (!data) return false;
704
705 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
706 return false;
707 }
708
709 if (!asn1_write_Integer(data, ledc->type)) {
710 return false;
711 }
712
713 if (!asn1_pop_tag(data)) {
714 return false;
715 }
716
717 *out = data_blob_talloc(mem_ctx, data->data, data->length);
718 if (out->data == NULL) {
719 return false;
720 }
721 talloc_free(data);
722
723 return true;
724}
725
726static bool encode_sd_flags_request(void *mem_ctx, void *in, DATA_BLOB *out)
727{
728 struct ldb_sd_flags_control *lsdfc = talloc_get_type(in, struct ldb_sd_flags_control);
729 struct asn1_data *data = asn1_init(mem_ctx);
730
731 if (!data) return false;
732
733 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
734 return false;
735 }
736
737 if (!asn1_write_Integer(data, lsdfc->secinfo_flags)) {
738 return false;
739 }
740
741 if (!asn1_pop_tag(data)) {
742 return false;
743 }
744
745 *out = data_blob_talloc(mem_ctx, data->data, data->length);
746 if (out->data == NULL) {
747 return false;
748 }
749 talloc_free(data);
750
751 return true;
752}
753
754static bool encode_search_options_request(void *mem_ctx, void *in, DATA_BLOB *out)
755{
756 struct ldb_search_options_control *lsoc = talloc_get_type(in, struct ldb_search_options_control);
757 struct asn1_data *data = asn1_init(mem_ctx);
758
759 if (!data) return false;
760
761 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
762 return false;
763 }
764
765 if (!asn1_write_Integer(data, lsoc->search_options)) {
766 return false;
767 }
768
769 if (!asn1_pop_tag(data)) {
770 return false;
771 }
772
773 *out = data_blob_talloc(mem_ctx, data->data, data->length);
774 if (out->data == NULL) {
775 return false;
776 }
777 talloc_free(data);
778
779 return true;
780}
781
782static bool encode_paged_results_request(void *mem_ctx, void *in, DATA_BLOB *out)
783{
784 struct ldb_paged_control *lprc = talloc_get_type(in, struct ldb_paged_control);
785 struct asn1_data *data = asn1_init(mem_ctx);
786
787 if (!data) return false;
788
789 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
790 return false;
791 }
792
793 if (!asn1_write_Integer(data, lprc->size)) {
794 return false;
795 }
796
797 if (!asn1_write_OctetString(data, lprc->cookie, lprc->cookie_len)) {
798 return false;
799 }
800
801 if (!asn1_pop_tag(data)) {
802 return false;
803 }
804
805 *out = data_blob_talloc(mem_ctx, data->data, data->length);
806 if (out->data == NULL) {
807 return false;
808 }
809 talloc_free(data);
810
811 return true;
812}
813
814/* seem that this controls has 2 forms one in case it is used with
815 * a Search Request and another when used ina Search Response
816 */
817static bool encode_asq_control(void *mem_ctx, void *in, DATA_BLOB *out)
818{
819 struct ldb_asq_control *lac = talloc_get_type(in, struct ldb_asq_control);
820 struct asn1_data *data = asn1_init(mem_ctx);
821
822 if (!data) return false;
823
824 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
825 return false;
826 }
827
828 if (lac->request) {
829
830 if (!asn1_write_OctetString(data, lac->source_attribute, lac->src_attr_len)) {
831 return false;
832 }
833 } else {
834 if (!asn1_write_enumerated(data, lac->result)) {
835 return false;
836 }
837 }
838
839 if (!asn1_pop_tag(data)) {
840 return false;
841 }
842
843 *out = data_blob_talloc(mem_ctx, data->data, data->length);
844 if (out->data == NULL) {
845 return false;
846 }
847 talloc_free(data);
848
849 return true;
850}
851
852static bool encode_dirsync_request(void *mem_ctx, void *in, DATA_BLOB *out)
853{
854 struct ldb_dirsync_control *ldc = talloc_get_type(in, struct ldb_dirsync_control);
855 struct asn1_data *data = asn1_init(mem_ctx);
856
857 if (!data) return false;
858
859 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
860 return false;
861 }
862
863 if (!asn1_write_Integer(data, ldc->flags)) {
864 return false;
865 }
866
867 if (!asn1_write_Integer(data, ldc->max_attributes)) {
868 return false;
869 }
870
871 if (!asn1_write_OctetString(data, ldc->cookie, ldc->cookie_len)) {
872 return false;
873 }
874
875 if (!asn1_pop_tag(data)) {
876 return false;
877 }
878
879 *out = data_blob_talloc(mem_ctx, data->data, data->length);
880 if (out->data == NULL) {
881 return false;
882 }
883 talloc_free(data);
884
885 return true;
886}
887
888static bool encode_vlv_request(void *mem_ctx, void *in, DATA_BLOB *out)
889{
890 struct ldb_vlv_req_control *lvrc = talloc_get_type(in, struct ldb_vlv_req_control);
891 struct asn1_data *data = asn1_init(mem_ctx);
892
893 if (!data) return false;
894
895 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
896 return false;
897 }
898
899 if (!asn1_write_Integer(data, lvrc->beforeCount)) {
900 return false;
901 }
902
903 if (!asn1_write_Integer(data, lvrc->afterCount)) {
904 return false;
905 }
906
907 if (lvrc->type == 0) {
908 if (!asn1_push_tag(data, ASN1_CONTEXT(0))) {
909 return false;
910 }
911
912 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
913 return false;
914 }
915
916 if (!asn1_write_Integer(data, lvrc->match.byOffset.offset)) {
917 return false;
918 }
919
920 if (!asn1_write_Integer(data, lvrc->match.byOffset.contentCount)) {
921 return false;
922 }
923
924 if (!asn1_pop_tag(data)) { /*SEQUENCE*/
925 return false;
926 }
927
928 if (!asn1_pop_tag(data)) { /*CONTEXT*/
929 return false;
930 }
931 } else {
932 if (!asn1_push_tag(data, ASN1_CONTEXT(1))) {
933 return false;
934 }
935
936 if (!asn1_write_OctetString(data, lvrc->match.gtOrEq.value, lvrc->match.gtOrEq.value_len)) {
937 return false;
938 }
939
940 if (!asn1_pop_tag(data)) { /*CONTEXT*/
941 return false;
942 }
943 }
944
945 if (lvrc->ctxid_len) {
946 if (!asn1_write_OctetString(data, lvrc->contextId, lvrc->ctxid_len)) {
947 return false;
948 }
949 }
950
951 if (!asn1_pop_tag(data)) {
952 return false;
953 }
954
955 *out = data_blob_talloc(mem_ctx, data->data, data->length);
956 if (out->data == NULL) {
957 return false;
958 }
959 talloc_free(data);
960
961 return true;
962}
963
964static bool encode_vlv_response(void *mem_ctx, void *in, DATA_BLOB *out)
965{
966 struct ldb_vlv_resp_control *lvrc = talloc_get_type(in, struct ldb_vlv_resp_control);
967 struct asn1_data *data = asn1_init(mem_ctx);
968
969 if (!data) return false;
970
971 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
972 return false;
973 }
974
975 if (!asn1_write_Integer(data, lvrc->targetPosition)) {
976 return false;
977 }
978
979 if (!asn1_write_Integer(data, lvrc->contentCount)) {
980 return false;
981 }
982
983 if (!asn1_write_enumerated(data, lvrc->vlv_result)) {
984 return false;
985 }
986
987 if (lvrc->ctxid_len) {
988 if (!asn1_write_OctetString(data, lvrc->contextId, lvrc->ctxid_len)) {
989 return false;
990 }
991 }
992
993 if (!asn1_pop_tag(data)) {
994 return false;
995 }
996
997 *out = data_blob_talloc(mem_ctx, data->data, data->length);
998 if (out->data == NULL) {
999 return false;
1000 }
1001 talloc_free(data);
1002
1003 return true;
1004}
1005
1006static bool encode_openldap_dereference(void *mem_ctx, void *in, DATA_BLOB *out)
1007{
1008 struct dsdb_openldap_dereference_control *control = talloc_get_type(in, struct dsdb_openldap_dereference_control);
1009 int i,j;
1010 struct asn1_data *data = asn1_init(mem_ctx);
1011
1012 if (!data) return false;
1013
1014 if (!control) return false;
1015
1016 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
1017 return false;
1018 }
1019
1020 for (i=0; control->dereference && control->dereference[i]; i++) {
1021 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
1022 return false;
1023 }
1024 if (!asn1_write_OctetString(data, control->dereference[i]->source_attribute, strlen(control->dereference[i]->source_attribute))) {
1025 return false;
1026 }
1027 if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
1028 return false;
1029 }
1030 for (j=0; control->dereference && control->dereference[i]->dereference_attribute[j]; j++) {
1031 if (!asn1_write_OctetString(data, control->dereference[i]->dereference_attribute[j],
1032 strlen(control->dereference[i]->dereference_attribute[j]))) {
1033 return false;
1034 }
1035 }
1036
1037 asn1_pop_tag(data);
1038 asn1_pop_tag(data);
1039 }
1040 asn1_pop_tag(data);
1041
1042 *out = data_blob_talloc(mem_ctx, data->data, data->length);
1043 if (out->data == NULL) {
1044 return false;
1045 }
1046 talloc_free(data);
1047 return true;
1048}
1049
1050static bool decode_openldap_dereference(void *mem_ctx, DATA_BLOB in, void *_out)
1051{
1052 void **out = (void **)_out;
1053 struct asn1_data *data = asn1_init(mem_ctx);
1054 struct dsdb_openldap_dereference_result_control *control;
1055 struct dsdb_openldap_dereference_result **r = NULL;
1056 int i = 0;
1057 if (!data) return false;
1058
1059 control = talloc(mem_ctx, struct dsdb_openldap_dereference_result_control);
1060 if (!control) return false;
1061
1062 if (!asn1_load(data, in)) {
1063 return false;
1064 }
1065
1066 control = talloc(mem_ctx, struct dsdb_openldap_dereference_result_control);
1067 if (!control) {
1068 return false;
1069 }
1070
1071 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
1072 return false;
1073 }
1074
1075 while (asn1_tag_remaining(data) > 0) {
1076 r = talloc_realloc(control, r, struct dsdb_openldap_dereference_result *, i + 2);
1077 if (!r) {
1078 return false;
1079 }
1080 r[i] = talloc_zero(r, struct dsdb_openldap_dereference_result);
1081 if (!r[i]) {
1082 return false;
1083 }
1084
1085 if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
1086 return false;
1087 }
1088
1089 asn1_read_OctetString_talloc(r[i], data, &r[i]->source_attribute);
1090 asn1_read_OctetString_talloc(r[i], data, &r[i]->dereferenced_dn);
1091 if (asn1_peek_tag(data, ASN1_CONTEXT(0))) {
1092 if (!asn1_start_tag(data, ASN1_CONTEXT(0))) {
1093 return false;
1094 }
1095
1096 ldap_decode_attribs_bare(r, data, &r[i]->attributes,
1097 &r[i]->num_attributes);
1098
1099 if (!asn1_end_tag(data)) {
1100 return false;
1101 }
1102 }
1103 if (!asn1_end_tag(data)) {
1104 return false;
1105 }
1106 i++;
1107 r[i] = NULL;
1108 }
1109
1110 if (!asn1_end_tag(data)) {
1111 return false;
1112 }
1113
1114 control->attributes = r;
1115 *out = control;
1116
1117 return true;
1118}
1119
1120static bool encode_flag_request(void *mem_ctx, void *in, DATA_BLOB *out)
1121{
1122 if (in) {
1123 return false;
1124 }
1125
1126 *out = data_blob(NULL, 0);
1127 return true;
1128}
1129
1130static bool decode_flag_request(void *mem_ctx, DATA_BLOB in, void *_out)
1131{
1132 if (in.length != 0) {
1133 return false;
1134 }
1135
1136 return true;
1137}
1138
1139static const struct ldap_control_handler ldap_known_controls[] = {
1140 { LDB_CONTROL_PAGED_RESULTS_OID, decode_paged_results_request, encode_paged_results_request },
1141 { LDB_CONTROL_SD_FLAGS_OID, decode_sd_flags_request, encode_sd_flags_request },
1142 { LDB_CONTROL_DOMAIN_SCOPE_OID, decode_flag_request, encode_flag_request },
1143 { LDB_CONTROL_SEARCH_OPTIONS_OID, decode_search_options_request, encode_search_options_request },
1144 { LDB_CONTROL_NOTIFICATION_OID, decode_flag_request, encode_flag_request },
1145 { LDB_CONTROL_TREE_DELETE_OID, decode_flag_request, encode_flag_request },
1146 { LDB_CONTROL_SHOW_DELETED_OID, decode_flag_request, encode_flag_request },
1147 { LDB_CONTROL_SHOW_RECYCLED_OID, decode_flag_request, encode_flag_request },
1148 { LDB_CONTROL_SHOW_DEACTIVATED_LINK_OID, decode_flag_request, encode_flag_request },
1149 { LDB_CONTROL_EXTENDED_DN_OID, decode_extended_dn_request, encode_extended_dn_request },
1150 { LDB_CONTROL_SERVER_SORT_OID, decode_server_sort_request, encode_server_sort_request },
1151 { LDB_CONTROL_SORT_RESP_OID, decode_server_sort_response, encode_server_sort_response },
1152 { LDB_CONTROL_ASQ_OID, decode_asq_control, encode_asq_control },
1153 { LDB_CONTROL_DIRSYNC_OID, decode_dirsync_request, encode_dirsync_request },
1154 { LDB_CONTROL_VLV_REQ_OID, decode_vlv_request, encode_vlv_request },
1155 { LDB_CONTROL_VLV_RESP_OID, decode_vlv_response, encode_vlv_response },
1156 { LDB_CONTROL_PERMISSIVE_MODIFY_OID, decode_flag_request, encode_flag_request },
1157 { LDB_CONTROL_SERVER_LAZY_COMMIT, decode_flag_request, encode_flag_request },
1158 { LDB_CONTROL_RODC_DCPROMO_OID, decode_flag_request, encode_flag_request },
1159 { LDB_CONTROL_RELAX_OID, decode_flag_request, encode_flag_request },
1160 { DSDB_OPENLDAP_DEREFERENCE_CONTROL, decode_openldap_dereference, encode_openldap_dereference },
1161
1162/* DSDB_CONTROL_CURRENT_PARTITION_OID is internal only, and has no network representation */
1163 { DSDB_CONTROL_CURRENT_PARTITION_OID, NULL, NULL },
1164/* DSDB_CONTROL_REPLICATED_UPDATE_OID is internal only, and has no network representation */
1165 { DSDB_CONTROL_REPLICATED_UPDATE_OID, NULL, NULL },
1166/* DSDB_CONTROL_DN_STORAGE_FORMAT_OID is internal only, and has no network representation */
1167 { DSDB_CONTROL_DN_STORAGE_FORMAT_OID, NULL, NULL },
1168/* LDB_CONTROL_RECALCULATE_SD_OID is internal only, and has no network representation */
1169 { LDB_CONTROL_RECALCULATE_SD_OID, NULL, NULL },
1170/* LDB_CONTROL_REVEAL_INTERNALS is internal only, and has no network representation */
1171 { LDB_CONTROL_REVEAL_INTERNALS, NULL, NULL },
1172/* LDB_CONTROL_AS_SYSTEM_OID is internal only, and has no network representation */
1173 { LDB_CONTROL_AS_SYSTEM_OID, NULL, NULL },
1174/* DSDB_CONTROL_PASSWORD_CHANGE_STATUS_OID is internal only, and has no network representation */
1175 { DSDB_CONTROL_PASSWORD_CHANGE_STATUS_OID, NULL, NULL },
1176/* DSDB_CONTROL_PASSWORD_HASH_VALUES_OID is internal only, and has no network representation */
1177 { DSDB_CONTROL_PASSWORD_HASH_VALUES_OID, NULL, NULL },
1178/* DSDB_CONTROL_PASSWORD_CHANGE_OID is internal only, and has no network representation */
1179 { DSDB_CONTROL_PASSWORD_CHANGE_OID, NULL, NULL },
1180/* DSDB_CONTROL_APPLY_LINKS is internal only, and has no network representation */
1181 { DSDB_CONTROL_APPLY_LINKS, NULL, NULL },
1182/* DSDB_CONTROL_BYPASS_PASSWORD_HASH_OID is internal only, and has an empty network representation */
1183 { DSDB_CONTROL_BYPASS_PASSWORD_HASH_OID, decode_flag_request, encode_flag_request },
1184/* LDB_CONTROL_BYPASS_OPERATIONAL_OID is internal only, and has no network representation */
1185 { LDB_CONTROL_BYPASS_OPERATIONAL_OID, NULL, NULL },
1186/* DSDB_CONTROL_CHANGEREPLMETADATA_OID is internal only, and has no network representation */
1187 { DSDB_CONTROL_CHANGEREPLMETADATA_OID, NULL, NULL },
1188/* LDB_CONTROL_PROVISION_OID is internal only, and has no network representation */
1189 { LDB_CONTROL_PROVISION_OID, NULL, NULL },
1190/* DSDB_EXTENDED_REPLICATED_OBJECTS_OID is internal only, and has no network representation */
1191 { DSDB_EXTENDED_REPLICATED_OBJECTS_OID, NULL, NULL },
1192/* DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID is internal only, and has no network representation */
1193 { DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID, NULL, NULL },
1194/* DSDB_EXTENDED_ALLOCATE_RID_POOL is internal only, and has no network representation */
1195 { DSDB_EXTENDED_ALLOCATE_RID_POOL, NULL, NULL },
1196 { NULL, NULL, NULL }
1197};
1198
1199const struct ldap_control_handler *samba_ldap_control_handlers(void)
1200{
1201 return ldap_known_controls;
1202}
1203
Note: See TracBrowser for help on using the repository browser.