Changeset 740 for vendor/current/source4/cldap_server

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/source4/cldap_server

Files:

• cldap_server.c (modified) (8 diffs)
• cldap_server.h (modified) (2 diffs)
• config.mk (deleted)
• netlogon.c (modified) (19 diffs)
• rootdse.c (modified) (6 diffs)
• wscript_build (added)

vendor/current/source4/cldap_server/cldap_server.c

@@ -22 +22 @@
 #include "includes.h"
 #include <talloc.h>
-#include "libcli/ldap/ldap.h"
 #include "lib/messaging/irpc.h"
 #include "smbd/service_task.h"
@@ -29 +28 @@
 #include "system/network.h"
 #include "lib/socket/netif.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "dsdb/samdb/samdb.h"
 #include "ldb_wrap.h"
@@ -113 +112 @@
                                                 "ip",
                                                 address,
-                                                lp_cldap_port(lp_ctx),
+                                                lpcfg_cldap_port(lp_ctx),
                                                 &socket_address);
         if (ret != 0) {
                 status = map_nt_error_from_unix(errno);
                 DEBUG(0,("invalid address %s:%d - %s:%s\n",
-                         address, lp_cldap_port(lp_ctx),
+                         address, lpcfg_cldap_port(lp_ctx),
                          gai_strerror(ret), nt_errstr(status)));
                 return status;
@@ -149 +148 @@
                                           struct interface *ifaces)
 {
-        int num_interfaces;
+        int i, num_interfaces;
         TALLOC_CTX *tmp_ctx = talloc_new(cldapd);
         NTSTATUS status;
-        int i;
 
         num_interfaces = iface_count(ifaces);
@@ -158 +156 @@
         /* if we are allowing incoming packets from any address, then
            we need to bind to the wildcard address */
-        if (!lp_bind_interfaces_only(lp_ctx)) {
+        if (!lpcfg_bind_interfaces_only(lp_ctx)) {
                 status = cldapd_add_socket(cldapd, lp_ctx, "0.0.0.0");
                 NT_STATUS_NOT_OK_RETURN(status);
@@ -185 +183 @@
         struct interface *ifaces;
         
-        load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+        load_interfaces(task, lpcfg_interfaces(task->lp_ctx), &ifaces);
 
         if (iface_count(ifaces) == 0) {
@@ -192 +190 @@
         }
 
-        switch (lp_server_role(task->lp_ctx)) {
+        switch (lpcfg_server_role(task->lp_ctx)) {
         case ROLE_STANDALONE:
                 task_server_terminate(task, "cldap_server: no CLDAP server required in standalone configuration", 
@@ -215 +213 @@
 
         cldapd->task = task;
-        cldapd->samctx = samdb_connect(cldapd, task->event_ctx, task->lp_ctx, system_session(cldapd, task->lp_ctx));
+        cldapd->samctx = samdb_connect(cldapd, task->event_ctx, task->lp_ctx, system_session(task->lp_ctx), 0);
         if (cldapd->samctx == NULL) {
                 task_server_terminate(task, "cldapd failed to open samdb", true);

vendor/current/source4/cldap_server/cldap_server.h

@@ -21 +21 @@
 
 #include "libcli/cldap/cldap.h"
+#include "libcli/ldap/libcli_ldap.h"
 
 /*
@@ -32 +33 @@
 struct ldap_SearchRequest;
 
+/* used by netlogon DCE/RPC server */
+NTSTATUS fill_netlogon_samlogon_response(struct ldb_context *sam_ctx,
+                                         TALLOC_CTX *mem_ctx,
+                                         const char *domain,
+                                         const char *netbios_domain,
+                                         struct dom_sid *domain_sid,
+                                         const char *domain_guid,
+                                         const char *user,
+                                         uint32_t acct_control,
+                                         const char *src_address,
+                                         uint32_t version,
+                                         struct loadparm_context *lp_ctx,
+                                         struct netlogon_samlogon_response *netlogon,
+                                         bool fill_on_blank_request);
+
 #include "cldap_server/proto.h"

vendor/current/source4/cldap_server/netlogon.c

@@ -22 +22 @@
 
 #include "includes.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "lib/events/events.h"
 #include "smbd/service_task.h"
@@ -37 +37 @@
 #include "param/param.h"
 #include "../lib/tsocket/tsocket.h"
+#include "libds/common/flag_mapping.h"
 
 /*
@@ -52 +53 @@
                                          uint32_t version,
                                          struct loadparm_context *lp_ctx,
-                                         struct netlogon_samlogon_response *netlogon)
+                                         struct netlogon_samlogon_response *netlogon,
+                                         bool fill_on_blank_request)
 {
         const char *dom_attrs[] = {"objectGUID", NULL};
@@ -58 +60 @@
         struct ldb_result *dom_res = NULL, *user_res = NULL;
         int ret;
-        const char **services = lp_server_services(lp_ctx);
+        const char **services = lpcfg_server_services(lp_ctx);
         uint32_t server_type;
         const char *pdc_name;
         struct GUID domain_uuid;
-        const char *realm;
         const char *dns_domain;
+        const char *forest_domain;
         const char *pdc_dns_name;
         const char *flatname;
@@ -71 +73 @@
         struct ldb_dn *domain_dn = NULL;
         struct interface *ifaces;
-        bool user_known;
+        bool user_known, am_rodc;
         NTSTATUS status;
 
-        /* the domain has an optional trailing . */
+        /* the domain parameter could have an optional trailing "." */
         if (domain && domain[strlen(domain)-1] == '.') {
                 domain = talloc_strndup(mem_ctx, domain, strlen(domain)-1);
-        }
-
-        if (domain && strcasecmp_m(domain, lp_realm(lp_ctx)) == 0) {
+                NT_STATUS_HAVE_NO_MEMORY(domain);
+        }
+
+        /* Lookup using long or short domainname */
+        if (domain && (strcasecmp_m(domain, lpcfg_dnsdomain(lp_ctx)) == 0)) {
                 domain_dn = ldb_get_default_basedn(sam_ctx);
         }
-
-        if (netbios_domain && strcasecmp_m(domain, lp_sam_name(lp_ctx))) {
+        if (netbios_domain && (strcasecmp_m(netbios_domain, lpcfg_sam_name(lp_ctx)) == 0)) {
                 domain_dn = ldb_get_default_basedn(sam_ctx);
         }
-
         if (domain_dn) {
+                const char *domain_identifier = domain != NULL ? domain
+                                                        : netbios_domain;
                 ret = ldb_search(sam_ctx, mem_ctx, &dom_res,
                                  domain_dn, LDB_SCOPE_BASE, dom_attrs,
                                  "objectClass=domain");
                 if (ret != LDB_SUCCESS) {
-                        DEBUG(2,("Error finding domain '%s'/'%s' in sam: %s\n", domain, ldb_dn_get_linearized(domain_dn), ldb_errstring(sam_ctx)));
+                        DEBUG(2,("Error finding domain '%s'/'%s' in sam: %s\n",
+                                 domain_identifier,
+                                 ldb_dn_get_linearized(domain_dn),
+                                 ldb_errstring(sam_ctx)));
                         return NT_STATUS_NO_SUCH_DOMAIN;
                 }
                 if (dom_res->count != 1) {
-                        DEBUG(2,("Error finding domain '%s'/'%s' in sam\n", domain, ldb_dn_get_linearized(domain_dn)));
+                        DEBUG(2,("Error finding domain '%s'/'%s' in sam\n",
+                                 domain_identifier,
+                                 ldb_dn_get_linearized(domain_dn)));
                         return NT_STATUS_NO_SUCH_DOMAIN;
                 }
         }
 
-        if ((dom_res == NULL || dom_res->count == 0) && (domain_guid || domain_sid)) {
-
+        /* Lookup using GUID or SID */
+        if ((dom_res == NULL) && (domain_guid || domain_sid)) {
                 if (domain_guid) {
                         struct GUID binary_guid;
                         struct ldb_val guid_val;
-                        enum ndr_err_code ndr_err;
 
                         /* By this means, we ensure we don't have funny stuff in the GUID */
@@ -116 +124 @@
 
                         /* And this gets the result into the binary format we want anyway */
-                        ndr_err = ndr_push_struct_blob(&guid_val, mem_ctx, NULL, &binary_guid,
-                                                       (ndr_push_flags_fn_t)ndr_push_GUID);
-                        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                                return NT_STATUS_INVALID_PARAMETER;
+                        status = GUID_to_ndr_blob(&binary_guid, mem_ctx, &guid_val);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                return status;
                         }
                         ret = ldb_search(sam_ctx, mem_ctx, &dom_res,
@@ -132 +139 @@
                         
                         /* Rather than go via the string, just push into the NDR form */
-                        ndr_err = ndr_push_struct_blob(&sid_val, mem_ctx, NULL, &sid,
+                        ndr_err = ndr_push_struct_blob(&sid_val, mem_ctx, &sid,
                                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
@@ -141 +148 @@
                                                  NULL, LDB_SCOPE_SUBTREE, 
                                                  dom_attrs, 
-                                                 "(&(objectCategory=DomainDNS)(objectSID=%s))", 
+                                                 "(&(objectCategory=DomainDNS)(objectSid=%s))",
                                                  ldb_binary_encode(mem_ctx, sid_val));
                 }
                 
                 if (ret != LDB_SUCCESS) {
-                        DEBUG(2,("Unable to find referece to GUID '%s' or SID %s in sam: %s\n",
+                        DEBUG(2,("Unable to find a correct reference to GUID '%s' or SID '%s' in sam: %s\n",
                                  domain_guid, dom_sid_string(mem_ctx, domain_sid),
                                  ldb_errstring(sam_ctx)));
@@ -152 +159 @@
                 } else if (dom_res->count == 1) {
                         /* Ok, now just check it is our domain */
-                        
-                        if (ldb_dn_compare(ldb_get_default_basedn(sam_ctx), dom_res->msgs[0]->dn) != 0) {
+                        if (ldb_dn_compare(ldb_get_default_basedn(sam_ctx),
+                                           dom_res->msgs[0]->dn) != 0) {
+                                DEBUG(2,("The GUID '%s' or SID '%s' doesn't identify our domain\n",
+                                         domain_guid,
+                                         dom_sid_string(mem_ctx, domain_sid)));
                                 return NT_STATUS_NO_SUCH_DOMAIN;
                         }
-                } else if (dom_res->count > 1) {
+                } else {
+                        DEBUG(2,("Unable to find a correct reference to GUID '%s' or SID '%s' in sam\n",
+                                 domain_guid, dom_sid_string(mem_ctx, domain_sid)));
                         return NT_STATUS_NO_SUCH_DOMAIN;
                 }
         }
 
-
-        if ((dom_res == NULL || dom_res->count == 0)) {
-                DEBUG(2,("Unable to find domain with name %s or GUID {%s}\n", domain, domain_guid));
+        if (dom_res == NULL && fill_on_blank_request) {
+                /* blank inputs gives our domain - tested against
+                   w2k8r2. Without this ADUC on Win7 won't start */
+                domain_dn = ldb_get_default_basedn(sam_ctx);
+                ret = ldb_search(sam_ctx, mem_ctx, &dom_res,
+                                 domain_dn, LDB_SCOPE_BASE, dom_attrs,
+                                 "objectClass=domain");
+                if (ret != LDB_SUCCESS) {
+                        DEBUG(2,("Error finding domain '%s'/'%s' in sam: %s\n",
+                                 lpcfg_dnsdomain(lp_ctx),
+                                 ldb_dn_get_linearized(domain_dn),
+                                 ldb_errstring(sam_ctx)));
+                        return NT_STATUS_NO_SUCH_DOMAIN;
+                }
+        }
+
+        if (dom_res == NULL) {
+                DEBUG(2,(__location__ ": Unable to get domain information with no inputs\n"));
                 return NT_STATUS_NO_SUCH_DOMAIN;
         }
@@ -192 +219 @@
                                          UF_ACCOUNTDISABLE, ds_acb2uf(acct_control));
                 if (ret != LDB_SUCCESS) {
-                        DEBUG(2,("Unable to find referece to user '%s' with ACB 0x%8x under %s: %s\n",
+                        DEBUG(2,("Unable to find reference to user '%s' with ACB 0x%8x under %s: %s\n",
                                  user, acct_control, ldb_dn_get_linearized(dom_res->msgs[0]->dn),
                                  ldb_errstring(sam_ctx)));
@@ -207 +234 @@
                 
         server_type      = 
-                NBT_SERVER_DS | NBT_SERVER_TIMESERV |
-                NBT_SERVER_CLOSEST | NBT_SERVER_WRITABLE | 
-                NBT_SERVER_GOOD_TIMESERV | DS_DNS_CONTROLLER |
-                DS_DNS_DOMAIN;
+                DS_SERVER_DS | DS_SERVER_TIMESERV |
+                DS_SERVER_CLOSEST |
+                DS_SERVER_GOOD_TIMESERV;
+
+#if 0
+        /* w2k8-r2 as a DC does not claim these */
+        server_type |= DS_DNS_CONTROLLER | DS_DNS_DOMAIN;
+#endif
 
         if (samdb_is_pdc(sam_ctx)) {
-                int *domainFunctionality;
-                server_type |= NBT_SERVER_PDC;
-                domainFunctionality = talloc_get_type(ldb_get_opaque(sam_ctx, "domainFunctionality"), int);
-                if (domainFunctionality && *domainFunctionality >= DS_DOMAIN_FUNCTION_2008) {
-                        server_type |= NBT_SERVER_FULL_SECRET_DOMAIN_6;
-                }
+                server_type |= DS_SERVER_PDC;
+        }
+
+        if (dsdb_functional_level(sam_ctx) >= DS_DOMAIN_FUNCTION_2008) {
+                server_type |= DS_SERVER_FULL_SECRET_DOMAIN_6;
         }
 
         if (samdb_is_gc(sam_ctx)) {
-                server_type |= NBT_SERVER_GC;
+                server_type |= DS_SERVER_GC;
         }
 
         if (str_list_check(services, "ldap")) {
-                server_type |= NBT_SERVER_LDAP;
+                server_type |= DS_SERVER_LDAP;
         }
 
         if (str_list_check(services, "kdc")) {
-                server_type |= NBT_SERVER_KDC;
-        }
-
+                server_type |= DS_SERVER_KDC;
+        }
+
+        if (samdb_rodc(sam_ctx, &am_rodc) == LDB_SUCCESS && !am_rodc) {
+                server_type |= DS_SERVER_WRITABLE;
+        }
+
+#if 0
+        /* w2k8-r2 as a sole DC does not claim this */
         if (ldb_dn_compare(ldb_get_root_basedn(sam_ctx), ldb_get_default_basedn(sam_ctx)) == 0) {
-                server_type |= DS_DNS_FOREST;
-        }
-
-        pdc_name         = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name(lp_ctx));
+                server_type |= DS_DNS_FOREST_ROOT;
+        }
+#endif
+
+        pdc_name         = talloc_asprintf(mem_ctx, "\\\\%s",
+                                           lpcfg_netbios_name(lp_ctx));
+        NT_STATUS_HAVE_NO_MEMORY(pdc_name);
         domain_uuid      = samdb_result_guid(dom_res->msgs[0], "objectGUID");
-        realm            = lp_realm(lp_ctx);
-        dns_domain       = lp_realm(lp_ctx);
+        dns_domain       = lpcfg_dnsdomain(lp_ctx);
+        forest_domain    = samdb_forest_name(sam_ctx, mem_ctx);
+        NT_STATUS_HAVE_NO_MEMORY(forest_domain);
         pdc_dns_name     = talloc_asprintf(mem_ctx, "%s.%s", 
                                            strlower_talloc(mem_ctx, 
-                                                           lp_netbios_name(lp_ctx)), 
+                                                           lpcfg_netbios_name(lp_ctx)),
                                            dns_domain);
-
-        flatname         = lp_sam_name(lp_ctx);
-        /* FIXME: Hardcoded site names */
-        server_site      = "Default-First-Site-Name";
-        client_site      = "Default-First-Site-Name";
-        load_interfaces(mem_ctx, lp_interfaces(lp_ctx), &ifaces);
-        pdc_ip           = iface_best_ip(ifaces, src_address);
-
+        NT_STATUS_HAVE_NO_MEMORY(pdc_dns_name);
+        flatname         = lpcfg_workgroup(lp_ctx);
+        server_site      = samdb_server_site_name(sam_ctx, mem_ctx);
+        NT_STATUS_HAVE_NO_MEMORY(server_site);
+        client_site      = samdb_client_site_name(sam_ctx, mem_ctx,
+                                                  src_address, NULL);
+        NT_STATUS_HAVE_NO_MEMORY(client_site);
+        load_interfaces(mem_ctx, lpcfg_interfaces(lp_ctx), &ifaces);
+        /*
+         * TODO: the caller should pass the address which the client
+         * used to trigger this call, as the client is able to reach
+         * this ip.
+         */
+        if (src_address) {
+                pdc_ip = iface_best_ip(ifaces, src_address);
+        } else {
+                pdc_ip = iface_n_ip(ifaces, 0);
+        }
         ZERO_STRUCTP(netlogon);
 
@@ -266 +316 @@
                         netlogon->data.nt5_ex.command      = LOGON_SAM_LOGON_USER_UNKNOWN_EX;
                 }
-                netlogon->data.nt5_ex.server_type  = server_type;
+                netlogon->data.nt5_ex.pdc_name     = pdc_name;
+                netlogon->data.nt5_ex.user_name    = user;
+                netlogon->data.nt5_ex.domain_name  = flatname;
                 netlogon->data.nt5_ex.domain_uuid  = domain_uuid;
-                netlogon->data.nt5_ex.forest       = realm;
+                netlogon->data.nt5_ex.forest       = forest_domain;
                 netlogon->data.nt5_ex.dns_domain   = dns_domain;
                 netlogon->data.nt5_ex.pdc_dns_name = pdc_dns_name;
-                netlogon->data.nt5_ex.domain       = flatname;
-                netlogon->data.nt5_ex.pdc_name     = lp_netbios_name(lp_ctx);
-                netlogon->data.nt5_ex.user_name    = user;
                 netlogon->data.nt5_ex.server_site  = server_site;
                 netlogon->data.nt5_ex.client_site  = client_site;
-
                 if (version & NETLOGON_NT_VERSION_5EX_WITH_IP) {
                         /* Clearly this needs to be fixed up for IPv6 */
@@ -284 +332 @@
                         netlogon->data.nt5_ex.sockaddr.remaining = data_blob_talloc_zero(mem_ctx, 8);
                 }
+                netlogon->data.nt5_ex.server_type  = server_type;
                 netlogon->data.nt5_ex.nt_version   = NETLOGON_NT_VERSION_1|NETLOGON_NT_VERSION_5EX|extra_flags;
                 netlogon->data.nt5_ex.lmnt_token   = 0xFFFF;
@@ -301 +350 @@
                 netlogon->data.nt5.domain_name  = flatname;
                 netlogon->data.nt5.domain_uuid  = domain_uuid;
-                netlogon->data.nt5.forest       = realm;
+                netlogon->data.nt5.forest       = forest_domain;
                 netlogon->data.nt5.dns_domain   = dns_domain;
                 netlogon->data.nt5.pdc_dns_name = pdc_dns_name;
@@ -318 +367 @@
                         netlogon->data.nt4.command      = LOGON_SAM_LOGON_USER_UNKNOWN;
                 }
-                netlogon->data.nt4.server      = pdc_name;
+                netlogon->data.nt4.pdc_name    = pdc_name;
                 netlogon->data.nt4.user_name   = user;
-                netlogon->data.nt4.domain      = flatname;
+                netlogon->data.nt4.domain_name = flatname;
                 netlogon->data.nt4.nt_version  = NETLOGON_NT_VERSION_1;
                 netlogon->data.nt4.lmnt_token  = 0xFFFF;
@@ -340 +389 @@
                              struct tsocket_address *src)
 {
-        int i;
+        unsigned int i;
         const char *domain = NULL;
         const char *host = NULL;
         const char *user = NULL;
         const char *domain_guid = NULL;
-        const char *domain_sid = NULL;
+        struct dom_sid *domain_sid = NULL;
         int acct_control = -1;
         int version = -1;
@@ -377 +426 @@
                 }
                 if (strcasecmp(t->u.equality.attr, "DomainSid") == 0) {
-                        domain_sid = talloc_strndup(tmp_ctx, 
-                                                    (const char *)t->u.equality.value.data,
-                                                    t->u.equality.value.length);
+                        enum ndr_err_code ndr_err;
+
+                        domain_sid = talloc(tmp_ctx, struct dom_sid);
+                        if (domain_sid == NULL) {
+                                goto failed;
+                        }
+                        ndr_err = ndr_pull_struct_blob(&t->u.equality.value,
+                                                       domain_sid, domain_sid,
+                                                       (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
+                        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                                talloc_free(domain_sid);
+                                goto failed;
+                        }
                 }
                 if (strcasecmp(t->u.equality.attr, "User") == 0) {
@@ -396 +455 @@
         }
 
-        if (domain_guid == NULL && domain == NULL) {
-                domain = lp_realm(cldapd->task->lp_ctx);
+        if ((domain == NULL) && (domain_guid == NULL) && (domain_sid == NULL)) {
+                domain = lpcfg_dnsdomain(cldapd->task->lp_ctx);
         }
 
@@ -407 +466 @@
                  domain, host, user, version, domain_guid));
 
-        status = fill_netlogon_samlogon_response(cldapd->samctx, tmp_ctx, domain, NULL, NULL, domain_guid,
+        status = fill_netlogon_samlogon_response(cldapd->samctx, tmp_ctx,
+                                                 domain, NULL, domain_sid,
+                                                 domain_guid,
                                                  user, acct_control,
                                                  tsocket_address_inet_addr_string(src, tmp_ctx),
-                                                 version, cldapd->task->lp_ctx, &netlogon);
+                                                 version, cldapd->task->lp_ctx,
+                                                 &netlogon, false);
         if (!NT_STATUS_IS_OK(status)) {
                 goto failed;
         }
 
-        status = cldap_netlogon_reply(cldap,
-                                      lp_iconv_convenience(cldapd->task->lp_ctx),
-                                      message_id, src, version,
-                                      &netlogon);
+        status = cldap_netlogon_reply(cldap, message_id, src, version, &netlogon);
         if (!NT_STATUS_IS_OK(status)) {
                 goto failed;

vendor/current/source4/cldap_server/rootdse.c

@@ -22 +22 @@
 #include "includes.h"
 #include <tevent.h>
-#include "libcli/ldap/ldap.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "smbd/service_task.h"
 #include "cldap_server/cldap_server.h"
@@ -38 +37 @@
 {
         struct ldap_SearchResEntry *ent = NULL;
-        struct ldb_dn *basedn;
         struct ldb_result *res = NULL;
         struct ldb_request *lreq;
-        enum ldb_scope scope = LDB_SCOPE_DEFAULT;
         const char **attrs = NULL;
         const char *errstr = NULL;
-        int ret = 0;
-        int ldb_ret = -1;
-
-        basedn = ldb_dn_new(mem_ctx, cldapd->samctx, NULL);
-        if (basedn == NULL) goto nomem;
-        scope = LDB_SCOPE_BASE;
+        int ret = LDAP_SUCCESS, ldb_ret;
 
         if (search->num_attributes >= 1) {
@@ -67 +59 @@
 
         ldb_ret = ldb_build_search_req_ex(&lreq, cldapd->samctx, mem_ctx,
-                                          basedn, scope,
+                                          NULL, LDB_SCOPE_BASE,
                                           search->tree, attrs,
                                           NULL,
@@ -108 +100 @@
                 }
                 ent->num_attributes = res->msgs[0]->num_elements;
-                ent->attributes = talloc_array(ent, struct ldb_message_element, ent->num_attributes);
+                ent->attributes = talloc_array(ent, struct ldb_message_element,
+                                               ent->num_attributes);
                 if (ent->attributes == NULL) goto nomem;
                 for (j=0; j < ent->num_attributes; j++) {
-                        ent->attributes[j].name = talloc_steal(ent->attributes, res->msgs[0]->elements[j].name);
+                        ent->attributes[j].name = talloc_steal(ent->attributes,
+                                                               res->msgs[0]->elements[j].name);
                         ent->attributes[j].num_values = 0;
                         ent->attributes[j].values = NULL;
@@ -124 +118 @@
 
 reply:
-        if (ret) {
+        if (ret != LDAP_SUCCESS) {
                 /* nothing ... */
         } else if (ldb_ret == LDB_SUCCESS) {
@@ -165 +159 @@
         reply.result            = &result;
 
-        cldapd_rootdse_fill(cldapd, tmp_ctx, search, &reply.response, reply.result);
+        cldapd_rootdse_fill(cldapd, tmp_ctx, search, &reply.response,
+                            reply.result);
 
         status = cldap_reply_send(cldap, &reply);