Branch data Line data Source code
1 : : /*
2 : : SSSD
3 : :
4 : : Authors:
5 : : Simo Sorce <ssorce@redhat.com>
6 : : Stephen Gallagher <sgallagh@redhat.com>
7 : :
8 : : Copyright (C) 2008-2011 Simo Sorce <ssorce@redhat.com>
9 : : Copyright (C) 2008-2011 Stephen Gallagher
10 : :
11 : : This program is free software; you can redistribute it and/or modify
12 : : it under the terms of the GNU General Public License as published by
13 : : the Free Software Foundation; either version 3 of the License, or
14 : : (at your option) any later version.
15 : :
16 : : This program is distributed in the hope that it will be useful,
17 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : GNU General Public License for more details.
20 : :
21 : : You should have received a copy of the GNU General Public License
22 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
23 : : */
24 : :
25 : : #include "util/util.h"
26 : : #include "db/sysdb_private.h"
27 : : #include "db/sysdb_autofs.h"
28 : :
29 : : struct upgrade_ctx {
30 : : struct ldb_context *ldb;
31 : : const char *new_version;
32 : : };
33 : :
34 : 0 : static errno_t commence_upgrade(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
35 : : const char *new_ver, struct upgrade_ctx **_ctx)
36 : : {
37 : : struct upgrade_ctx *ctx;
38 : : int ret;
39 : :
40 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_CRIT_FAILURE, ("UPGRADING DB TO VERSION %s\n", new_ver));
[ # # ][ # # ]
[ # # ]
41 : :
42 : 0 : ctx = talloc(mem_ctx, struct upgrade_ctx);
43 [ # # ]: 0 : if (!ctx) {
44 : : return ENOMEM;
45 : : }
46 : :
47 : 0 : ctx->ldb = ldb;
48 : 0 : ctx->new_version = new_ver;
49 : :
50 : 0 : ret = ldb_transaction_start(ldb);
51 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
52 : : ret = EIO;
53 : : goto done;
54 : : }
55 : :
56 : 0 : ret = EOK;
57 : :
58 : : done:
59 [ # # ]: 0 : if (ret != EOK) {
60 : 0 : talloc_free(ctx);
61 : : } else {
62 : 0 : *_ctx = ctx;
63 : : }
64 : 0 : return ret;
65 : : }
66 : :
67 : 0 : static errno_t update_version(struct upgrade_ctx *ctx)
68 : : {
69 : 0 : struct ldb_message *msg = NULL;
70 : : errno_t ret;
71 : :
72 : 0 : msg = ldb_msg_new(ctx);
73 [ # # ]: 0 : if (!msg) {
74 : : ret = ENOMEM;
75 : : goto done;
76 : : }
77 : 0 : msg->dn = ldb_dn_new(msg, ctx->ldb, SYSDB_BASE);
78 [ # # ]: 0 : if (!msg->dn) {
79 : : ret = ENOMEM;
80 : : goto done;
81 : : }
82 : :
83 : 0 : ret = ldb_msg_add_empty(msg, "version", LDB_FLAG_MOD_REPLACE, NULL);
84 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
85 : : ret = ENOMEM;
86 : : goto done;
87 : : }
88 : :
89 : 0 : ret = ldb_msg_add_string(msg, "version", ctx->new_version);
90 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
91 : : ret = ENOMEM;
92 : : goto done;
93 : : }
94 : :
95 : 0 : ret = ldb_modify(ctx->ldb, msg);
96 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
97 : 0 : ret = sysdb_error_to_errno(ret);
98 : 0 : goto done;
99 : : }
100 : :
101 : : ret = EOK;
102 : :
103 : : done:
104 : 0 : talloc_free(msg);
105 : 0 : return ret;
106 : : }
107 : :
108 : 0 : static int finish_upgrade(int ret, struct upgrade_ctx **ctx, const char **ver)
109 : : {
110 : : int lret;
111 : :
112 [ # # ]: 0 : if (ret == EOK) {
113 : 0 : lret = ldb_transaction_commit((*ctx)->ldb);
114 : 0 : ret = sysdb_error_to_errno(lret);
115 [ # # ]: 0 : if (ret == EOK) {
116 : 0 : *ver = (*ctx)->new_version;
117 : : }
118 : : }
119 : :
120 [ # # ]: 0 : if (ret != EOK) {
121 : 0 : lret = ldb_transaction_cancel((*ctx)->ldb);
122 [ # # ]: 0 : if (lret != LDB_SUCCESS) {
123 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_CRIT_FAILURE,
[ # # ][ # # ]
[ # # ]
124 : : ("Could not cancel transaction! [%s]\n",
125 : : ldb_strerror(lret)));
126 : : /* Do not overwrite ret here, we want to return
127 : : * the original failure, not the failure of the
128 : : * transaction cancellation.
129 : : */
130 : : }
131 : : }
132 : :
133 : 0 : talloc_zfree(*ctx);
134 : 0 : return ret;
135 : : }
136 : :
137 : : /* serach all groups that have a memberUid attribute.
138 : : * change it into a member attribute for a user of same domain.
139 : : * remove the memberUid attribute
140 : : * add the new member attribute
141 : : * finally stop indexing memberUid
142 : : * upgrade version to 0.2
143 : : */
144 : 0 : int sysdb_upgrade_01(struct ldb_context *ldb, const char **ver)
145 : : {
146 : : struct ldb_message_element *el;
147 : : struct ldb_result *res;
148 : : struct ldb_dn *basedn;
149 : : struct ldb_dn *mem_dn;
150 : : struct ldb_message *msg;
151 : : const struct ldb_val *val;
152 : 0 : const char *filter = "(&(memberUid=*)(objectclass=group))";
153 : 0 : const char *attrs[] = { "memberUid", NULL };
154 : : const char *mdn;
155 : : char *domain;
156 : : int ret, i, j;
157 : : TALLOC_CTX *tmp_ctx;
158 : : struct upgrade_ctx *ctx;
159 : :
160 : 0 : tmp_ctx = talloc_new(NULL);
161 [ # # ]: 0 : if (!tmp_ctx) {
162 : : return ENOMEM;
163 : : }
164 : :
165 : 0 : ret = commence_upgrade(tmp_ctx, ldb, SYSDB_VERSION_0_2, &ctx);
166 [ # # ]: 0 : if (ret) {
167 : 0 : talloc_free(tmp_ctx);
168 : : return ret;
169 : : }
170 : :
171 : 0 : basedn = ldb_dn_new(tmp_ctx, ldb, SYSDB_BASE);
172 [ # # ]: 0 : if (!basedn) {
173 : : ret = EIO;
174 : : goto done;
175 : : }
176 : :
177 : 0 : ret = ldb_search(ldb, tmp_ctx, &res,
178 : : basedn, LDB_SCOPE_SUBTREE,
179 : : attrs, "%s", filter);
180 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
181 : : ret = EIO;
182 : : goto done;
183 : : }
184 : :
185 [ # # ]: 0 : for (i = 0; i < res->count; i++) {
186 : 0 : el = ldb_msg_find_element(res->msgs[i], "memberUid");
187 [ # # ]: 0 : if (!el) {
188 [ # # ][ # # ]: 0 : DEBUG(1, ("memberUid is missing from message [%s], skipping\n",
[ # # ][ # # ]
[ # # ]
189 : : ldb_dn_get_linearized(res->msgs[i]->dn)));
190 : 0 : continue;
191 : : }
192 : :
193 : : /* create modification message */
194 : 0 : msg = ldb_msg_new(tmp_ctx);
195 [ # # ]: 0 : if (!msg) {
196 : : ret = ENOMEM;
197 : : goto done;
198 : : }
199 : 0 : msg->dn = res->msgs[i]->dn;
200 : :
201 : 0 : ret = ldb_msg_add_empty(msg, "memberUid", LDB_FLAG_MOD_DELETE, NULL);
202 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
203 : : ret = ENOMEM;
204 : : goto done;
205 : : }
206 : :
207 : 0 : ret = ldb_msg_add_empty(msg, SYSDB_MEMBER, LDB_FLAG_MOD_ADD, NULL);
208 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
209 : : ret = ENOMEM;
210 : : goto done;
211 : : }
212 : :
213 : : /* get domain name component value */
214 : 0 : val = ldb_dn_get_component_val(res->msgs[i]->dn, 2);
215 : 0 : domain = talloc_strndup(tmp_ctx, (const char *)val->data, val->length);
216 [ # # ]: 0 : if (!domain) {
217 : : ret = ENOMEM;
218 : : goto done;
219 : : }
220 : :
221 [ # # ]: 0 : for (j = 0; j < el->num_values; j++) {
222 : 0 : mem_dn = ldb_dn_new_fmt(tmp_ctx, ldb, SYSDB_TMPL_USER,
223 : 0 : (const char *)el->values[j].data, domain);
224 [ # # ]: 0 : if (!mem_dn) {
225 : : ret = ENOMEM;
226 : : goto done;
227 : : }
228 : :
229 : 0 : mdn = talloc_strdup(msg, ldb_dn_get_linearized(mem_dn));
230 [ # # ]: 0 : if (!mdn) {
231 : : ret = ENOMEM;
232 : : goto done;
233 : : }
234 : 0 : ret = ldb_msg_add_string(msg, SYSDB_MEMBER, mdn);
235 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
236 : : ret = ENOMEM;
237 : : goto done;
238 : : }
239 : :
240 : 0 : talloc_zfree(mem_dn);
241 : : }
242 : :
243 : : /* ok now we are ready to modify the entry */
244 : 0 : ret = ldb_modify(ldb, msg);
245 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
246 : 0 : ret = sysdb_error_to_errno(ret);
247 : : goto done;
248 : : }
249 : :
250 : 0 : talloc_zfree(msg);
251 : : }
252 : :
253 : : /* conversion done, update version number */
254 : 0 : ret = update_version(ctx);
255 : :
256 : : done:
257 : 0 : ret = finish_upgrade(ret, &ctx, ver);
258 : 0 : talloc_free(tmp_ctx);
259 : : return ret;
260 : : }
261 : :
262 : 0 : int sysdb_check_upgrade_02(struct sss_domain_info *domains,
263 : : const char *db_path)
264 : : {
265 : 0 : TALLOC_CTX *tmp_ctx = NULL;
266 : : struct ldb_context *ldb;
267 : : char *ldb_file;
268 : : struct sysdb_ctx *sysdb;
269 : : struct sss_domain_info *dom;
270 : : struct ldb_message_element *el;
271 : : struct ldb_message *msg;
272 : : struct ldb_result *res;
273 : : struct ldb_dn *verdn;
274 : 0 : const char *version = NULL;
275 : 0 : bool do_02_upgrade = false;
276 : 0 : bool ctx_trans = false;
277 : : int ret;
278 : :
279 : 0 : tmp_ctx = talloc_new(NULL);
280 [ # # ]: 0 : if (!tmp_ctx) {
281 : : return ENOMEM;
282 : : }
283 : :
284 : 0 : ret = sysdb_get_db_file(tmp_ctx,
285 : : "local", "UPGRADE",
286 : : db_path, &ldb_file);
287 [ # # ]: 0 : if (ret != EOK) {
288 : : goto exit;
289 : : }
290 : :
291 : 0 : ret = sysdb_ldb_connect(tmp_ctx, ldb_file, &ldb);
292 [ # # ]: 0 : if (ret != EOK) {
293 [ # # ][ # # ]: 0 : DEBUG(1, ("sysdb_ldb_connect failed.\n"));
[ # # ][ # # ]
[ # # ]
294 : : return ret;
295 : : }
296 : :
297 : 0 : verdn = ldb_dn_new(tmp_ctx, ldb, SYSDB_BASE);
298 [ # # ]: 0 : if (!verdn) {
299 : : ret = EIO;
300 : : goto exit;
301 : : }
302 : :
303 : 0 : ret = ldb_search(ldb, tmp_ctx, &res,
304 : : verdn, LDB_SCOPE_BASE,
305 : : NULL, NULL);
306 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
307 : : ret = EIO;
308 : : goto exit;
309 : : }
310 [ # # ]: 0 : if (res->count > 1) {
311 : : ret = EIO;
312 : : goto exit;
313 : : }
314 : :
315 [ # # ]: 0 : if (res->count == 1) {
316 : 0 : el = ldb_msg_find_element(res->msgs[0], "version");
317 [ # # ]: 0 : if (el) {
318 [ # # ]: 0 : if (el->num_values != 1) {
319 : : ret = EINVAL;
320 : : goto exit;
321 : : }
322 : 0 : version = talloc_strndup(tmp_ctx,
323 : 0 : (char *)(el->values[0].data),
324 : 0 : el->values[0].length);
325 [ # # ]: 0 : if (!version) {
326 : : ret = ENOMEM;
327 : : goto exit;
328 : : }
329 : :
330 [ # # ]: 0 : if (strcmp(version, SYSDB_VERSION) == 0) {
331 : : /* all fine, return */
332 : : ret = EOK;
333 : : goto exit;
334 : : }
335 : :
336 [ # # ][ # # ]: 0 : DEBUG(4, ("Upgrading DB from version: %s\n", version));
[ # # ][ # # ]
[ # # ]
337 : :
338 [ # # ][ # # ]: 0 : if (strcmp(version, SYSDB_VERSION_0_1) == 0) {
[ # # ][ # # ]
339 : : /* convert database */
340 : 0 : ret = sysdb_upgrade_01(ldb, &version);
341 [ # # ]: 0 : if (ret != EOK) goto exit;
342 : : }
343 : :
344 [ # # ][ # # ]: 0 : if (strcmp(version, SYSDB_VERSION_0_2) == 0) {
[ # # ][ # # ]
345 : : /* need to convert database to split files */
346 : 0 : do_02_upgrade = true;
347 : : }
348 : :
349 : : }
350 : : }
351 : :
352 [ # # ]: 0 : if (!do_02_upgrade) {
353 : : /* not a v2 upgrade, return and let the normal code take over any
354 : : * further upgrade */
355 : : ret = EOK;
356 : : goto exit;
357 : : }
358 : :
359 : : /* == V2->V3 UPGRADE == */
360 : :
361 [ # # ][ # # ]: 0 : DEBUG(0, ("UPGRADING DB TO VERSION %s\n", SYSDB_VERSION_0_3));
[ # # ][ # # ]
[ # # ]
362 : :
363 : : /* ldb uses posix locks,
364 : : * posix is stupid and kills all locks when you close *any* file
365 : : * descriptor associated to the same file.
366 : : * Therefore we must close and reopen the ldb file here */
367 : :
368 : : /* == Backup and reopen ldb == */
369 : :
370 : : /* close */
371 : 0 : talloc_zfree(ldb);
372 : :
373 : : /* backup*/
374 : 0 : ret = backup_file(ldb_file, 0);
375 [ # # ]: 0 : if (ret != EOK) {
376 : : goto exit;
377 : : }
378 : :
379 : : /* reopen */
380 : 0 : ret = sysdb_ldb_connect(tmp_ctx, ldb_file, &ldb);
381 [ # # ]: 0 : if (ret != EOK) {
382 [ # # ][ # # ]: 0 : DEBUG(1, ("sysdb_ldb_connect failed.\n"));
[ # # ][ # # ]
[ # # ]
383 : : return ret;
384 : : }
385 : :
386 : : /* open a transaction */
387 : 0 : ret = ldb_transaction_start(ldb);
388 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
389 [ # # ][ # # ]: 0 : DEBUG(1, ("Failed to start ldb transaction! (%d)\n", ret));
[ # # ][ # # ]
[ # # ]
390 : : ret = EIO;
391 : : goto exit;
392 : : }
393 : :
394 : : /* == Upgrade contents == */
395 : :
396 [ # # ]: 0 : for (dom = domains; dom; dom = dom->next) {
397 : : struct ldb_dn *domain_dn;
398 : : struct ldb_dn *users_dn;
399 : : struct ldb_dn *groups_dn;
400 : : int i;
401 : :
402 : : /* skip local */
403 [ # # ]: 0 : if (strcasecmp(dom->provider, "local") == 0) {
404 : 0 : continue;
405 : : }
406 : :
407 : : /* create new dom db */
408 : 0 : ret = sysdb_domain_init_internal(tmp_ctx, dom,
409 : : db_path, false, &sysdb);
410 [ # # ]: 0 : if (ret != EOK) {
411 : : goto done;
412 : : }
413 : :
414 : 0 : ret = ldb_transaction_start(sysdb->ldb);
415 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
416 [ # # ][ # # ]: 0 : DEBUG(1, ("Failed to start ldb transaction! (%d)\n", ret));
[ # # ][ # # ]
[ # # ]
417 : : ret = EIO;
418 : : goto done;
419 : : }
420 : 0 : ctx_trans = true;
421 : :
422 : : /* search all entries for this domain in local,
423 : : * copy them all in the new database,
424 : : * then remove them from local */
425 : :
426 : 0 : domain_dn = ldb_dn_new_fmt(tmp_ctx, sysdb->ldb,
427 : 0 : SYSDB_DOM_BASE, sysdb->domain->name);
428 [ # # ]: 0 : if (!domain_dn) {
429 : : ret = ENOMEM;
430 : : goto done;
431 : : }
432 : :
433 : 0 : ret = ldb_search(ldb, tmp_ctx, &res,
434 : : domain_dn, LDB_SCOPE_SUBTREE,
435 : : NULL, NULL);
436 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
437 : : ret = EIO;
438 : : goto done;
439 : : }
440 : :
441 : 0 : users_dn = ldb_dn_new_fmt(tmp_ctx, sysdb->ldb,
442 : 0 : SYSDB_TMPL_USER_BASE, sysdb->domain->name);
443 [ # # ]: 0 : if (!users_dn) {
444 : : ret = ENOMEM;
445 : : goto done;
446 : : }
447 : 0 : groups_dn = ldb_dn_new_fmt(tmp_ctx, sysdb->ldb,
448 : 0 : SYSDB_TMPL_GROUP_BASE, sysdb->domain->name);
449 [ # # ]: 0 : if (!groups_dn) {
450 : : ret = ENOMEM;
451 : : goto done;
452 : : }
453 : :
454 [ # # ]: 0 : for (i = 0; i < res->count; i++) {
455 : :
456 : : struct ldb_dn *orig_dn;
457 : :
458 : 0 : msg = res->msgs[i];
459 : :
460 : : /* skip pre-created congtainers */
461 [ # # # # ]: 0 : if ((ldb_dn_compare(msg->dn, domain_dn) == 0) ||
462 [ # # ]: 0 : (ldb_dn_compare(msg->dn, users_dn) == 0) ||
463 : 0 : (ldb_dn_compare(msg->dn, groups_dn) == 0)) {
464 : 0 : continue;
465 : : }
466 : :
467 : : /* regenerate the DN against the new ldb as it may have different
468 : : * casefolding rules (example: name changing from case insensitive
469 : : * to case sensitive) */
470 : 0 : orig_dn = msg->dn;
471 : 0 : msg->dn = ldb_dn_new(msg, sysdb->ldb,
472 : : ldb_dn_get_linearized(orig_dn));
473 [ # # ]: 0 : if (!msg->dn) {
474 : : ret = ENOMEM;
475 : : goto done;
476 : : }
477 : :
478 : 0 : ret = ldb_add(sysdb->ldb, msg);
479 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
480 [ # # ][ # # ]: 0 : DEBUG(0, ("WARNING: Could not add entry %s,"
[ # # ][ # # ]
[ # # ]
481 : : " to new ldb file! (%d [%s])\n",
482 : : ldb_dn_get_linearized(msg->dn),
483 : : ret, ldb_errstring(sysdb->ldb)));
484 : : }
485 : :
486 : 0 : ret = ldb_delete(ldb, orig_dn);
487 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
488 [ # # ][ # # ]: 0 : DEBUG(0, ("WARNING: Could not remove entry %s,"
[ # # ][ # # ]
[ # # ]
489 : : " from old ldb file! (%d [%s])\n",
490 : : ldb_dn_get_linearized(orig_dn),
491 : : ret, ldb_errstring(ldb)));
492 : : }
493 : : }
494 : :
495 : : /* now remove the basic containers from local */
496 : : /* these were optional so debug at level 9 in case
497 : : * of failure just for tracing */
498 : 0 : ret = ldb_delete(ldb, groups_dn);
499 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
500 [ # # ][ # # ]: 0 : DEBUG(9, ("WARNING: Could not remove entry %s,"
[ # # ][ # # ]
[ # # ]
501 : : " from old ldb file! (%d [%s])\n",
502 : : ldb_dn_get_linearized(groups_dn),
503 : : ret, ldb_errstring(ldb)));
504 : : }
505 : 0 : ret = ldb_delete(ldb, users_dn);
506 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
507 [ # # ][ # # ]: 0 : DEBUG(9, ("WARNING: Could not remove entry %s,"
[ # # ][ # # ]
[ # # ]
508 : : " from old ldb file! (%d [%s])\n",
509 : : ldb_dn_get_linearized(users_dn),
510 : : ret, ldb_errstring(ldb)));
511 : : }
512 : 0 : ret = ldb_delete(ldb, domain_dn);
513 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
514 [ # # ][ # # ]: 0 : DEBUG(9, ("WARNING: Could not remove entry %s,"
[ # # ][ # # ]
[ # # ]
515 : : " from old ldb file! (%d [%s])\n",
516 : : ldb_dn_get_linearized(domain_dn),
517 : : ret, ldb_errstring(ldb)));
518 : : }
519 : :
520 : 0 : ret = ldb_transaction_commit(sysdb->ldb);
521 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
522 [ # # ][ # # ]: 0 : DEBUG(1, ("Failed to commit ldb transaction! (%d)\n", ret));
[ # # ][ # # ]
[ # # ]
523 : : ret = EIO;
524 : : goto done;
525 : : }
526 : 0 : ctx_trans = false;
527 : :
528 : 0 : talloc_zfree(domain_dn);
529 : 0 : talloc_zfree(groups_dn);
530 : 0 : talloc_zfree(users_dn);
531 : 0 : talloc_zfree(res);
532 : : }
533 : :
534 : : /* conversion done, upgrade version number */
535 : 0 : msg = ldb_msg_new(tmp_ctx);
536 [ # # ]: 0 : if (!msg) {
537 : : ret = ENOMEM;
538 : : goto done;
539 : : }
540 : 0 : msg->dn = ldb_dn_new(tmp_ctx, ldb, SYSDB_BASE);
541 [ # # ]: 0 : if (!msg->dn) {
542 : : ret = ENOMEM;
543 : : goto done;
544 : : }
545 : :
546 : 0 : ret = ldb_msg_add_empty(msg, "version", LDB_FLAG_MOD_REPLACE, NULL);
547 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
548 : : ret = ENOMEM;
549 : : goto done;
550 : : }
551 : 0 : ret = ldb_msg_add_string(msg, "version", SYSDB_VERSION_0_3);
552 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
553 : : ret = ENOMEM;
554 : : goto done;
555 : : }
556 : :
557 : 0 : ret = ldb_modify(ldb, msg);
558 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
559 : 0 : ret = sysdb_error_to_errno(ret);
560 : : goto done;
561 : : }
562 : :
563 : 0 : ret = ldb_transaction_commit(ldb);
564 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
565 [ # # ][ # # ]: 0 : DEBUG(1, ("Failed to commit ldb transaction! (%d)\n", ret));
[ # # ][ # # ]
[ # # ]
566 : : ret = EIO;
567 : : goto exit;
568 : : }
569 : :
570 : : ret = EOK;
571 : :
572 : : done:
573 [ # # ]: 0 : if (ret != EOK) {
574 [ # # ]: 0 : if (ctx_trans) {
575 : 0 : ret = ldb_transaction_cancel(sysdb->ldb);
576 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
577 [ # # ][ # # ]: 0 : DEBUG(1, ("Failed to cancel ldb transaction! (%d)\n", ret));
[ # # ][ # # ]
[ # # ]
578 : : }
579 : : }
580 : 0 : ret = ldb_transaction_cancel(ldb);
581 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
582 [ # # ][ # # ]: 0 : DEBUG(1, ("Failed to cancel ldb transaction! (%d)\n", ret));
[ # # ][ # # ]
[ # # ]
583 : : }
584 : : }
585 : :
586 : : exit:
587 : 0 : talloc_free(tmp_ctx);
588 : : return ret;
589 : : }
590 : :
591 : 0 : int sysdb_upgrade_03(struct sysdb_ctx *sysdb, const char **ver)
592 : : {
593 : : TALLOC_CTX *tmp_ctx;
594 : : int ret;
595 : : struct ldb_message *msg;
596 : : struct upgrade_ctx *ctx;
597 : :
598 : 0 : tmp_ctx = talloc_new(NULL);
599 [ # # ]: 0 : if (!tmp_ctx) {
600 : : return ENOMEM;
601 : : }
602 : :
603 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_4, &ctx);
604 [ # # ]: 0 : if (ret) {
605 : : return ret;
606 : : }
607 : :
608 : : /* Make this database case-sensitive */
609 : 0 : msg = ldb_msg_new(tmp_ctx);
610 [ # # ]: 0 : if (!msg) {
611 : : ret = ENOMEM;
612 : : goto done;
613 : : }
614 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@ATTRIBUTES");
615 [ # # ]: 0 : if (!msg->dn) {
616 : : ret = ENOMEM;
617 : : goto done;
618 : : }
619 : :
620 : 0 : ret = ldb_msg_add_empty(msg, "name", LDB_FLAG_MOD_DELETE, NULL);
621 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
622 : : ret = ENOMEM;
623 : : goto done;
624 : : }
625 : :
626 : 0 : ret = ldb_modify(sysdb->ldb, msg);
627 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
628 : 0 : ret = sysdb_error_to_errno(ret);
629 : : goto done;
630 : : }
631 : :
632 : : /* conversion done, update version number */
633 : 0 : ret = update_version(ctx);
634 : :
635 : : done:
636 : 0 : ret = finish_upgrade(ret, &ctx, ver);
637 : 0 : talloc_free(tmp_ctx);
638 : : return ret;
639 : : }
640 : :
641 : 0 : int sysdb_upgrade_04(struct sysdb_ctx *sysdb, const char **ver)
642 : : {
643 : : TALLOC_CTX *tmp_ctx;
644 : : int ret;
645 : : struct ldb_message *msg;
646 : : struct upgrade_ctx *ctx;
647 : :
648 : 0 : tmp_ctx = talloc_new(NULL);
649 [ # # ]: 0 : if (!tmp_ctx) {
650 : : return ENOMEM;
651 : : }
652 : :
653 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_5, &ctx);
654 [ # # ]: 0 : if (ret) {
655 : : return ret;
656 : : }
657 : :
658 : : /* Add new index */
659 : 0 : msg = ldb_msg_new(tmp_ctx);
660 [ # # ]: 0 : if (!msg) {
661 : : ret = ENOMEM;
662 : : goto done;
663 : : }
664 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@INDEXLIST");
665 [ # # ]: 0 : if (!msg->dn) {
666 : : ret = ENOMEM;
667 : : goto done;
668 : : }
669 : :
670 : 0 : ret = ldb_msg_add_empty(msg, "@IDXATTR", LDB_FLAG_MOD_ADD, NULL);
671 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
672 : : ret = ENOMEM;
673 : : goto done;
674 : : }
675 : 0 : ret = ldb_msg_add_string(msg, "@IDXATTR", "originalDN");
676 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
677 : : ret = ENOMEM;
678 : : goto done;
679 : : }
680 : :
681 : 0 : ret = ldb_modify(sysdb->ldb, msg);
682 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
683 : 0 : ret = sysdb_error_to_errno(ret);
684 : : goto done;
685 : : }
686 : :
687 : : /* Rebuild memberuid and memberoif attributes */
688 : 0 : msg = ldb_msg_new(tmp_ctx);
689 [ # # ]: 0 : if (!msg) {
690 : : ret = ENOMEM;
691 : : goto done;
692 : : }
693 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@MEMBEROF-REBUILD");
694 [ # # ]: 0 : if (!msg->dn) {
695 : : ret = ENOMEM;
696 : : goto done;
697 : : }
698 : :
699 : 0 : ret = ldb_add(sysdb->ldb, msg);
700 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
701 : 0 : ret = sysdb_error_to_errno(ret);
702 : : goto done;
703 : : }
704 : :
705 : : /* conversion done, update version number */
706 : 0 : ret = update_version(ctx);
707 : :
708 : : done:
709 : 0 : ret = finish_upgrade(ret, &ctx, ver);
710 : 0 : talloc_free(tmp_ctx);
711 : : return ret;
712 : : }
713 : :
714 : 0 : int sysdb_upgrade_05(struct sysdb_ctx *sysdb, const char **ver)
715 : : {
716 : : TALLOC_CTX *tmp_ctx;
717 : : int ret;
718 : : struct ldb_message *msg;
719 : : struct upgrade_ctx *ctx;
720 : :
721 : 0 : tmp_ctx = talloc_new(NULL);
722 [ # # ]: 0 : if (!tmp_ctx) {
723 : : return ENOMEM;
724 : : }
725 : :
726 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_6, &ctx);
727 [ # # ]: 0 : if (ret) {
728 : : return ret;
729 : : }
730 : :
731 : : /* Add new indexes */
732 : 0 : msg = ldb_msg_new(tmp_ctx);
733 [ # # ]: 0 : if (!msg) {
734 : : ret = ENOMEM;
735 : : goto done;
736 : : }
737 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@INDEXLIST");
738 [ # # ]: 0 : if (!msg->dn) {
739 : : ret = ENOMEM;
740 : : goto done;
741 : : }
742 : :
743 : : /* Add Index for dataExpireTimestamp */
744 : 0 : ret = ldb_msg_add_empty(msg, "@IDXATTR", LDB_FLAG_MOD_ADD, NULL);
745 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
746 : : ret = ENOMEM;
747 : : goto done;
748 : : }
749 : 0 : ret = ldb_msg_add_string(msg, "@IDXATTR", "dataExpireTimestamp");
750 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
751 : : ret = ENOMEM;
752 : : goto done;
753 : : }
754 : :
755 : : /* Add index to speed up ONELEVEL searches */
756 : 0 : ret = ldb_msg_add_empty(msg, "@IDXONE", LDB_FLAG_MOD_ADD, NULL);
757 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
758 : : ret = ENOMEM;
759 : : goto done;
760 : : }
761 : 0 : ret = ldb_msg_add_string(msg, "@IDXONE", "1");
762 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
763 : : ret = ENOMEM;
764 : : goto done;
765 : : }
766 : :
767 : 0 : ret = ldb_modify(sysdb->ldb, msg);
768 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
769 : 0 : ret = sysdb_error_to_errno(ret);
770 : : goto done;
771 : : }
772 : :
773 : : /* conversion done, update version number */
774 : 0 : ret = update_version(ctx);
775 : :
776 : : done:
777 : 0 : ret = finish_upgrade(ret, &ctx, ver);
778 : 0 : talloc_free(tmp_ctx);
779 : : return ret;
780 : : }
781 : :
782 : 0 : int sysdb_upgrade_06(struct sysdb_ctx *sysdb, const char **ver)
783 : : {
784 : : TALLOC_CTX *tmp_ctx;
785 : : int ret;
786 : : struct ldb_message *msg;
787 : : struct upgrade_ctx *ctx;
788 : :
789 : 0 : tmp_ctx = talloc_new(NULL);
790 [ # # ]: 0 : if (!tmp_ctx) {
791 : : return ENOMEM;
792 : : }
793 : :
794 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_7, &ctx);
795 [ # # ]: 0 : if (ret) {
796 : : return ret;
797 : : }
798 : :
799 : : /* Add new indexes */
800 : 0 : msg = ldb_msg_new(tmp_ctx);
801 [ # # ]: 0 : if (!msg) {
802 : : ret = ENOMEM;
803 : : goto done;
804 : : }
805 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@ATTRIBUTES");
806 [ # # ]: 0 : if (!msg->dn) {
807 : : ret = ENOMEM;
808 : : goto done;
809 : : }
810 : :
811 : : /* Case insensitive search for originalDN */
812 : 0 : ret = ldb_msg_add_empty(msg, SYSDB_ORIG_DN, LDB_FLAG_MOD_ADD, NULL);
813 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
814 : : ret = ENOMEM;
815 : : goto done;
816 : : }
817 : 0 : ret = ldb_msg_add_string(msg, SYSDB_ORIG_DN, "CASE_INSENSITIVE");
818 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
819 : : ret = ENOMEM;
820 : : goto done;
821 : : }
822 : :
823 : 0 : ret = ldb_modify(sysdb->ldb, msg);
824 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
825 : 0 : ret = sysdb_error_to_errno(ret);
826 : : goto done;
827 : : }
828 : :
829 : : /* conversion done, update version number */
830 : 0 : ret = update_version(ctx);
831 : :
832 : : done:
833 : 0 : ret = finish_upgrade(ret, &ctx, ver);
834 : 0 : talloc_free(tmp_ctx);
835 : : return ret;
836 : : }
837 : :
838 : 0 : int sysdb_upgrade_07(struct sysdb_ctx *sysdb, const char **ver)
839 : : {
840 : : TALLOC_CTX *tmp_ctx;
841 : : int ret;
842 : : struct ldb_message *msg;
843 : : struct upgrade_ctx *ctx;
844 : :
845 : 0 : tmp_ctx = talloc_new(NULL);
846 [ # # ]: 0 : if (!tmp_ctx) {
847 : : return ENOMEM;
848 : : }
849 : :
850 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_8, &ctx);
851 [ # # ]: 0 : if (ret) {
852 : : return ret;
853 : : }
854 : :
855 : : /* Add new indexes */
856 : 0 : msg = ldb_msg_new(tmp_ctx);
857 [ # # ]: 0 : if (!msg) {
858 : : ret = ENOMEM;
859 : : goto done;
860 : : }
861 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@INDEXLIST");
862 [ # # ]: 0 : if (!msg->dn) {
863 : : ret = ENOMEM;
864 : : goto done;
865 : : }
866 : :
867 : : /* Add Index for nameAlias */
868 : 0 : ret = ldb_msg_add_empty(msg, "@IDXATTR", LDB_FLAG_MOD_ADD, NULL);
869 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
870 : : ret = ENOMEM;
871 : : goto done;
872 : : }
873 : 0 : ret = ldb_msg_add_string(msg, "@IDXATTR", "nameAlias");
874 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
875 : : ret = ENOMEM;
876 : : goto done;
877 : : }
878 : :
879 : 0 : ret = ldb_modify(sysdb->ldb, msg);
880 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
881 : 0 : ret = sysdb_error_to_errno(ret);
882 : : goto done;
883 : : }
884 : :
885 : : /* conversion done, update version number */
886 : 0 : ret = update_version(ctx);
887 : :
888 : : done:
889 : 0 : ret = finish_upgrade(ret, &ctx, ver);
890 : 0 : talloc_free(tmp_ctx);
891 : : return ret;
892 : : }
893 : :
894 : 0 : int sysdb_upgrade_08(struct sysdb_ctx *sysdb, const char **ver)
895 : : {
896 : : TALLOC_CTX *tmp_ctx;
897 : : int ret;
898 : : struct ldb_message *msg;
899 : : struct upgrade_ctx *ctx;
900 : :
901 : 0 : tmp_ctx = talloc_new(NULL);
902 [ # # ]: 0 : if (!tmp_ctx) {
903 : : return ENOMEM;
904 : : }
905 : :
906 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_9, &ctx);
907 [ # # ]: 0 : if (ret) {
908 : : return ret;
909 : : }
910 : :
911 : : /* Add new indexes */
912 : 0 : msg = ldb_msg_new(tmp_ctx);
913 [ # # ]: 0 : if (!msg) {
914 : : ret = ENOMEM;
915 : : goto done;
916 : : }
917 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@INDEXLIST");
918 [ # # ]: 0 : if (!msg->dn) {
919 : : ret = ENOMEM;
920 : : goto done;
921 : : }
922 : :
923 : : /* Add Index for servicePort and serviceProtocol */
924 : 0 : ret = ldb_msg_add_empty(msg, "@IDXATTR", LDB_FLAG_MOD_ADD, NULL);
925 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
926 : : ret = ENOMEM;
927 : : goto done;
928 : : }
929 : 0 : ret = ldb_msg_add_string(msg, "@IDXATTR", "servicePort");
930 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
931 : : ret = ENOMEM;
932 : : goto done;
933 : : }
934 : :
935 : 0 : ret = ldb_msg_add_string(msg, "@IDXATTR", "serviceProtocol");
936 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
937 : : ret = ENOMEM;
938 : : goto done;
939 : : }
940 : :
941 : 0 : ret = ldb_modify(sysdb->ldb, msg);
942 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
943 : 0 : ret = sysdb_error_to_errno(ret);
944 : : goto done;
945 : : }
946 : :
947 : : /* conversion done, update version number */
948 : 0 : ret = update_version(ctx);
949 : :
950 : : done:
951 : 0 : ret = finish_upgrade(ret, &ctx, ver);
952 : 0 : talloc_free(tmp_ctx);
953 : : return ret;
954 : : }
955 : :
956 : 0 : int sysdb_upgrade_09(struct sysdb_ctx *sysdb, const char **ver)
957 : : {
958 : : TALLOC_CTX *tmp_ctx;
959 : : int ret;
960 : : struct ldb_message *msg;
961 : : struct upgrade_ctx *ctx;
962 : :
963 : 0 : tmp_ctx = talloc_new(NULL);
964 [ # # ]: 0 : if (!tmp_ctx) {
965 : : return ENOMEM;
966 : : }
967 : :
968 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_10, &ctx);
969 [ # # ]: 0 : if (ret) {
970 : : return ret;
971 : : }
972 : :
973 : : /* Add new indexes */
974 : 0 : msg = ldb_msg_new(tmp_ctx);
975 [ # # ]: 0 : if (!msg) {
976 : : ret = ENOMEM;
977 : : goto done;
978 : : }
979 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@INDEXLIST");
980 [ # # ]: 0 : if (!msg->dn) {
981 : : ret = ENOMEM;
982 : : goto done;
983 : : }
984 : :
985 : : /* Add Index for servicePort and serviceProtocol */
986 : 0 : ret = ldb_msg_add_empty(msg, "@IDXATTR", LDB_FLAG_MOD_ADD, NULL);
987 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
988 : : ret = ENOMEM;
989 : : goto done;
990 : : }
991 : :
992 : 0 : ret = ldb_msg_add_string(msg, "@IDXATTR", "sudoUser");
993 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
994 : : ret = ENOMEM;
995 : : goto done;
996 : : }
997 : :
998 : 0 : ret = ldb_modify(sysdb->ldb, msg);
999 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1000 : 0 : ret = sysdb_error_to_errno(ret);
1001 : : goto done;
1002 : : }
1003 : :
1004 : : /* conversion done, update version number */
1005 : 0 : ret = update_version(ctx);
1006 : :
1007 : : done:
1008 : 0 : ret = finish_upgrade(ret, &ctx, ver);
1009 : 0 : talloc_free(tmp_ctx);
1010 : : return ret;
1011 : : }
1012 : :
1013 : 0 : int sysdb_upgrade_10(struct sysdb_ctx *sysdb, const char **ver)
1014 : : {
1015 : :
1016 : : TALLOC_CTX *tmp_ctx;
1017 : : int ret;
1018 : : struct ldb_result *res;
1019 : : struct ldb_message *msg;
1020 : : struct ldb_message *user;
1021 : : struct ldb_message_element *memberof_el;
1022 : : const char *name;
1023 : : struct ldb_dn *basedn;
1024 : 0 : const char *filter = "(&(objectClass=user)(!(uidNumber=*))(memberOf=*))";
1025 : 0 : const char *attrs[] = { "name", "memberof", NULL };
1026 : : struct upgrade_ctx *ctx;
1027 : : int i, j;
1028 : :
1029 : 0 : tmp_ctx = talloc_new(NULL);
1030 [ # # ]: 0 : if (tmp_ctx == NULL) {
1031 : : return ENOMEM;
1032 : : }
1033 : :
1034 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_11, &ctx);
1035 [ # # ]: 0 : if (ret) {
1036 : : return ret;
1037 : : }
1038 : :
1039 : 0 : basedn = ldb_dn_new_fmt(tmp_ctx, sysdb->ldb, SYSDB_TMPL_USER_BASE,
1040 : 0 : sysdb->domain->name);
1041 [ # # ]: 0 : if (basedn == NULL) {
1042 : : ret = EIO;
1043 : : goto done;
1044 : : }
1045 : :
1046 : 0 : ret = ldb_search(sysdb->ldb, tmp_ctx, &res, basedn, LDB_SCOPE_SUBTREE,
1047 : : attrs, "%s", filter);
1048 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1049 : : ret = EIO;
1050 : : goto done;
1051 : : }
1052 : :
1053 [ # # ]: 0 : for (i = 0; i < res->count; i++) {
1054 : 0 : user = res->msgs[i];
1055 : 0 : memberof_el = ldb_msg_find_element(user, "memberof");
1056 : 0 : name = ldb_msg_find_attr_as_string(user, "name", NULL);
1057 [ # # ]: 0 : if (name == NULL) {
1058 : : ret = EIO;
1059 : : goto done;
1060 : : }
1061 : :
1062 [ # # ]: 0 : for (j = 0; j < memberof_el->num_values; j++) {
1063 : 0 : msg = ldb_msg_new(tmp_ctx);
1064 [ # # ]: 0 : if (msg == NULL) {
1065 : : ret = ENOMEM;
1066 : : goto done;
1067 : : }
1068 : :
1069 : 0 : msg->dn = ldb_dn_from_ldb_val(tmp_ctx, sysdb->ldb, &memberof_el->values[j]);
1070 [ # # ]: 0 : if (msg->dn == NULL) {
1071 : : ret = ENOMEM;
1072 : : goto done;
1073 : : }
1074 : :
1075 [ # # ]: 0 : if (!ldb_dn_validate(msg->dn)) {
1076 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_MINOR_FAILURE, ("DN validation failed during "
[ # # ][ # # ]
[ # # ]
1077 : : "upgrade: [%s]\n",
1078 : : memberof_el->values[j].data));
1079 : 0 : talloc_zfree(msg);
1080 : 0 : continue;
1081 : : }
1082 : :
1083 : 0 : ret = ldb_msg_add_empty(msg, "ghost", LDB_FLAG_MOD_ADD, NULL);
1084 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1085 : : ret = ENOMEM;
1086 : : goto done;
1087 : : }
1088 : 0 : ret = ldb_msg_add_string(msg, "ghost", name);
1089 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1090 : : ret = ENOMEM;
1091 : : goto done;
1092 : : }
1093 : :
1094 : 0 : ret = ldb_modify(sysdb->ldb, msg);
1095 : 0 : talloc_zfree(msg);
1096 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1097 : 0 : ret = sysdb_error_to_errno(ret);
1098 : : goto done;
1099 : : }
1100 : : }
1101 : :
1102 : 0 : ret = ldb_delete(sysdb->ldb, user->dn);
1103 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1104 : 0 : ret = sysdb_error_to_errno(ret);
1105 : : goto done;
1106 : : }
1107 : : }
1108 : :
1109 : : /* conversion done, update version number */
1110 : 0 : ret = update_version(ctx);
1111 : :
1112 : : done:
1113 : 0 : ret = finish_upgrade(ret, &ctx, ver);
1114 : 0 : talloc_free(tmp_ctx);
1115 : : return ret;
1116 : : }
1117 : :
1118 : 0 : int sysdb_upgrade_11(struct sysdb_ctx *sysdb, const char **ver)
1119 : : {
1120 : : TALLOC_CTX *tmp_ctx;
1121 : : errno_t ret;
1122 : : struct ldb_result *res;
1123 : : struct ldb_message *entry;
1124 : : const char *key;
1125 : : const char *value;
1126 : : struct ldb_message_element *memberof_el;
1127 : : struct ldb_dn *memberof_dn;
1128 : : struct ldb_dn *basedn;
1129 : : const struct ldb_val *val;
1130 : 0 : const char *attrs[] = { SYSDB_AUTOFS_ENTRY_KEY,
1131 : : SYSDB_AUTOFS_ENTRY_VALUE,
1132 : : SYSDB_MEMBEROF,
1133 : : NULL };
1134 : : struct upgrade_ctx *ctx;
1135 : : size_t i, j;
1136 : :
1137 : 0 : tmp_ctx = talloc_new(NULL);
1138 [ # # ]: 0 : if (!tmp_ctx) {
1139 : : return ENOMEM;
1140 : : }
1141 : :
1142 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_12, &ctx);
1143 [ # # ]: 0 : if (ret) {
1144 : : return ret;
1145 : : }
1146 : :
1147 : 0 : basedn = ldb_dn_new_fmt(tmp_ctx, sysdb->ldb, SYSDB_TMPL_CUSTOM_SUBTREE,
1148 : 0 : AUTOFS_ENTRY_SUBDIR, sysdb->domain->name);
1149 [ # # ]: 0 : if (basedn == NULL) {
1150 : : ret = ENOMEM;
1151 : : goto done;
1152 : : }
1153 : :
1154 : 0 : ret = ldb_search(sysdb->ldb, tmp_ctx, &res, basedn, LDB_SCOPE_SUBTREE,
1155 : : attrs, "(objectClass=%s)", SYSDB_AUTOFS_ENTRY_OC);
1156 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1157 : : ret = EIO;
1158 : : goto done;
1159 : : }
1160 : :
1161 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_TRACE_LIBS, ("Found %d autofs entries\n", res->count));
[ # # ][ # # ]
[ # # ]
1162 : :
1163 [ # # ]: 0 : for (i = 0; i < res->count; i++) {
1164 : 0 : entry = res->msgs[i];
1165 : 0 : key = ldb_msg_find_attr_as_string(entry,
1166 : : SYSDB_AUTOFS_ENTRY_KEY, NULL);
1167 : 0 : value = ldb_msg_find_attr_as_string(entry,
1168 : : SYSDB_AUTOFS_ENTRY_VALUE, NULL);
1169 : 0 : memberof_el = ldb_msg_find_element(entry, SYSDB_MEMBEROF);
1170 : :
1171 [ # # ][ # # ]: 0 : if (key && value && memberof_el) {
1172 [ # # ]: 0 : for (j = 0; j < memberof_el->num_values; j++) {
1173 : 0 : memberof_dn = ldb_dn_from_ldb_val(tmp_ctx, sysdb->ldb,
1174 : 0 : &(memberof_el->values[j]));
1175 [ # # ]: 0 : if (!memberof_dn) {
1176 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE, ("Cannot convert memberof into DN, skipping\n"));
[ # # ][ # # ]
[ # # ]
1177 : 0 : continue;
1178 : : }
1179 : :
1180 : 0 : val = ldb_dn_get_rdn_val(memberof_dn);
1181 [ # # ]: 0 : if (!val) {
1182 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE, ("Cannot get map name from map DN\n"));
[ # # ][ # # ]
[ # # ]
1183 : 0 : continue;
1184 : : }
1185 : :
1186 : 0 : ret = sysdb_save_autofsentry(sysdb, (const char *) val->data,
1187 : : key, value, NULL);
1188 [ # # ]: 0 : if (ret != EOK) {
1189 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE,
[ # # ][ # # ]
[ # # ]
1190 : : ("Cannot save autofs entry [%s]-[%s] into map %s\n",
1191 : : key, value, val->data));
1192 : 0 : continue;
1193 : : }
1194 : : }
1195 : :
1196 : : }
1197 : :
1198 : : /* Delete the old entry if it was either processed or incomplete */
1199 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_TRACE_LIBS, ("Deleting [%s]\n",
[ # # ][ # # ]
[ # # ]
1200 : : ldb_dn_get_linearized(entry->dn)));
1201 : :
1202 : 0 : ret = ldb_delete(sysdb->ldb, entry->dn);
1203 [ # # ]: 0 : if (ret != EOK) {
1204 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE, ("Cannot delete old autofs entry %s\n",
[ # # ][ # # ]
[ # # ]
1205 : : ldb_dn_get_linearized(entry->dn)));
1206 : 0 : continue;
1207 : : }
1208 : : }
1209 : :
1210 : : /* conversion done, update version number */
1211 : 0 : ret = update_version(ctx);
1212 : :
1213 : : done:
1214 : 0 : ret = finish_upgrade(ret, &ctx, ver);
1215 : 0 : talloc_free(tmp_ctx);
1216 : : return ret;
1217 : : }
1218 : :
1219 : 0 : int sysdb_upgrade_12(struct sysdb_ctx *sysdb, const char **ver)
1220 : : {
1221 : : TALLOC_CTX *tmp_ctx;
1222 : : int ret;
1223 : : struct ldb_message *msg;
1224 : : struct upgrade_ctx *ctx;
1225 : :
1226 : 0 : tmp_ctx = talloc_new(NULL);
1227 [ # # ]: 0 : if (!tmp_ctx) {
1228 : : return ENOMEM;
1229 : : }
1230 : :
1231 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_13, &ctx);
1232 [ # # ]: 0 : if (ret) {
1233 : : return ret;
1234 : : }
1235 : :
1236 : : /* add new indexes */
1237 : 0 : msg = ldb_msg_new(tmp_ctx);
1238 [ # # ]: 0 : if (!msg) {
1239 : : ret = ENOMEM;
1240 : : goto done;
1241 : : }
1242 : 0 : msg->dn = ldb_dn_new(tmp_ctx, sysdb->ldb, "@INDEXLIST");
1243 [ # # ]: 0 : if (!msg->dn) {
1244 : : ret = ENOMEM;
1245 : : goto done;
1246 : : }
1247 : :
1248 : : /* add index for sshKnownHostsExpire */
1249 : 0 : ret = ldb_msg_add_empty(msg, "@IDXATTR", LDB_FLAG_MOD_ADD, NULL);
1250 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1251 : : ret = ENOMEM;
1252 : : goto done;
1253 : : }
1254 : :
1255 : 0 : ret = ldb_msg_add_string(msg, "@IDXATTR", "sshKnownHostsExpire");
1256 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1257 : : ret = ENOMEM;
1258 : : goto done;
1259 : : }
1260 : :
1261 : 0 : ret = ldb_modify(sysdb->ldb, msg);
1262 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1263 : 0 : ret = sysdb_error_to_errno(ret);
1264 : : goto done;
1265 : : }
1266 : :
1267 : : /* conversion done, update version number */
1268 : 0 : ret = update_version(ctx);
1269 : :
1270 : : done:
1271 : 0 : ret = finish_upgrade(ret, &ctx, ver);
1272 : 0 : talloc_free(tmp_ctx);
1273 : : return ret;
1274 : : }
1275 : :
1276 : 0 : int sysdb_upgrade_13(struct sysdb_ctx *sysdb, const char **ver)
1277 : : {
1278 : : struct upgrade_ctx *ctx;
1279 : : struct ldb_result *dom_res;
1280 : : struct ldb_result *res;
1281 : : struct ldb_dn *basedn;
1282 : 0 : const char *attrs[] = { "cn", "name", NULL };
1283 : : const char *tmp_str;
1284 : : errno_t ret;
1285 : : int i, j, l, n;
1286 : :
1287 : 0 : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_14, &ctx);
1288 [ # # ]: 0 : if (ret) {
1289 : : return ret;
1290 : : }
1291 : :
1292 : 0 : basedn = ldb_dn_new(ctx, sysdb->ldb, SYSDB_BASE);
1293 [ # # ]: 0 : if (!basedn) {
1294 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE, ("Failed to build base dn\n"));
[ # # ][ # # ]
[ # # ]
1295 : : ret = EIO;
1296 : : goto done;
1297 : : }
1298 : :
1299 : 0 : ret = ldb_search(sysdb->ldb, ctx, &dom_res,
1300 : : basedn, LDB_SCOPE_ONELEVEL,
1301 : : attrs, "objectclass=%s", SYSDB_SUBDOMAIN_CLASS);
1302 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1303 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE, ("Failed to search subdomains\n"));
[ # # ][ # # ]
[ # # ]
1304 : : ret = EIO;
1305 : : goto done;
1306 : : }
1307 : :
1308 [ # # ]: 0 : for (i = 0; i < dom_res->count; i++) {
1309 : :
1310 : 0 : tmp_str = ldb_msg_find_attr_as_string(dom_res->msgs[i], "cn", NULL);
1311 [ # # ]: 0 : if (tmp_str == NULL) {
1312 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_MINOR_FAILURE,
[ # # ][ # # ]
[ # # ]
1313 : : ("The object [%s] doesn't have a name\n",
1314 : : ldb_dn_get_linearized(dom_res->msgs[i]->dn)));
1315 : 0 : continue;
1316 : : }
1317 : :
1318 : 0 : basedn = ldb_dn_new_fmt(ctx, sysdb->ldb, SYSDB_DOM_BASE, tmp_str);
1319 [ # # ]: 0 : if (!basedn) {
1320 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE,
[ # # ][ # # ]
[ # # ]
1321 : : ("Failed to build base dn for subdomain %s\n", tmp_str));
1322 : 0 : continue;
1323 : : }
1324 : :
1325 : 0 : ret = ldb_search(sysdb->ldb, ctx, &res,
1326 : : basedn, LDB_SCOPE_SUBTREE, attrs, NULL);
1327 [ # # ]: 0 : if (ret != LDB_SUCCESS) {
1328 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE,
[ # # ][ # # ]
[ # # ]
1329 : : ("Failed to search subdomain %s\n", tmp_str));
1330 : 0 : talloc_free(basedn);
1331 : 0 : continue;
1332 : : }
1333 : :
1334 : 0 : l = ldb_dn_get_comp_num(basedn);
1335 [ # # ]: 0 : for (j = 0; j < res->count; j++) {
1336 : 0 : n = ldb_dn_get_comp_num(res->msgs[j]->dn);
1337 [ # # ]: 0 : if (n <= l + 1) {
1338 : : /* Do not remove subdomain containers, only their contents */
1339 : 0 : continue;
1340 : : }
1341 : 0 : ret = ldb_delete(sysdb->ldb, res->msgs[j]->dn);
1342 [ # # ]: 0 : if (ret) {
1343 [ # # ][ # # ]: 0 : DEBUG(SSSDBG_OP_FAILURE,
[ # # ][ # # ]
[ # # ]
1344 : : ("Failed to delete %s\n", res->msgs[j]->dn));
1345 : 0 : continue;
1346 : : }
1347 : : }
1348 : :
1349 : 0 : talloc_free(basedn);
1350 : 0 : talloc_free(res);
1351 : : }
1352 : :
1353 : 0 : talloc_free(dom_res);
1354 : :
1355 : : /* conversion done, update version number */
1356 : 0 : ret = update_version(ctx);
1357 : :
1358 : : done:
1359 : 0 : ret = finish_upgrade(ret, &ctx, ver);
1360 : : return ret;
1361 : : }
1362 : :
1363 : :
1364 : : /*
1365 : : * Example template for future upgrades.
1366 : : * Copy and change version numbers as appropriate.
1367 : : */
1368 : : #if 0
1369 : :
1370 : : int sysdb_upgrade_13(struct sysdb_ctx *sysdb, const char **ver)
1371 : : {
1372 : : struct upgrade_ctx *ctx;
1373 : : errno_t ret;
1374 : :
1375 : : ret = commence_upgrade(sysdb, sysdb->ldb, SYSDB_VERSION_0_14, &ctx);
1376 : : if (ret) {
1377 : : return ret;
1378 : : }
1379 : :
1380 : : /* DO STUFF HERE (use ctx, as the local temporary memory context) */
1381 : :
1382 : : /* conversion done, update version number */
1383 : : ret = update_version(ctx);
1384 : :
1385 : : done:
1386 : : ret = finish_upgrade(ret, &ctx, ver);
1387 : : return ret;
1388 : : }
1389 : : #endif
|
