LCOV - code coverage report
Current view: top level - source4/libcli/ldap - ldap_controls.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 308 639 48.2 %
Date: 2024-02-28 12:06:22 Functions: 21 27 77.8 %

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

Generated by: LCOV version 1.14