c7cd76a395af75593605f7d43f65756f2a0cc62f
[ira/wip.git] / source4 / dsdb / samdb / ldb_modules / schema_load.c
1 /* 
2    Unix SMB/CIFS mplementation.
3
4    The module that handles the Schema FSMO Role Owner
5    checkings, it also loads the dsdb_schema.
6    
7    Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
8    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
9     
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22    
23 */
24
25 #include "includes.h"
26 #include "ldb_module.h"
27 #include "dsdb/samdb/samdb.h"
28 #include "librpc/gen_ndr/ndr_misc.h"
29 #include "librpc/gen_ndr/ndr_drsuapi.h"
30 #include "librpc/gen_ndr/ndr_drsblobs.h"
31 #include "param/param.h"
32 #include "dsdb/samdb/ldb_modules/util.h"
33
34 /*
35   Given an LDB module (pointing at the schema DB), and the DN, set the populated schema
36 */
37
38 static int dsdb_schema_from_schema_dn(TALLOC_CTX *mem_ctx, struct ldb_module *module,
39                                       struct smb_iconv_convenience *iconv_convenience, 
40                                       struct ldb_dn *schema_dn,
41                                       struct dsdb_schema **schema) 
42 {
43         TALLOC_CTX *tmp_ctx;
44         char *error_string;
45         int ret;
46         struct ldb_context *ldb = ldb_module_get_ctx(module);
47         struct ldb_result *schema_res;
48         struct ldb_result *a_res;
49         struct ldb_result *c_res;
50         static const char *schema_attrs[] = {
51                 "prefixMap",
52                 "schemaInfo",
53                 "fSMORoleOwner",
54                 NULL
55         };
56         unsigned flags;
57
58         tmp_ctx = talloc_new(mem_ctx);
59         if (!tmp_ctx) {
60                 ldb_oom(ldb);
61                 return LDB_ERR_OPERATIONS_ERROR;
62         }
63
64         /* we don't want to trace the schema load */
65         flags = ldb_get_flags(ldb);
66         ldb_set_flags(ldb, flags & ~LDB_FLG_ENABLE_TRACING);
67
68         /*
69          * setup the prefix mappings and schema info
70          */
71         ret = dsdb_module_search_dn(module, tmp_ctx, &schema_res,
72                                     schema_dn, schema_attrs, 0);
73         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
74                 goto failed;
75         } else if (ret != LDB_SUCCESS) {
76                 ldb_asprintf_errstring(ldb, 
77                                        "dsdb_schema: failed to search the schema head: %s",
78                                        ldb_errstring(ldb));
79                 goto failed;
80         }
81
82         /*
83          * load the attribute definitions
84          */
85         ret = dsdb_module_search(module, tmp_ctx, &a_res,
86                                  schema_dn, LDB_SCOPE_ONELEVEL, NULL,
87                                  0, 
88                                  "(objectClass=attributeSchema)");
89         if (ret != LDB_SUCCESS) {
90                 ldb_asprintf_errstring(ldb, 
91                                        "dsdb_schema: failed to search attributeSchema objects: %s",
92                                        ldb_errstring(ldb));
93                 goto failed;
94         }
95
96         /*
97          * load the objectClass definitions
98          */
99         ret = dsdb_module_search(module, tmp_ctx, &c_res,
100                                  schema_dn, LDB_SCOPE_ONELEVEL, NULL,
101                                  DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
102                                  "(objectClass=classSchema)");
103         if (ret != LDB_SUCCESS) {
104                 ldb_asprintf_errstring(ldb, 
105                                        "dsdb_schema: failed to search attributeSchema objects: %s",
106                                        ldb_errstring(ldb));
107                 goto failed;
108         }
109
110         ret = dsdb_schema_from_ldb_results(tmp_ctx, ldb,
111                                            lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
112                                            schema_res, a_res, c_res, schema, &error_string);
113         if (ret != LDB_SUCCESS) {
114                 ldb_asprintf_errstring(ldb, 
115                                                     "dsdb_schema load failed: %s",
116                                                     error_string);
117                 goto failed;
118         }
119         talloc_steal(mem_ctx, *schema);
120
121 failed:
122         if (flags & LDB_FLG_ENABLE_TRACING) {
123                 flags = ldb_get_flags(ldb);
124                 ldb_set_flags(ldb, flags | LDB_FLG_ENABLE_TRACING);
125         }
126         talloc_free(tmp_ctx);
127         return ret;
128 }       
129
130
131 static int schema_load_init(struct ldb_module *module)
132 {
133         struct ldb_context *ldb;
134         TALLOC_CTX *mem_ctx;
135         struct ldb_dn *schema_dn;
136         struct dsdb_schema *schema;
137         int ret;
138
139         ret = ldb_next_init(module);
140         if (ret != LDB_SUCCESS) {
141                 return ret;
142         }
143
144         ldb = ldb_module_get_ctx(module);
145         schema_dn = samdb_schema_dn(ldb);
146         if (!schema_dn) {
147                 ldb_reset_err_string(ldb);
148                 ldb_debug(ldb, LDB_DEBUG_WARNING,
149                           "schema_load_init: no schema dn present: (skip schema loading)\n");
150                 return LDB_SUCCESS;
151         }
152
153         if (dsdb_get_schema(ldb)) {
154                 return LDB_SUCCESS;
155         }
156
157         mem_ctx = talloc_new(module);
158         if (!mem_ctx) {
159                 ldb_oom(ldb);
160                 return LDB_ERR_OPERATIONS_ERROR;
161         }
162
163         ret = dsdb_schema_from_schema_dn(mem_ctx, module,
164                                          lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
165                                          schema_dn, &schema);
166
167         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
168                 ldb_reset_err_string(ldb);
169                 ldb_debug(ldb, LDB_DEBUG_WARNING,
170                           "schema_load_init: no schema head present: (skip schema loading)\n");
171                 talloc_free(mem_ctx);
172                 return LDB_SUCCESS;
173         }
174
175         if (ret != LDB_SUCCESS) {
176                 talloc_free(mem_ctx);
177                 return ret;
178         }
179
180         /* dsdb_set_schema() steal schema into the ldb_context */
181         ret = dsdb_set_schema(ldb, schema);
182         if (ret != LDB_SUCCESS) {
183                 ldb_debug_set(ldb, LDB_DEBUG_FATAL,
184                               "schema_load_init: dsdb_set_schema() failed: %d:%s",
185                               ret, ldb_strerror(ret));
186                 talloc_free(mem_ctx);
187                 return ret;
188         }
189
190         talloc_free(mem_ctx);
191         return LDB_SUCCESS;
192 }
193
194 static int schema_load_extended(struct ldb_module *module, struct ldb_request *req)
195 {
196         struct ldb_context *ldb;
197         struct ldb_dn *schema_dn;
198         struct dsdb_schema *schema;
199         int ret;
200         TALLOC_CTX *mem_ctx;
201
202         ldb = ldb_module_get_ctx(module);
203
204         if (strcmp(req->op.extended.oid, DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID) != 0) {
205                 return ldb_next_request(module, req);
206         }
207         
208         schema_dn = samdb_schema_dn(ldb);
209         if (!schema_dn) {
210                 ldb_reset_err_string(ldb);
211                 ldb_debug(ldb, LDB_DEBUG_WARNING,
212                           "schema_load_extended: no schema dn present: (skip schema loading)\n");
213                 return ldb_next_request(module, req);
214         }
215         
216         mem_ctx = talloc_new(module);
217         if (!mem_ctx) {
218                 ldb_oom(ldb);
219                 return LDB_ERR_OPERATIONS_ERROR;
220         }
221         
222         ret = dsdb_schema_from_schema_dn(mem_ctx, module,
223                                          lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
224                                          schema_dn, &schema);
225
226         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
227                 ldb_reset_err_string(ldb);
228                 ldb_debug(ldb, LDB_DEBUG_WARNING,
229                           "schema_load_extended: no schema head present: (skip schema loading)\n");
230                 talloc_free(mem_ctx);
231                 return ldb_next_request(module, req);
232         }
233
234         if (ret != LDB_SUCCESS) {
235                 talloc_free(mem_ctx);
236                 return ldb_next_request(module, req);
237         }
238
239         /* Replace the old schema*/
240         ret = dsdb_set_schema(ldb, schema);
241         if (ret != LDB_SUCCESS) {
242                 ldb_debug_set(ldb, LDB_DEBUG_FATAL,
243                               "schema_load_extended: dsdb_set_schema() failed: %d:%s",
244                               ret, ldb_strerror(ret));
245                 talloc_free(mem_ctx);
246                 return ret;
247         }
248
249         dsdb_make_schema_global(ldb);
250
251         talloc_free(mem_ctx);
252         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
253 }
254
255
256 _PUBLIC_ const struct ldb_module_ops ldb_schema_load_module_ops = {
257         .name           = "schema_load",
258         .init_context   = schema_load_init,
259         .extended       = schema_load_extended,
260 };