Split schema_init.c into smaller bits.
[kai/samba.git] / source4 / dsdb / schema / schema_set.c
1 /* 
2    Unix SMB/CIFS mplementation.
3    DSDB schema header
4    
5    Copyright (C) Stefan Metzmacher <metze@samba.org> 2006-2007
6    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2008
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 "dsdb/samdb/samdb.h"
25 #include "lib/ldb/include/ldb_errors.h"
26 #include "lib/util/dlinklist.h"
27 #include "param/param.h"
28
29 /**
30  * Attach the schema to an opaque pointer on the ldb, so ldb modules
31  * can find it 
32  */
33
34 int dsdb_set_schema(struct ldb_context *ldb, struct dsdb_schema *schema)
35 {
36         int ret;
37
38         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
39         if (ret != LDB_SUCCESS) {
40                 return ret;
41         }
42
43         talloc_steal(ldb, schema);
44
45         return LDB_SUCCESS;
46 }
47
48 /**
49  * Global variable to hold one copy of the schema, used to avoid memory bloat
50  */
51 static struct dsdb_schema *global_schema;
52
53 /**
54  * Make this ldb use the 'global' schema, setup to avoid having multiple copies in this process
55  */
56 int dsdb_set_global_schema(struct ldb_context *ldb)
57 {
58         int ret;
59         if (!global_schema) {
60                 return LDB_SUCCESS;
61         }
62         ret = ldb_set_opaque(ldb, "dsdb_schema", global_schema);
63         if (ret != LDB_SUCCESS) {
64                 return ret;
65         }
66
67         /* Keep a reference to this schema, just incase the global copy is replaced */
68         if (talloc_reference(ldb, global_schema) == NULL) {
69                 return LDB_ERR_OPERATIONS_ERROR;
70         }
71
72         return LDB_SUCCESS;
73 }
74
75 /**
76  * Find the schema object for this ldb
77  */
78
79 struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb)
80 {
81         const void *p;
82         struct dsdb_schema *schema;
83
84         /* see if we have a cached copy */
85         p = ldb_get_opaque(ldb, "dsdb_schema");
86         if (!p) {
87                 return NULL;
88         }
89
90         schema = talloc_get_type(p, struct dsdb_schema);
91         if (!schema) {
92                 return NULL;
93         }
94
95         return schema;
96 }
97
98 /**
99  * Make the schema found on this ldb the 'global' schema
100  */
101
102 void dsdb_make_schema_global(struct ldb_context *ldb)
103 {
104         struct dsdb_schema *schema = dsdb_get_schema(ldb);
105         if (!schema) {
106                 return;
107         }
108
109         if (global_schema) {
110                 talloc_unlink(talloc_autofree_context(), schema);
111         }
112
113         talloc_steal(talloc_autofree_context(), schema);
114         global_schema = schema;
115
116         dsdb_set_global_schema(ldb);
117 }
118
119
120 /**
121  * Rather than read a schema from the LDB itself, read it from an ldif
122  * file.  This allows schema to be loaded and used while adding the
123  * schema itself to the directory.
124  */
125
126 WERROR dsdb_attach_schema_from_ldif_file(struct ldb_context *ldb, const char *pf, const char *df)
127 {
128         struct ldb_ldif *ldif;
129         struct ldb_message *msg;
130         TALLOC_CTX *mem_ctx;
131         WERROR status;
132         int ret;
133         struct dsdb_schema *schema;
134         const struct ldb_val *prefix_val;
135         const struct ldb_val *info_val;
136         struct ldb_val info_val_default;
137
138         mem_ctx = talloc_new(ldb);
139         if (!mem_ctx) {
140                 goto nomem;
141         }
142
143         schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")));
144
145         schema->fsmo.we_are_master = true;
146         schema->fsmo.master_dn = ldb_dn_new_fmt(schema, ldb, "@PROVISION_SCHEMA_MASTER");
147         if (!schema->fsmo.master_dn) {
148                 goto nomem;
149         }
150
151         /*
152          * load the prefixMap attribute from pf
153          */
154         ldif = ldb_ldif_read_string(ldb, &pf);
155         if (!ldif) {
156                 status = WERR_INVALID_PARAM;
157                 goto failed;
158         }
159         talloc_steal(mem_ctx, ldif);
160
161         msg = ldb_msg_canonicalize(ldb, ldif->msg);
162         if (!msg) {
163                 goto nomem;
164         }
165         talloc_steal(mem_ctx, msg);
166         talloc_free(ldif);
167
168         prefix_val = ldb_msg_find_ldb_val(msg, "prefixMap");
169         if (!prefix_val) {
170                 status = WERR_INVALID_PARAM;
171                 goto failed;
172         }
173
174         info_val = ldb_msg_find_ldb_val(msg, "schemaInfo");
175         if (!info_val) {
176                 info_val_default = strhex_to_data_blob("FF0000000000000000000000000000000000000000");
177                 if (!info_val_default.data) {
178                         goto nomem;
179                 }
180                 talloc_steal(mem_ctx, info_val_default.data);
181                 info_val = &info_val_default;
182         }
183
184         status = dsdb_load_oid_mappings_ldb(schema, prefix_val, info_val);
185         if (!W_ERROR_IS_OK(status)) {
186                 goto failed;
187         }
188
189         /*
190          * load the attribute and class definitions outof df
191          */
192         while ((ldif = ldb_ldif_read_string(ldb, &df))) {
193                 bool is_sa;
194                 bool is_sc;
195
196                 talloc_steal(mem_ctx, ldif);
197
198                 msg = ldb_msg_canonicalize(ldb, ldif->msg);
199                 if (!msg) {
200                         goto nomem;
201                 }
202
203                 talloc_steal(mem_ctx, msg);
204                 talloc_free(ldif);
205
206                 is_sa = ldb_msg_check_string_attribute(msg, "objectClass", "attributeSchema");
207                 is_sc = ldb_msg_check_string_attribute(msg, "objectClass", "classSchema");
208
209                 if (is_sa) {
210                         struct dsdb_attribute *sa;
211
212                         sa = talloc_zero(schema, struct dsdb_attribute);
213                         if (!sa) {
214                                 goto nomem;
215                         }
216
217                         status = dsdb_attribute_from_ldb(schema, msg, sa, sa);
218                         if (!W_ERROR_IS_OK(status)) {
219                                 goto failed;
220                         }
221
222                         DLIST_ADD_END(schema->attributes, sa, struct dsdb_attribute *);
223                 } else if (is_sc) {
224                         struct dsdb_class *sc;
225
226                         sc = talloc_zero(schema, struct dsdb_class);
227                         if (!sc) {
228                                 goto nomem;
229                         }
230
231                         status = dsdb_class_from_ldb(schema, msg, sc, sc);
232                         if (!W_ERROR_IS_OK(status)) {
233                                 goto failed;
234                         }
235
236                         DLIST_ADD_END(schema->classes, sc, struct dsdb_class *);
237                 }
238         }
239
240         ret = dsdb_set_schema(ldb, schema);
241         if (ret != LDB_SUCCESS) {
242                 status = WERR_FOOBAR;
243                 goto failed;
244         }
245
246         goto done;
247
248 nomem:
249         status = WERR_NOMEM;
250 failed:
251 done:
252         talloc_free(mem_ctx);
253         return status;
254 }