source4/dsdb/samdb/ldb_modules/normalise.c

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Amdrew Bartlett <abartlet@samba.org> 2007-2008
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 /*
  21  *  Name: ldb
  22  *
  23  *  Component: ldb normalisation module
  24  *
  25  *  Description: module to ensure all DNs and attribute names are normalised
  26  *
  27  *  Author: Andrew Bartlett
  28  */
  29
  30 #include "includes.h"
  31 #include "ldb/include/ldb.h"
  32 #include "ldb/include/ldb_errors.h"
  33 #include "ldb/include/ldb_private.h"
  34 #include "dsdb/samdb/samdb.h"
  35
  36 /* Fix up the DN to be in the standard form, taking particular care to match the parent DN
  37
  38    This should mean that if the parent is:
  39     CN=Users,DC=samba,DC=example,DC=com
  40    and a proposed child is
  41     cn=Admins ,cn=USERS,dc=Samba,dc=example,dc=COM
  42
  43    The resulting DN should be:
  44
  45     CN=Admins,CN=Users,DC=samba,DC=example,DC=com
  46
  47  */
  48
  49 struct norm_context {
  50         struct ldb_module *module;
  51         struct ldb_request *req;
  52
  53         const struct dsdb_schema *schema;
  54 };
  55
  56 static int fix_dn(struct ldb_dn *dn)
  57 {
  58         int i, ret;
  59         char *upper_rdn_attr;
  60
  61         for (i=0; i < ldb_dn_get_comp_num(dn); i++) {
  62                 /* We need the attribute name in upper case */
  63                 upper_rdn_attr = strupper_talloc(dn,
  64                                                  ldb_dn_get_component_name(dn, i));
  65                 if (!upper_rdn_attr) {
  66                         return LDB_ERR_OPERATIONS_ERROR;
  67                 }
  68
  69                 /* And replace it with CN=foo (we need the attribute in upper case */
  70                 ret = ldb_dn_set_component(dn, i, upper_rdn_attr,
  71                                            *ldb_dn_get_component_val(dn, i));
  72                 talloc_free(upper_rdn_attr);
  73                 if (ret != LDB_SUCCESS) {
  74                         return ret;
  75                 }
  76         }
  77         return LDB_SUCCESS;
  78 }
  79
  80 static int normalize_search_callback(struct ldb_request *req, struct ldb_reply *ares)
  81 {
  82         struct ldb_message *msg;
  83         struct norm_context *ac;
  84         int i, j, ret;
  85
  86         ac = talloc_get_type(req->context, struct norm_context);
  87
  88         if (!ares) {
  89                 return ldb_module_done(ac->req, NULL, NULL,
  90                                         LDB_ERR_OPERATIONS_ERROR);
  91         }
  92         if (ares->error != LDB_SUCCESS) {
  93                 return ldb_module_done(ac->req, ares->controls,
  94                                         ares->response, ares->error);
  95         }
  96
  97         /* Only entries are interesting, and we handle the case of the parent seperatly */
  98
  99         switch (ares->type) {
 100         case LDB_REPLY_ENTRY:
 101
 102                 /* OK, we have one of *many* search results passing by here,
 103                  * but we should get them one at a time */
 104                 msg = ares->message;
 105
 106                 ret = fix_dn(msg->dn);
 107                 if (ret != LDB_SUCCESS) {
 108                         return ldb_module_done(ac->req, NULL, NULL, ret);
 109                 }
 110
 111                 for (i = 0; i < msg->num_elements; i++) {
 112                         const struct dsdb_attribute *attribute = dsdb_attribute_by_lDAPDisplayName(ac->schema, msg->elements[i].name);
 113                         if (!attribute) {
 114                                 continue;
 115                         }
 116                         /* Look to see if this attributeSyntax is a DN */
 117                         if (strcmp(attribute->attributeSyntax_oid, "2.5.5.1") == 0) {
 118                                 continue;
 119                         }
 120                         for (j = 0; j < msg->elements[i].num_values; j++) {
 121                                 const char *dn_str;
 122                                 struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, ac->module->ldb, &msg->elements[i].values[j]);
 123                                 if (!dn) {
 124                                         return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
 125                                 }
 126                                 ret = fix_dn(dn);
 127                                 if (ret != LDB_SUCCESS) {
 128                                         return ldb_module_done(ac->req, NULL, NULL, ret);
 129                                 }
 130                                 dn_str = talloc_steal(msg->elements[i].values, ldb_dn_get_linearized(dn));
 131                                 msg->elements[i].values[j] = data_blob_string_const(dn_str);
 132                                 talloc_free(dn);
 133                         }
 134                 }
 135
 136                 return ldb_module_send_entry(ac->req, msg);
 137
 138         case LDB_REPLY_REFERRAL:
 139
 140                 return ldb_module_send_referral(ac->req, ares->referral);
 141
 142         case LDB_REPLY_DONE:
 143
 144                 return ldb_module_done(ac->req, ares->controls,
 145                                         ares->response, ares->error);
 146         }
 147
 148         return LDB_SUCCESS;
 149 }
 150
 151 /* search */
 152 static int normalise_search(struct ldb_module *module, struct ldb_request *req)
 153 {
 154         struct ldb_request *down_req;
 155         struct norm_context *ac;
 156         int ret;
 157
 158         ac = talloc(req, struct norm_context);
 159         if (ac == NULL) {
 160                 return LDB_ERR_OPERATIONS_ERROR;
 161         }
 162
 163         ac->module = module;
 164         ac->req = req;
 165
 166         /* if schema not yet present just skip over */
 167         ac->schema = dsdb_get_schema(ac->module->ldb);
 168         if (ac->schema == NULL) {
 169                 talloc_free(ac);
 170                 return ldb_next_request(module, req);
 171         }
 172
 173         ret = ldb_build_search_req_ex(&down_req, module->ldb, ac,
 174                                         req->op.search.base,
 175                                         req->op.search.scope,
 176                                         req->op.search.tree,
 177                                         req->op.search.attrs,
 178                                         req->controls,
 179                                         ac, normalize_search_callback,
 180                                         req);
 181         if (ret != LDB_SUCCESS) {
 182                 return LDB_ERR_OPERATIONS_ERROR;
 183         }
 184
 185         return ldb_next_request(module, down_req);
 186 }
 187
 188
 189
 190 _PUBLIC_ const struct ldb_module_ops ldb_normalise_module_ops = {
 191         .name              = "normalise",
 192         .search            = normalise_search,
 193 };