LCOV - code coverage report
Current view: top level - source4/libcli/ldap - ldap_ildap.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 43 51 84.3 %
Date: 2021-09-23 10:06:22 Functions: 3 3 100.0 %

          Line data    Source code
       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    ildap api - an api similar to the traditional ldap api
       5             :    
       6             :    Copyright (C) Andrew Tridgell  2005
       7             :     
       8             :    This program is free software; you can redistribute it and/or modify
       9             :    it under the terms of the GNU General Public License as published by
      10             :    the Free Software Foundation; either version 3 of the License, or
      11             :    (at your option) any later version.
      12             :    
      13             :    This program is distributed in the hope that it will be useful,
      14             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             :    GNU General Public License for more details.
      17             :    
      18             :    You should have received a copy of the GNU General Public License
      19             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      20             :    
      21             : */
      22             : 
      23             : #include "includes.h"
      24             : #include "libcli/ldap/libcli_ldap.h"
      25             : #include "libcli/ldap/ldap_client.h"
      26             : 
      27             : 
      28             : /*
      29             :   count the returned search entries
      30             : */
      31       17671 : _PUBLIC_ int ildap_count_entries(struct ldap_connection *conn, struct ldap_message **res)
      32             : {
      33             :         int i;
      34       22445 :         for (i=0;res && res[i];i++) /* noop */ ;
      35       17671 :         return i;
      36             : }
      37             : 
      38             : 
      39             : /*
      40             :   perform a synchronous ldap search
      41             : */
      42       17671 : _PUBLIC_ NTSTATUS ildap_search_bytree(struct ldap_connection *conn, const char *basedn, 
      43             :                              int scope, struct ldb_parse_tree *tree,
      44             :                              const char * const *attrs, bool attributesonly, 
      45             :                              struct ldb_control **control_req,
      46             :                              struct ldb_control ***control_res,
      47             :                              struct ldap_message ***results)
      48             : {
      49             :         struct ldap_message *msg;
      50             :         int n, i;
      51             :         NTSTATUS status;
      52             :         struct ldap_request *req;
      53             : 
      54       17671 :         if (control_res)
      55           0 :                 *control_res = NULL;
      56       17671 :         *results = NULL;
      57             : 
      58       17671 :         msg = new_ldap_message(conn);
      59       17671 :         NT_STATUS_HAVE_NO_MEMORY(msg);
      60             : 
      61       22445 :         for (n=0;attrs && attrs[n];n++) /* noop */ ;
      62             :         
      63       17671 :         msg->type = LDAP_TAG_SearchRequest;
      64       17671 :         msg->r.SearchRequest.basedn = basedn;
      65       17671 :         msg->r.SearchRequest.scope  = scope;
      66       17671 :         msg->r.SearchRequest.deref  = LDAP_DEREFERENCE_NEVER;
      67       17671 :         msg->r.SearchRequest.timelimit = 0;
      68       17671 :         msg->r.SearchRequest.sizelimit = 0;
      69       17671 :         msg->r.SearchRequest.attributesonly = attributesonly;
      70       17671 :         msg->r.SearchRequest.tree = tree;
      71       17671 :         msg->r.SearchRequest.num_attributes = n;
      72       17671 :         msg->r.SearchRequest.attributes = attrs;
      73       17671 :         msg->controls = control_req;
      74             : 
      75       17671 :         req = ldap_request_send(conn, msg);
      76       17671 :         talloc_reparent(conn, msg, req);
      77             :         
      78       35342 :         for (i=n=0;true;i++) {
      79             :                 struct ldap_message *res;
      80       35342 :                 status = ldap_result_n(req, i, &res);
      81       48117 :                 if (!NT_STATUS_IS_OK(status)) break;
      82             : 
      83       35342 :                 if (res->type == LDAP_TAG_SearchResultDone) {
      84       17671 :                         status = ldap_check_response(conn, &res->r.GeneralResult);
      85       17671 :                         if (control_res) {
      86           0 :                                 *control_res = talloc_steal(conn, res->controls);
      87             :                         }
      88       17549 :                         break;
      89             :                 }
      90             : 
      91       17671 :                 if (res->type != LDAP_TAG_SearchResultEntry &&
      92           0 :                     res->type != LDAP_TAG_SearchResultReference)
      93           0 :                         continue;
      94             :                 
      95       17671 :                 (*results) = talloc_realloc(conn, *results, struct ldap_message *, n+2);
      96       17671 :                 if (*results == NULL) {
      97           0 :                         talloc_free(msg);
      98           0 :                         return NT_STATUS_NO_MEMORY;
      99             :                 }
     100       17671 :                 (*results)[n] = talloc_steal(*results, res);
     101       17671 :                 (*results)[n+1] = NULL;
     102       17671 :                 n++;
     103             :         }
     104             : 
     105       17671 :         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
     106           0 :                 status = NT_STATUS_OK;
     107             :         }
     108             : 
     109       17671 :         return status;
     110             : }
     111             : 
     112             : /*
     113             :   perform a ldap search
     114             : */
     115       17671 : _PUBLIC_ NTSTATUS ildap_search(struct ldap_connection *conn, const char *basedn, 
     116             :                       int scope, const char *expression, 
     117             :                       const char * const *attrs, bool attributesonly, 
     118             :                       struct ldb_control **control_req,
     119             :                       struct ldb_control ***control_res,
     120             :                       struct ldap_message ***results)
     121             : {
     122             :         NTSTATUS status;
     123       17671 :         struct ldb_parse_tree *tree = ldb_parse_tree(conn, expression);
     124             : 
     125       17671 :         if (tree == NULL) {
     126           0 :                 return NT_STATUS_INVALID_PARAMETER;
     127             :         }
     128       17671 :         status = ildap_search_bytree(conn, basedn, scope, tree, attrs,
     129             :                                      attributesonly, control_req,
     130             :                                      control_res, results);
     131       17671 :         talloc_free(tree);
     132       17671 :         return status;
     133             : }

Generated by: LCOV version 1.13