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