Merge branch 'master' of ssh://git.samba.org/data/git/samba into extended-dn
[abartlet/samba.git/.git] / 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 };