Line data Source code
1 : /*
2 : SSSD
3 :
4 : Authors:
5 : Yassir Elley <yelley@redhat.com>
6 :
7 : Copyright (C) 2014 Red Hat
8 :
9 : This program is free software; you can redistribute it and/or modify
10 : it under the terms of the GNU General Public License as published by
11 : the Free Software Foundation; either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : This program is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU General Public License for more details.
18 :
19 : You should have received a copy of the GNU General Public License
20 : along with this program. If not, see <http://www.gnu.org/licenses/>.
21 : */
22 :
23 :
24 : #include "db/sysdb.h"
25 : #include "db/sysdb_private.h"
26 :
27 : static struct ldb_dn *
28 2 : sysdb_gpo_dn(TALLOC_CTX *mem_ctx, struct sss_domain_info *domain,
29 : const char *gpo_guid)
30 : {
31 : errno_t ret;
32 : char *clean_gpo_guid;
33 : struct ldb_dn *dn;
34 :
35 2 : ret = sysdb_dn_sanitize(NULL, gpo_guid, &clean_gpo_guid);
36 2 : if (ret != EOK) {
37 0 : return NULL;
38 : }
39 :
40 2 : DEBUG(SSSDBG_TRACE_ALL, SYSDB_TMPL_GPO"\n", clean_gpo_guid, domain->name);
41 :
42 2 : dn = ldb_dn_new_fmt(mem_ctx, domain->sysdb->ldb, SYSDB_TMPL_GPO,
43 : clean_gpo_guid, domain->name);
44 2 : talloc_free(clean_gpo_guid);
45 :
46 2 : return dn;
47 : }
48 :
49 : errno_t
50 2 : sysdb_gpo_store_gpo(struct sss_domain_info *domain,
51 : const char *gpo_guid,
52 : int gpo_version,
53 : int cache_timeout,
54 : time_t now)
55 : {
56 : errno_t ret, sret;
57 : int lret;
58 : struct ldb_message *update_msg;
59 : struct ldb_message **msgs;
60 : static const char *attrs[] = SYSDB_GPO_ATTRS;
61 : size_t count;
62 2 : bool in_transaction = false;
63 : TALLOC_CTX *tmp_ctx;
64 :
65 2 : tmp_ctx = talloc_new(NULL);
66 2 : if (!tmp_ctx) return ENOMEM;
67 :
68 2 : update_msg = ldb_msg_new(tmp_ctx);
69 2 : if (!update_msg) {
70 0 : ret = ENOMEM;
71 0 : goto done;
72 : }
73 :
74 2 : update_msg->dn = sysdb_gpo_dn(update_msg, domain, gpo_guid);
75 2 : if (!update_msg->dn) {
76 0 : ret = ENOMEM;
77 0 : goto done;
78 : }
79 :
80 2 : ret = sysdb_transaction_start(domain->sysdb);
81 2 : if (ret != EOK) {
82 0 : DEBUG(SSSDBG_CRIT_FAILURE, "Failed to start transaction\n");
83 0 : goto done;
84 : }
85 :
86 2 : if (!now) {
87 2 : now = time(NULL);
88 : }
89 :
90 2 : in_transaction = true;
91 :
92 : /* Check for an existing gpo_guid entry */
93 2 : ret = sysdb_search_entry(tmp_ctx, domain->sysdb, update_msg->dn,
94 : LDB_SCOPE_BASE, NULL, attrs, &count, &msgs);
95 :
96 2 : if (ret == ENOENT) {
97 : /* Create new GPO */
98 1 : DEBUG(SSSDBG_TRACE_FUNC,
99 : "Adding new GPO [gpo_guid:%s][gpo_version:%d]\n",
100 : gpo_guid, gpo_version);
101 :
102 : /* Add the objectClass */
103 1 : lret = ldb_msg_add_empty(update_msg, SYSDB_OBJECTCLASS,
104 : LDB_FLAG_MOD_ADD,
105 : NULL);
106 1 : if (lret != LDB_SUCCESS) {
107 0 : ret = sysdb_error_to_errno(lret);
108 0 : goto done;
109 : }
110 :
111 1 : lret = ldb_msg_add_string(update_msg, SYSDB_OBJECTCLASS,
112 : SYSDB_GPO_OC);
113 1 : if (lret != LDB_SUCCESS) {
114 0 : ret = sysdb_error_to_errno(lret);
115 0 : goto done;
116 : }
117 :
118 : /* Add the GPO GUID */
119 1 : lret = ldb_msg_add_empty(update_msg, SYSDB_GPO_GUID_ATTR,
120 : LDB_FLAG_MOD_ADD,
121 : NULL);
122 1 : if (lret != LDB_SUCCESS) {
123 0 : ret = sysdb_error_to_errno(lret);
124 0 : goto done;
125 : }
126 :
127 1 : lret = ldb_msg_add_string(update_msg, SYSDB_GPO_GUID_ATTR, gpo_guid);
128 1 : if (lret != LDB_SUCCESS) {
129 0 : ret = sysdb_error_to_errno(lret);
130 0 : goto done;
131 : }
132 :
133 : /* Add the Version */
134 1 : lret = ldb_msg_add_empty(update_msg, SYSDB_GPO_VERSION_ATTR,
135 : LDB_FLAG_MOD_ADD,
136 : NULL);
137 1 : if (lret != LDB_SUCCESS) {
138 0 : ret = sysdb_error_to_errno(lret);
139 0 : goto done;
140 : }
141 :
142 1 : lret = ldb_msg_add_fmt(update_msg, SYSDB_GPO_VERSION_ATTR,
143 : "%d", gpo_version);
144 1 : if (lret != LDB_SUCCESS) {
145 0 : ret = sysdb_error_to_errno(lret);
146 0 : goto done;
147 : }
148 :
149 : /* Add the Policy File Timeout */
150 1 : lret = ldb_msg_add_empty(update_msg, SYSDB_GPO_TIMEOUT_ATTR,
151 : LDB_FLAG_MOD_ADD, NULL);
152 1 : if (lret != LDB_SUCCESS) {
153 0 : ret = sysdb_error_to_errno(lret);
154 0 : goto done;
155 : }
156 :
157 2 : lret = ldb_msg_add_fmt(update_msg, SYSDB_GPO_TIMEOUT_ATTR, "%lu",
158 1 : ((cache_timeout) ? (now + cache_timeout) : 0));
159 1 : if (lret != LDB_SUCCESS) {
160 0 : ret = sysdb_error_to_errno(lret);
161 0 : goto done;
162 : }
163 :
164 1 : lret = ldb_add(domain->sysdb->ldb, update_msg);
165 1 : if (lret != LDB_SUCCESS) {
166 0 : DEBUG(SSSDBG_MINOR_FAILURE,
167 : "Failed to add GPO: [%s]\n",
168 : ldb_strerror(lret));
169 0 : ret = sysdb_error_to_errno(lret);
170 0 : goto done;
171 : }
172 1 : } else if (ret == EOK && count == 1) {
173 : /* Update the existing GPO */
174 :
175 1 : DEBUG(SSSDBG_TRACE_ALL, "Updating new GPO [%s][%s]\n", domain->name, gpo_guid);
176 :
177 : /* Add the Version */
178 1 : lret = ldb_msg_add_empty(update_msg, SYSDB_GPO_VERSION_ATTR,
179 : LDB_FLAG_MOD_REPLACE,
180 : NULL);
181 1 : if (lret != LDB_SUCCESS) {
182 0 : ret = sysdb_error_to_errno(lret);
183 0 : goto done;
184 : }
185 :
186 1 : lret = ldb_msg_add_fmt(update_msg, SYSDB_GPO_VERSION_ATTR,
187 : "%d", gpo_version);
188 1 : if (lret != LDB_SUCCESS) {
189 0 : ret = sysdb_error_to_errno(lret);
190 0 : goto done;
191 : }
192 :
193 : /* Add the Policy File Timeout */
194 1 : lret = ldb_msg_add_empty(update_msg, SYSDB_GPO_TIMEOUT_ATTR,
195 : LDB_FLAG_MOD_REPLACE, NULL);
196 1 : if (lret != LDB_SUCCESS) {
197 0 : ret = sysdb_error_to_errno(lret);
198 0 : goto done;
199 : }
200 :
201 2 : lret = ldb_msg_add_fmt(update_msg, SYSDB_GPO_TIMEOUT_ATTR, "%lu",
202 1 : ((cache_timeout) ? (now + cache_timeout) : 0));
203 1 : if (lret != LDB_SUCCESS) {
204 0 : ret = sysdb_error_to_errno(lret);
205 0 : goto done;
206 : }
207 :
208 1 : lret = ldb_modify(domain->sysdb->ldb, update_msg);
209 2 : if (lret != LDB_SUCCESS) {
210 0 : DEBUG(SSSDBG_MINOR_FAILURE,
211 : "Failed to modify GPO: [%s](%d)[%s]\n",
212 : ldb_strerror(lret), lret, ldb_errstring(domain->sysdb->ldb));
213 0 : ret = sysdb_error_to_errno(lret);
214 0 : goto done;
215 : }
216 : } else {
217 0 : ret = EIO;
218 0 : goto done;
219 : }
220 :
221 2 : ret = sysdb_transaction_commit(domain->sysdb);
222 2 : if (ret != EOK) {
223 0 : DEBUG(SSSDBG_CRIT_FAILURE,
224 : "Could not commit transaction: [%s]\n", strerror(ret));
225 0 : goto done;
226 : }
227 2 : in_transaction = false;
228 :
229 : done:
230 2 : if (in_transaction) {
231 0 : sret = sysdb_transaction_cancel(domain->sysdb);
232 0 : if (sret != EOK) {
233 0 : DEBUG(SSSDBG_CRIT_FAILURE, "Could not cancel transaction\n");
234 : }
235 : }
236 2 : talloc_free(tmp_ctx);
237 2 : return ret;
238 : }
239 :
240 : errno_t
241 4 : sysdb_gpo_get_gpo_by_guid(TALLOC_CTX *mem_ctx,
242 : struct sss_domain_info *domain,
243 : const char *gpo_guid,
244 : struct ldb_result **_result)
245 : {
246 : errno_t ret;
247 : int lret;
248 : struct ldb_dn *base_dn;
249 : TALLOC_CTX *tmp_ctx;
250 : struct ldb_result *res;
251 :
252 4 : const char *attrs[] = SYSDB_GPO_ATTRS;
253 :
254 4 : tmp_ctx = talloc_new(NULL);
255 4 : if (!tmp_ctx) return ENOMEM;
256 :
257 4 : DEBUG(SSSDBG_TRACE_ALL, SYSDB_TMPL_GPO_BASE"\n", domain->name);
258 :
259 4 : base_dn = ldb_dn_new_fmt(tmp_ctx, domain->sysdb->ldb,
260 : SYSDB_TMPL_GPO_BASE,
261 : domain->name);
262 4 : if (!base_dn) {
263 0 : ret = ENOMEM;
264 0 : goto done;
265 : }
266 :
267 4 : lret = ldb_search(domain->sysdb->ldb, tmp_ctx, &res, base_dn,
268 : LDB_SCOPE_SUBTREE, attrs, SYSDB_GPO_GUID_FILTER, gpo_guid);
269 4 : if (lret) {
270 0 : DEBUG(SSSDBG_MINOR_FAILURE,
271 : "Could not locate GPO: [%s]\n",
272 : ldb_strerror(lret));
273 0 : ret = sysdb_error_to_errno(lret);
274 0 : goto done;
275 : }
276 :
277 4 : if (res->count > 1) {
278 0 : DEBUG(SSSDBG_CRIT_FAILURE, "Search for GUID [%s] returned more than " \
279 : "one object.\n", gpo_guid);
280 0 : ret = EINVAL;
281 0 : goto done;
282 4 : } else if (res->count == 0) {
283 1 : ret = ENOENT;
284 1 : goto done;
285 : }
286 3 : *_result = talloc_steal(mem_ctx, res);
287 3 : ret = EOK;
288 : done:
289 :
290 4 : if (ret == ENOENT) {
291 1 : DEBUG(SSSDBG_TRACE_ALL, "No such entry.\n");
292 3 : } else if (ret) {
293 0 : DEBUG(SSSDBG_OP_FAILURE, "Error: %d (%s)\n", ret, strerror(ret));
294 : }
295 :
296 4 : talloc_free(tmp_ctx);
297 4 : return ret;
298 : }
299 :
300 : errno_t
301 2 : sysdb_gpo_get_gpos(TALLOC_CTX *mem_ctx,
302 : struct sss_domain_info *domain,
303 : struct ldb_result **_result)
304 : {
305 : errno_t ret;
306 : int lret;
307 : struct ldb_dn *base_dn;
308 : TALLOC_CTX *tmp_ctx;
309 : struct ldb_result *res;
310 :
311 2 : const char *attrs[] = SYSDB_GPO_ATTRS;
312 :
313 2 : tmp_ctx = talloc_new(NULL);
314 2 : if (!tmp_ctx) return ENOMEM;
315 :
316 2 : DEBUG(SSSDBG_TRACE_ALL, SYSDB_TMPL_GPO_BASE"\n", domain->name);
317 :
318 2 : base_dn = ldb_dn_new_fmt(tmp_ctx, domain->sysdb->ldb,
319 : SYSDB_TMPL_GPO_BASE,
320 : domain->name);
321 2 : if (!base_dn) {
322 0 : ret = ENOMEM;
323 0 : goto done;
324 : }
325 :
326 2 : lret = ldb_search(domain->sysdb->ldb, tmp_ctx, &res, base_dn,
327 : LDB_SCOPE_SUBTREE, attrs, SYSDB_GPO_FILTER);
328 2 : if (lret) {
329 0 : DEBUG(SSSDBG_MINOR_FAILURE,
330 : "Could not locate GPOs: [%s]\n",
331 : ldb_strerror(lret));
332 0 : ret = sysdb_error_to_errno(lret);
333 0 : goto done;
334 : }
335 :
336 2 : if (res->count == 0) {
337 1 : ret = ENOENT;
338 1 : goto done;
339 : }
340 :
341 1 : *_result = talloc_steal(mem_ctx, res);
342 1 : ret = EOK;
343 :
344 : done:
345 :
346 2 : if (ret == ENOENT) {
347 1 : DEBUG(SSSDBG_TRACE_ALL, "No GPO entries.\n");
348 1 : } else if (ret) {
349 0 : DEBUG(SSSDBG_OP_FAILURE, "Error: %d (%s)\n", ret, strerror(ret));
350 : }
351 :
352 2 : talloc_free(tmp_ctx);
353 2 : return ret;
354 : }
355 :
356 : /* GPO Result */
357 :
358 : static struct ldb_dn *
359 3 : sysdb_gpo_result_dn(TALLOC_CTX *mem_ctx,
360 : struct sss_domain_info *domain,
361 : const char *result_name)
362 : {
363 : errno_t ret;
364 : char *clean_result_name;
365 : struct ldb_dn *dn;
366 :
367 3 : ret = sysdb_dn_sanitize(NULL, result_name, &clean_result_name);
368 3 : if (ret != EOK) {
369 0 : return NULL;
370 : }
371 :
372 3 : DEBUG(SSSDBG_TRACE_ALL, SYSDB_TMPL_GPO_RESULT"\n",
373 : clean_result_name, domain->name);
374 :
375 3 : dn = ldb_dn_new_fmt(mem_ctx, domain->sysdb->ldb, SYSDB_TMPL_GPO_RESULT,
376 : clean_result_name, domain->name);
377 3 : talloc_free(clean_result_name);
378 :
379 3 : return dn;
380 : }
381 :
382 : errno_t
383 3 : sysdb_gpo_store_gpo_result_setting(struct sss_domain_info *domain,
384 : const char *ini_key,
385 : const char *ini_value)
386 : {
387 : errno_t ret, sret;
388 : int lret;
389 : struct ldb_message *update_msg;
390 : struct ldb_message **msgs;
391 : size_t count;
392 3 : bool in_transaction = false;
393 : TALLOC_CTX *tmp_ctx;
394 :
395 3 : tmp_ctx = talloc_new(NULL);
396 3 : if (!tmp_ctx) return ENOMEM;
397 :
398 3 : update_msg = ldb_msg_new(tmp_ctx);
399 3 : if (!update_msg) {
400 0 : ret = ENOMEM;
401 0 : goto done;
402 : }
403 :
404 3 : update_msg->dn = sysdb_gpo_result_dn(update_msg, domain, "gpo_result");
405 3 : if (!update_msg->dn) {
406 0 : ret = ENOMEM;
407 0 : goto done;
408 : }
409 :
410 3 : ret = sysdb_transaction_start(domain->sysdb);
411 3 : if (ret != EOK) {
412 0 : DEBUG(SSSDBG_CRIT_FAILURE, "Failed to start transaction\n");
413 0 : goto done;
414 : }
415 :
416 3 : in_transaction = true;
417 :
418 : /* Check for an existing GPO Result object */
419 3 : ret = sysdb_search_entry(tmp_ctx, domain->sysdb, update_msg->dn,
420 : LDB_SCOPE_BASE, NULL, NULL, &count, &msgs);
421 :
422 3 : if (ret == ENOENT) {
423 : /* Create new GPO Result object */
424 1 : DEBUG(SSSDBG_TRACE_FUNC, "Storing setting: key [%s] value [%s]\n",
425 : ini_key, ini_value);
426 :
427 : /* Add the objectClass */
428 1 : lret = ldb_msg_add_empty(update_msg, SYSDB_OBJECTCLASS,
429 : LDB_FLAG_MOD_ADD,
430 : NULL);
431 1 : if (lret != LDB_SUCCESS) {
432 0 : ret = sysdb_error_to_errno(lret);
433 0 : goto done;
434 : }
435 :
436 1 : lret = ldb_msg_add_string(update_msg, SYSDB_OBJECTCLASS,
437 : SYSDB_GPO_RESULT_OC);
438 1 : if (lret != LDB_SUCCESS) {
439 0 : ret = sysdb_error_to_errno(lret);
440 0 : goto done;
441 : }
442 :
443 : /* Store the policy_setting if it is non-NULL */
444 1 : if (ini_value) {
445 1 : lret = ldb_msg_add_empty(update_msg, ini_key,
446 : LDB_FLAG_MOD_ADD,
447 : NULL);
448 1 : if (lret != LDB_SUCCESS) {
449 0 : ret = sysdb_error_to_errno(lret);
450 0 : goto done;
451 : }
452 :
453 1 : lret = ldb_msg_add_string(update_msg, ini_key, ini_value);
454 1 : if (lret != LDB_SUCCESS) {
455 0 : ret = sysdb_error_to_errno(lret);
456 0 : goto done;
457 : }
458 : }
459 :
460 1 : lret = ldb_add(domain->sysdb->ldb, update_msg);
461 1 : if (lret != LDB_SUCCESS) {
462 0 : DEBUG(SSSDBG_MINOR_FAILURE,
463 : "Failed to add GPO Result: [%s]\n",
464 : ldb_strerror(lret));
465 0 : ret = sysdb_error_to_errno(lret);
466 0 : goto done;
467 : }
468 2 : } else if (ret == EOK && count == 1) {
469 : /* Update existing GPO Result object*/
470 2 : if (ini_value) {
471 1 : DEBUG(SSSDBG_TRACE_FUNC, "Updating setting: key [%s] value [%s]\n",
472 : ini_key, ini_value);
473 : /* Update the policy setting */
474 1 : lret = ldb_msg_add_empty(update_msg, ini_key,
475 : LDB_FLAG_MOD_REPLACE,
476 : NULL);
477 1 : if (lret != LDB_SUCCESS) {
478 0 : ret = sysdb_error_to_errno(lret);
479 0 : goto done;
480 : }
481 :
482 1 : lret = ldb_msg_add_fmt(update_msg, ini_key, "%s", ini_value);
483 1 : if (lret != LDB_SUCCESS) {
484 0 : ret = sysdb_error_to_errno(lret);
485 0 : goto done;
486 : }
487 : } else {
488 : /* If the value is NULL, we need to remove it from the cache */
489 1 : DEBUG(SSSDBG_TRACE_FUNC, "Removing setting: key [%s]\n", ini_key);
490 :
491 : /* Update the policy setting */
492 1 : lret = ldb_msg_add_empty(update_msg, ini_key,
493 : LDB_FLAG_MOD_DELETE,
494 : NULL);
495 1 : if (lret != LDB_SUCCESS) {
496 0 : ret = sysdb_error_to_errno(lret);
497 0 : goto done;
498 : }
499 : }
500 :
501 2 : lret = ldb_modify(domain->sysdb->ldb, update_msg);
502 4 : if (lret != LDB_SUCCESS) {
503 0 : DEBUG(SSSDBG_MINOR_FAILURE,
504 : "Failed to modify GPO Result: [%s](%d)[%s]\n",
505 : ldb_strerror(lret), lret, ldb_errstring(domain->sysdb->ldb));
506 0 : ret = sysdb_error_to_errno(lret);
507 0 : goto done;
508 : }
509 : } else {
510 0 : ret = EIO;
511 0 : goto done;
512 : }
513 :
514 3 : ret = sysdb_transaction_commit(domain->sysdb);
515 3 : if (ret != EOK) {
516 0 : DEBUG(SSSDBG_CRIT_FAILURE,
517 : "Could not commit transaction: [%s]\n", strerror(ret));
518 0 : goto done;
519 : }
520 3 : in_transaction = false;
521 :
522 : done:
523 3 : if (in_transaction) {
524 0 : sret = sysdb_transaction_cancel(domain->sysdb);
525 0 : if (sret != EOK) {
526 0 : DEBUG(SSSDBG_CRIT_FAILURE, "Could not cancel transaction\n");
527 : }
528 : }
529 3 : talloc_free(tmp_ctx);
530 3 : return ret;
531 : }
532 :
533 : static errno_t
534 10 : sysdb_gpo_get_gpo_result_object(TALLOC_CTX *mem_ctx,
535 : struct sss_domain_info *domain,
536 : const char **attrs,
537 : struct ldb_result **_result)
538 : {
539 : errno_t ret;
540 : int lret;
541 : struct ldb_dn *base_dn;
542 : TALLOC_CTX *tmp_ctx;
543 : struct ldb_result *res;
544 :
545 10 : tmp_ctx = talloc_new(NULL);
546 10 : if (!tmp_ctx) return ENOMEM;
547 :
548 10 : DEBUG(SSSDBG_TRACE_ALL, SYSDB_TMPL_GPO_RESULT_BASE"\n", domain->name);
549 :
550 10 : base_dn = ldb_dn_new_fmt(tmp_ctx, domain->sysdb->ldb,
551 : SYSDB_TMPL_GPO_RESULT_BASE,
552 : domain->name);
553 10 : if (!base_dn) {
554 0 : ret = ENOMEM;
555 0 : goto done;
556 : }
557 :
558 10 : lret = ldb_search(domain->sysdb->ldb, tmp_ctx, &res, base_dn,
559 : LDB_SCOPE_SUBTREE, attrs, SYSDB_GPO_RESULT_FILTER);
560 10 : if (lret) {
561 0 : DEBUG(SSSDBG_MINOR_FAILURE,
562 : "Could not locate GPO Result object: [%s]\n",
563 : ldb_strerror(lret));
564 0 : ret = sysdb_error_to_errno(lret);
565 0 : goto done;
566 : }
567 :
568 10 : if (res->count == 0) {
569 5 : ret = ENOENT;
570 5 : goto done;
571 : }
572 :
573 5 : *_result = talloc_steal(mem_ctx, res);
574 5 : ret = EOK;
575 :
576 : done:
577 :
578 10 : if (ret == ENOENT) {
579 5 : DEBUG(SSSDBG_TRACE_ALL, "No GPO Result object.\n");
580 5 : } else if (ret) {
581 0 : DEBUG(SSSDBG_OP_FAILURE, "Error: %d (%s)\n", ret, strerror(ret));
582 : }
583 :
584 10 : talloc_free(tmp_ctx);
585 10 : return ret;
586 : }
587 :
588 :
589 : errno_t
590 8 : sysdb_gpo_get_gpo_result_setting(TALLOC_CTX *mem_ctx,
591 : struct sss_domain_info *domain,
592 : const char *ini_key,
593 : const char **_ini_value)
594 : {
595 : errno_t ret;
596 : TALLOC_CTX *tmp_ctx;
597 : struct ldb_result *res;
598 : const char *ini_value;
599 :
600 8 : const char *attrs[] = {ini_key, NULL};
601 :
602 8 : tmp_ctx = talloc_new(NULL);
603 8 : if (!tmp_ctx) return ENOMEM;
604 :
605 8 : ret = sysdb_gpo_get_gpo_result_object(tmp_ctx, domain, attrs, &res);
606 8 : if (ret != EOK) {
607 4 : goto done;
608 : }
609 :
610 4 : ini_value = ldb_msg_find_attr_as_string(res->msgs[0],
611 : ini_key,
612 : NULL);
613 4 : DEBUG(SSSDBG_TRACE_FUNC, "key [%s] value [%s]\n", ini_key, ini_value);
614 :
615 4 : *_ini_value = talloc_strdup(mem_ctx, ini_value);
616 4 : if (!*_ini_value && ini_value) {
617 : /* If ini_value was NULL, this is expected to also be NULL */
618 0 : ret = ENOMEM;
619 0 : goto done;
620 : }
621 :
622 4 : ret = EOK;
623 :
624 : done:
625 :
626 8 : if (ret == ENOENT) {
627 4 : DEBUG(SSSDBG_TRACE_ALL, "No setting for key [%s].\n", ini_key);
628 4 : } else if (ret) {
629 0 : DEBUG(SSSDBG_OP_FAILURE, "Error: %d (%s)\n", ret, strerror(ret));
630 : }
631 :
632 8 : talloc_free(tmp_ctx);
633 8 : return ret;
634 : }
635 :
636 :
637 2 : errno_t sysdb_gpo_delete_gpo_result_object(TALLOC_CTX *mem_ctx,
638 : struct sss_domain_info *domain)
639 : {
640 : struct ldb_result *res;
641 : errno_t ret, sret;
642 2 : bool in_transaction = false;
643 :
644 2 : ret = sysdb_transaction_start(domain->sysdb);
645 2 : if (ret != EOK) {
646 0 : DEBUG(SSSDBG_CRIT_FAILURE, "Failed to start transaction\n");
647 0 : goto done;
648 : }
649 :
650 2 : in_transaction = true;
651 :
652 2 : ret = sysdb_gpo_get_gpo_result_object(mem_ctx, domain, NULL, &res);
653 2 : if (ret != EOK && ret != ENOENT) {
654 0 : DEBUG(SSSDBG_OP_FAILURE,
655 : "Could not delete GPO result object: %d\n", ret);
656 0 : goto done;
657 2 : } else if (ret != ENOENT) {
658 1 : DEBUG(SSSDBG_TRACE_FUNC, "Deleting GPO Result object\n");
659 :
660 1 : ret = sysdb_delete_entry(domain->sysdb, res->msgs[0]->dn, true);
661 1 : if (ret != EOK) {
662 0 : DEBUG(SSSDBG_MINOR_FAILURE,
663 : "Could not delete GPO Result cache entry\n");
664 0 : goto done;
665 : }
666 : }
667 :
668 2 : ret = sysdb_transaction_commit(domain->sysdb);
669 2 : if (ret != EOK) {
670 0 : DEBUG(SSSDBG_CRIT_FAILURE,
671 : "Could not commit transaction: [%s]\n", strerror(ret));
672 0 : goto done;
673 : }
674 2 : in_transaction = false;
675 :
676 : done:
677 2 : if (in_transaction) {
678 0 : sret = sysdb_transaction_cancel(domain->sysdb);
679 0 : if (sret != EOK) {
680 0 : DEBUG(SSSDBG_CRIT_FAILURE, "Could not cancel transaction\n");
681 : }
682 : }
683 2 : return ret;
684 :
685 : }
|
