diff options
Diffstat (limited to 'src/sssd/sssd_components.c')
| -rw-r--r-- | src/sssd/sssd_components.c | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/src/sssd/sssd_components.c b/src/sssd/sssd_components.c new file mode 100644 index 0000000..0cee595 --- /dev/null +++ b/src/sssd/sssd_components.c @@ -0,0 +1,360 @@ +/* + Authors: + Pavel Březina <pbrezina@redhat.com> + + Copyright (C) 2014 Red Hat + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <stdint.h> +#include <dbus/dbus.h> +#include <sss_dbus.h> +#include <konkret/konkret.h> +#include "sssd_components.h" +#include "utils.h" + +static sss_dbus_error +sssd_component_find(sss_dbus_ctx *dbus_ctx, + const char *name, + sssd_component_type type, + char **_path) +{ + sss_dbus_error error; + + switch (type) { + case SSSD_COMPONENT_MONITOR: + error = sss_dbus_invoke_find(dbus_ctx, SSSD_DBUS_FIND_MONITOR, _path, + DBUS_TYPE_INVALID); + break; + case SSSD_COMPONENT_RESPONDER: + error = sss_dbus_invoke_find(dbus_ctx, SSSD_DBUS_FIND_RESPONDER, _path, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + break; + case SSSD_COMPONENT_BACKEND: + error = sss_dbus_invoke_find(dbus_ctx, SSSD_DBUS_FIND_BACKEND, _path, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + break; + } + + return error; +} + +static sssd_method_error +sssd_component_send_message(sss_dbus_ctx *dbus_ctx, + DBusMessage *message) +{ + sss_dbus_error error; + + error = sss_dbus_send_message(dbus_ctx, message, NULL); + if (error == SSS_DBUS_IO_ERROR) { + if (strcmp(sss_dbus_get_last_io_error_name(dbus_ctx), + DBUS_ERROR_NOT_SUPPORTED) == 0) { + return SSSD_METHOD_ERROR_NOT_SUPPORTED; + } + + return SSSD_METHOD_ERROR_IO; + } else if (error != SSS_DBUS_OK) { + return SSSD_METHOD_ERROR_FAILED; + } + + return SSSD_METHOD_ERROR_OK; +} + +static KUint32 +sssd_component_set_debug_level(const char *method, + const char *name, + sssd_component_type type, + const KUint16* debug_level, + CMPIStatus* _status) +{ + KUint32 result = KUINT32_INIT; + DBusMessage *msg = NULL; + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + dbus_bool_t dbret; + sssd_method_error ret; + char *path = NULL; + uint32_t level; + + KSetStatus(_status, OK); + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + error = sssd_component_find(dbus_ctx, name, type, &path); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + if (!debug_level->exists || debug_level->null) { + KSetStatus(_status, ERR_INVALID_PARAMETER); + ret = SSSD_METHOD_ERROR_FAILED; + goto done; + } + + level = debug_level->value; + + msg = sss_dbus_create_message(path, SSS_DBUS_IFACE_COMPONENTS, method); + if (msg == NULL) { + ret = SSSD_METHOD_ERROR_FAILED; + goto done; + } + + dbret = dbus_message_append_args(msg, DBUS_TYPE_UINT32, &level, + DBUS_TYPE_INVALID); + if (!dbret) { + ret = SSSD_METHOD_ERROR_FAILED; + goto done; + } + + ret = sssd_component_send_message(dbus_ctx, msg); + +done: + if (msg != NULL) { + dbus_message_unref(msg); + } + + sss_dbus_free_string(dbus_ctx, &path); + sss_dbus_free(&dbus_ctx); + + KUint32_Set(&result, ret); + return result; +} + +static KUint32 +sssd_component_set_state(const char *method, + const char *name, + sssd_component_type type, + CMPIStatus* _status) +{ + KUint32 result = KUINT32_INIT; + DBusMessage *msg = NULL; + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + sssd_method_error ret; + char *path = NULL; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + error = sssd_component_find(dbus_ctx, name, type, &path); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + msg = sss_dbus_create_message(path, SSS_DBUS_IFACE_COMPONENTS, method); + if (msg == NULL) { + ret = SSSD_METHOD_ERROR_FAILED; + goto done; + } + + ret = sssd_component_send_message(dbus_ctx, msg); + +done: + if (msg != NULL) { + dbus_message_unref(msg); + } + + sss_dbus_free_string(dbus_ctx, &path); + sss_dbus_free(&dbus_ctx); + + KSetStatus(_status, OK); + KUint32_Set(&result, ret); + return result; +} + +KUint32 +sssd_component_set_debug_permanently(const char *name, + sssd_component_type type, + const KUint16* debug_level, + CMPIStatus* _status) +{ + return sssd_component_set_debug_level("ChangeDebugLevel", + name, type, debug_level, _status); +} + +KUint32 +sssd_component_set_debug_temporarily(const char *name, + sssd_component_type type, + const KUint16* debug_level, + CMPIStatus* _status) +{ + return sssd_component_set_debug_level("ChangeDebugLevelTemporarily", + name, type, debug_level, _status); +} + +KUint32 sssd_component_enable(const char *name, + sssd_component_type type, + CMPIStatus* _status) +{ + return sssd_component_set_state("Enable", name, type, _status); +} + +KUint32 sssd_component_disable(const char *name, + sssd_component_type type, + CMPIStatus* _status) +{ + return sssd_component_set_state("Disable", name, type, _status); +} + +struct sssd_component_attrs { + const char *name; + sss_dbus_bool enabled; + uint32_t debug; +}; + +static sssd_method_error +sssd_component_get_attrs(sss_dbus_attr **attrs, + const char *path, + struct sssd_component_attrs *out) +{ + sss_dbus_error error; + sssd_method_error ret; + + error = sss_dbus_find_attr_as_string(attrs, "name", &out->name); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_bool(attrs, "enabled", &out->enabled); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_uint32(attrs, "debug_level", &out->debug); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + ret = SSSD_METHOD_ERROR_OK; + +done: + return ret; +} + +sssd_method_error +sssd_monitor_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDMonitor *instance) +{ + sss_dbus_attr **attrs = NULL; + sss_dbus_error error; + struct sssd_component_attrs values; + sssd_method_error ret; + + error = sss_dbus_fetch_all_attrs(dbus_ctx, path, + SSS_DBUS_IFACE_COMPONENTS, &attrs); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + ret = sssd_component_get_attrs(attrs, path, &values); + if (ret != SSSD_METHOD_ERROR_OK) { + goto done; + } + + LMI_SSSDMonitor_Init(instance, cb, namespace); + + /* CIM_ManagedElement */ + LMI_SSSDMonitor_Set_Caption(instance, "SSSD Monitor Component"); + LMI_SSSDMonitor_Set_Description(instance, "SSSD Monitor Component"); + LMI_SSSDMonitor_Set_ElementName(instance, values.name); + + /* LMI_SSSDMonitor */ + LMI_SSSDMonitor_Set_Name(instance, values.name); + LMI_SSSDMonitor_Set_Type(instance, SSSD_COMPONENT_MONITOR); + LMI_SSSDMonitor_Set_IsEnabled(instance, values.enabled); + LMI_SSSDMonitor_Set_DebugLevel(instance, values.debug); + + ret = SSSD_METHOD_ERROR_OK; + +done: + sss_dbus_free_attrs(dbus_ctx, &attrs); + return ret; +} + +sssd_method_error +sssd_responder_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDResponder *instance) +{ + sss_dbus_attr **attrs = NULL; + sss_dbus_error error; + struct sssd_component_attrs values; + sssd_method_error ret; + + error = sss_dbus_fetch_all_attrs(dbus_ctx, path, + SSS_DBUS_IFACE_COMPONENTS, &attrs); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + ret = sssd_component_get_attrs(attrs, path, &values); + if (ret != SSSD_METHOD_ERROR_OK) { + goto done; + } + + LMI_SSSDResponder_Init(instance, cb, namespace); + + /* CIM_ManagedElement */ + LMI_SSSDResponder_Set_Caption(instance, "SSSD Responder Component"); + LMI_SSSDResponder_Set_Description(instance, "SSSD Responder Component"); + LMI_SSSDResponder_Set_ElementName(instance, values.name); + + /* LMI_SSSDResponder */ + LMI_SSSDResponder_Set_Name(instance, values.name); + LMI_SSSDResponder_Set_Type(instance, SSSD_COMPONENT_RESPONDER); + LMI_SSSDResponder_Set_IsEnabled(instance, values.enabled); + LMI_SSSDResponder_Set_DebugLevel(instance, values.debug); + + ret = SSSD_METHOD_ERROR_OK; + +done: + sss_dbus_free_attrs(dbus_ctx, &attrs); + return ret; +} + +sssd_method_error +sssd_backend_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDBackend *instance) +{ + sss_dbus_attr **attrs = NULL; + sss_dbus_error error; + struct sssd_component_attrs values; + sssd_method_error ret; + + error = sss_dbus_fetch_all_attrs(dbus_ctx, path, + SSS_DBUS_IFACE_COMPONENTS, &attrs); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + ret = sssd_component_get_attrs(attrs, path, &values); + if (ret != SSSD_METHOD_ERROR_OK) { + goto done; + } + + LMI_SSSDBackend_Init(instance, cb, namespace); + + /* CIM_ManagedElement */ + LMI_SSSDBackend_Set_Caption(instance, "SSSD Responder Component"); + LMI_SSSDBackend_Set_Description(instance, "SSSD Responder Component"); + LMI_SSSDBackend_Set_ElementName(instance, values.name); + + /* LMI_SSSDBackend */ + LMI_SSSDBackend_Set_Name(instance, values.name); + LMI_SSSDBackend_Set_Type(instance, SSSD_COMPONENT_RESPONDER); + LMI_SSSDBackend_Set_IsEnabled(instance, values.enabled); + LMI_SSSDBackend_Set_DebugLevel(instance, values.debug); + + ret = SSSD_METHOD_ERROR_OK; + +done: + sss_dbus_free_attrs(dbus_ctx, &attrs); + return ret; +} |