From adb98a993104ac3e5922d5fad99bd00867233944 Mon Sep 17 00:00:00 2001 From: Pavel Březina Date: Thu, 8 May 2014 12:58:06 +0200 Subject: Implement the schema --- CMakeLists.txt | 1 + src/sssd/CMakeLists.txt | 20 +- src/sssd/LMI_HostedSSSDServiceProvider.c | 21 +- src/sssd/LMI_SSSDAvailableComponentProvider.c | 89 ++++++- src/sssd/LMI_SSSDAvailableDomainProvider.c | 59 ++++- src/sssd/LMI_SSSDBackendDomainProvider.c | 67 ++++- src/sssd/LMI_SSSDBackendProvider.c | 107 ++++++-- src/sssd/LMI_SSSDBackendProviderProvider.c | 96 ++++++- src/sssd/LMI_SSSDDomainProvider.c | 81 +++++- src/sssd/LMI_SSSDDomainSubdomainProvider.c | 152 ++++++++++- src/sssd/LMI_SSSDMonitorProvider.c | 66 +++-- src/sssd/LMI_SSSDProviderProvider.c | 39 ++- src/sssd/LMI_SSSDResponderProvider.c | 107 ++++++-- src/sssd/LMI_SSSDServiceProvider.c | 28 +- src/sssd/LMI_SSSD_utils.c | 63 ----- src/sssd/LMI_SSSD_utils.h | 59 ----- src/sssd/sssd_components.c | 360 ++++++++++++++++++++++++++ src/sssd/sssd_components.h | 78 ++++++ src/sssd/sssd_domains.c | 183 +++++++++++++ src/sssd/sssd_domains.h | 36 +++ src/sssd/utils.c | 44 ++++ src/sssd/utils.h | 73 ++++++ 22 files changed, 1595 insertions(+), 234 deletions(-) delete mode 100644 src/sssd/LMI_SSSD_utils.c delete mode 100644 src/sssd/LMI_SSSD_utils.h create mode 100644 src/sssd/sssd_components.c create mode 100644 src/sssd/sssd_components.h create mode 100644 src/sssd/sssd_domains.c create mode 100644 src/sssd/sssd_domains.h create mode 100644 src/sssd/utils.c create mode 100644 src/sssd/utils.h diff --git a/CMakeLists.txt b/CMakeLists.txt index c30909c..389ee15 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -37,6 +37,7 @@ endif (DEFINED LIB_INSTALL_DIR) include(OpenLMIMacros) find_package(CMPI REQUIRED) find_package(KonkretCMPI REQUIRED) +find_package(PkgConfig REQUIRED) # Add subdirectories add_subdirectory(mof) diff --git a/src/sssd/CMakeLists.txt b/src/sssd/CMakeLists.txt index 542ffef..ffb04c6 100644 --- a/src/sssd/CMakeLists.txt +++ b/src/sssd/CMakeLists.txt @@ -7,11 +7,20 @@ set(REG LMI_${PROVIDER_NAME}.reg) # CFLAGS set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -ggdb3 -O0") +pkg_check_modules(DBUS1 dbus-1 REQUIRED) +pkg_check_modules(SSS_SIMPLEIFP sss_simpleifp REQUIRED) +pkg_check_modules(DHASH dhash REQUIRED) + # Generate headers and sources from the MOF file konkretcmpi_generate(${MOF} CIM_PROVIDERS CIM_HEADERS CIM_CLASSES) # Include directories -include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMPI_INCLUDE_DIR} ..) +include_directories(${CMAKE_CURRENT_BINARY_DIR} + ${CMPI_INCLUDE_DIR} + ${DBUS1_INCLUDE_DIRS} + ${SSS_SIMPLEIFP_INCLUDE_DIR} + ${DHASH_INCLUDE_DIR} + ..) # Source files set(provider_SRCS @@ -28,7 +37,9 @@ set(provider_SRCS LMI_${PROVIDER_NAME}BackendDomainProvider.c LMI_${PROVIDER_NAME}DomainSubdomainProvider.c LMI_Hosted${PROVIDER_NAME}ServiceProvider.c - LMI_${PROVIDER_NAME}_utils.c) + utils.c + sssd_components.c + sssd_domains.c) # Define library add_library(${LIBRARY_NAME} SHARED @@ -38,7 +49,10 @@ add_library(${LIBRARY_NAME} SHARED target_link_libraries(${LIBRARY_NAME} openlmicommon - ${KONKRETCMPI_LIBRARIES}) + ${KONKRETCMPI_LIBRARIES} + ${DBUS1_LIBRARIES} + ${SSS_SIMPLEIFP_LIBRARIES} + ${DHASH_LIBRARIES}) # Create registration file cim_registration(${PROVIDER_NAME} ${LIBRARY_NAME} ${MOF} ${REG_INSTALL_DIR}) diff --git a/src/sssd/LMI_HostedSSSDServiceProvider.c b/src/sssd/LMI_HostedSSSDServiceProvider.c index 918a226..23284d3 100644 --- a/src/sssd/LMI_HostedSSSDServiceProvider.c +++ b/src/sssd/LMI_HostedSSSDServiceProvider.c @@ -1,10 +1,12 @@ #include #include "LMI_HostedSSSDService.h" +#include "utils.h" static const CMPIBroker* _cb; -static void LMI_HostedSSSDServiceInitialize() +static void LMI_HostedSSSDServiceInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_HostedSSSDServiceCleanup( @@ -32,6 +34,19 @@ static CMPIStatus LMI_HostedSSSDServiceEnumInstances( const CMPIObjectPath* cop, const char** properties) { + LMI_SSSDServiceRef ref; + LMI_HostedSSSDService association; + const char *namespace = KNameSpace(cop); + + LMI_SSSDService_Get_Ref(_cb, namespace, &ref); + + LMI_HostedSSSDService_Init(&association, _cb, namespace); + LMI_HostedSSSDService_Set_Dependent(&association, &ref); + LMI_HostedSSSDService_SetObjectPath_Antecedent(&association, + lmi_get_computer_system()); + + KReturnInstance(cr, association); + CMReturn(CMPI_RC_OK); } @@ -187,13 +202,13 @@ CMInstanceMIStub( LMI_HostedSSSDService, LMI_HostedSSSDService, _cb, - LMI_HostedSSSDServiceInitialize()) + LMI_HostedSSSDServiceInitialize(ctx)) CMAssociationMIStub( LMI_HostedSSSDService, LMI_HostedSSSDService, _cb, - LMI_HostedSSSDServiceInitialize()) + LMI_HostedSSSDServiceInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDAvailableComponentProvider.c b/src/sssd/LMI_SSSDAvailableComponentProvider.c index 56083b8..2a7295c 100644 --- a/src/sssd/LMI_SSSDAvailableComponentProvider.c +++ b/src/sssd/LMI_SSSDAvailableComponentProvider.c @@ -1,10 +1,17 @@ #include +#include +#include #include "LMI_SSSDAvailableComponent.h" +#include "LMI_SSSDMonitor.h" +#include "LMI_SSSDResponder.h" +#include "LMI_SSSDBackend.h" +#include "utils.h" static const CMPIBroker* _cb; -static void LMI_SSSDAvailableComponentInitialize() +static void LMI_SSSDAvailableComponentInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDAvailableComponentCleanup( @@ -32,7 +39,81 @@ static CMPIStatus LMI_SSSDAvailableComponentEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + const char *namespace = KNameSpace(cop); + LMI_SSSDAvailableComponent association; + LMI_SSSDServiceRef ref_sssd; + LMI_SSSDMonitorRef ref_monitor; + LMI_SSSDResponderRef ref_responder; + LMI_SSSDBackendRef ref_backend; + CMPIObjectPath *op; + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_attr **attrs = NULL; + sss_dbus_error error; + char **paths = NULL; + const char *name = NULL; + const char *type = NULL; + CMPIStatus cmpi_ret; + CMPIrc ret; + int i; + + LMI_SSSDService_Get_Ref(_cb, namespace, &ref_sssd); + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_COMPONENTS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + for (i = 0; paths[i] != NULL; i++) { + error = sss_dbus_fetch_all_attrs(dbus_ctx, paths[i], + SSS_DBUS_IFACE_COMPONENTS, &attrs); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "name", &name); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "type", &type); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + if (strcmp(type, "monitor") == 0) { + LMI_SSSDMonitorRef_Init(&ref_monitor, _cb, namespace); + LMI_SSSDMonitorRef_Set_Name(&ref_monitor, name); + op = LMI_SSSDMonitorRef_ToObjectPath(&ref_monitor, &cmpi_ret); + } else if (strcmp(type, "responder") == 0) { + LMI_SSSDResponderRef_Init(&ref_responder, _cb, namespace); + LMI_SSSDResponderRef_Set_Name(&ref_responder, name); + op = LMI_SSSDResponderRef_ToObjectPath(&ref_responder, &cmpi_ret); + } else if (strcmp(type, "backend") == 0) { + LMI_SSSDBackendRef_Init(&ref_backend, _cb, namespace); + LMI_SSSDBackendRef_Set_Name(&ref_backend, name); + op = LMI_SSSDBackendRef_ToObjectPath(&ref_backend, &cmpi_ret); + } else { + /* unknown type */ + continue; + } + + if (!KOkay(cmpi_ret)) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + LMI_SSSDAvailableComponent_Init(&association, _cb, namespace); + LMI_SSSDAvailableComponent_Set_SSSD(&association, &ref_sssd); + LMI_SSSDAvailableComponent_SetObjectPath_Component(&association, op); + + KReturnInstance(cr, association); + + sss_dbus_free_attrs(dbus_ctx, &attrs); + } + + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free_attrs(dbus_ctx, &attrs); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDAvailableComponentGetInstance( @@ -187,13 +268,13 @@ CMInstanceMIStub( LMI_SSSDAvailableComponent, LMI_SSSDAvailableComponent, _cb, - LMI_SSSDAvailableComponentInitialize()) + LMI_SSSDAvailableComponentInitialize(ctx)) CMAssociationMIStub( LMI_SSSDAvailableComponent, LMI_SSSDAvailableComponent, _cb, - LMI_SSSDAvailableComponentInitialize()) + LMI_SSSDAvailableComponentInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDAvailableDomainProvider.c b/src/sssd/LMI_SSSDAvailableDomainProvider.c index bba3f6d..af63a84 100644 --- a/src/sssd/LMI_SSSDAvailableDomainProvider.c +++ b/src/sssd/LMI_SSSDAvailableDomainProvider.c @@ -1,10 +1,14 @@ #include +#include +#include #include "LMI_SSSDAvailableDomain.h" +#include "utils.h" static const CMPIBroker* _cb; -static void LMI_SSSDAvailableDomainInitialize() +static void LMI_SSSDAvailableDomainInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDAvailableDomainCleanup( @@ -32,7 +36,54 @@ static CMPIStatus LMI_SSSDAvailableDomainEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + const char *namespace = KNameSpace(cop); + LMI_SSSDAvailableDomain association; + LMI_SSSDServiceRef ref_sssd; + LMI_SSSDDomainRef ref_domain; + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_attr **attrs = NULL; + sss_dbus_error error; + char **paths = NULL; + const char *name = NULL; + CMPIrc ret; + int i; + + LMI_SSSDService_Get_Ref(_cb, namespace, &ref_sssd); + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_DOMAINS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + for (i = 0; paths[i] != NULL; i++) { + error = sss_dbus_fetch_attr(dbus_ctx, paths[i], SSS_DBUS_IFACE_DOMAINS, + "name", &attrs); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "name", &name); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + LMI_SSSDDomainRef_Init(&ref_domain, _cb, namespace); + LMI_SSSDDomainRef_Set_Name(&ref_domain, name); + + LMI_SSSDAvailableDomain_Init(&association, _cb, namespace); + LMI_SSSDAvailableDomain_Set_SSSD(&association, &ref_sssd); + LMI_SSSDAvailableDomain_Set_Domain(&association, &ref_domain); + + KReturnInstance(cr, association); + + sss_dbus_free_attrs(dbus_ctx, &attrs); + } + + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free_attrs(dbus_ctx, &attrs); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDAvailableDomainGetInstance( @@ -187,13 +238,13 @@ CMInstanceMIStub( LMI_SSSDAvailableDomain, LMI_SSSDAvailableDomain, _cb, - LMI_SSSDAvailableDomainInitialize()) + LMI_SSSDAvailableDomainInitialize(ctx)) CMAssociationMIStub( LMI_SSSDAvailableDomain, LMI_SSSDAvailableDomain, _cb, - LMI_SSSDAvailableDomainInitialize()) + LMI_SSSDAvailableDomainInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDBackendDomainProvider.c b/src/sssd/LMI_SSSDBackendDomainProvider.c index e189918..fec48e3 100644 --- a/src/sssd/LMI_SSSDBackendDomainProvider.c +++ b/src/sssd/LMI_SSSDBackendDomainProvider.c @@ -1,10 +1,14 @@ #include +#include +#include #include "LMI_SSSDBackendDomain.h" +#include "utils.h" static const CMPIBroker* _cb; -static void LMI_SSSDBackendDomainInitialize() +static void LMI_SSSDBackendDomainInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDBackendDomainCleanup( @@ -32,7 +36,62 @@ static CMPIStatus LMI_SSSDBackendDomainEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + const char *namespace = KNameSpace(cop); + LMI_SSSDBackendDomain association; + LMI_SSSDBackendRef ref_backend; + LMI_SSSDDomainRef ref_domain; + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_attr **attrs = NULL; + sss_dbus_error error; + char **paths = NULL; + const char *name = NULL; + sss_dbus_bool is_subdomain; + CMPIrc ret; + int i; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_DOMAINS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + for (i = 0; paths[i] != NULL; i++) { + error = sss_dbus_fetch_all_attrs(dbus_ctx, paths[i], + SSS_DBUS_IFACE_DOMAINS, &attrs); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "name", &name); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_find_attr_as_bool(attrs, "subdomain", &is_subdomain); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + if (!is_subdomain) { + LMI_SSSDBackendRef_Init(&ref_backend, _cb, namespace); + LMI_SSSDBackendRef_Set_Name(&ref_backend, name); + + LMI_SSSDDomainRef_Init(&ref_domain, _cb, namespace); + LMI_SSSDDomainRef_Set_Name(&ref_domain, name); + + LMI_SSSDBackendDomain_Init(&association, _cb, namespace); + LMI_SSSDBackendDomain_Set_Backend(&association, &ref_backend); + LMI_SSSDBackendDomain_Set_Domain(&association, &ref_domain); + + + KReturnInstance(cr, association); + } + + sss_dbus_free_attrs(dbus_ctx, &attrs); + } + + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free_attrs(dbus_ctx, &attrs); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDBackendDomainGetInstance( @@ -187,13 +246,13 @@ CMInstanceMIStub( LMI_SSSDBackendDomain, LMI_SSSDBackendDomain, _cb, - LMI_SSSDBackendDomainInitialize()) + LMI_SSSDBackendDomainInitialize(ctx)) CMAssociationMIStub( LMI_SSSDBackendDomain, LMI_SSSDBackendDomain, _cb, - LMI_SSSDBackendDomainInitialize()) + LMI_SSSDBackendDomainInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDBackendProvider.c b/src/sssd/LMI_SSSDBackendProvider.c index fbef1af..7c390af 100644 --- a/src/sssd/LMI_SSSDBackendProvider.c +++ b/src/sssd/LMI_SSSDBackendProvider.c @@ -1,10 +1,14 @@ #include +#include #include "LMI_SSSDBackend.h" +#include "utils.h" +#include "sssd_components.h" static const CMPIBroker* _cb = NULL; -static void LMI_SSSDBackendInitialize() +static void LMI_SSSDBackendInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDBackendCleanup( @@ -32,7 +36,39 @@ static CMPIStatus LMI_SSSDBackendEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + LMI_SSSDBackend instance; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + char **paths = NULL; + sssd_method_error mret; + CMPIrc ret; + int i; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_BACKENDS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + for (i = 0; paths[i] != NULL; i++) { + mret = sssd_backend_set_instance(dbus_ctx, paths[i], _cb, namespace, + &instance); + if (mret != SSSD_METHOD_ERROR_OK) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + KReturnInstance(cr, instance); + } + + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDBackendGetInstance( @@ -42,8 +78,41 @@ static CMPIStatus LMI_SSSDBackendGetInstance( const CMPIObjectPath* cop, const char** properties) { - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); + LMI_SSSDBackend instance; + LMI_SSSDBackendRef ref; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + const char *name = NULL; + char *path = NULL; + sssd_method_error mret; + CMPIrc ret; + + LMI_SSSDBackendRef_InitFromObjectPath(&ref, _cb, cop); + name = ref.Name.chars; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_find(dbus_ctx, SSSD_DBUS_FIND_BACKEND, &path, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + mret = sssd_backend_set_instance(dbus_ctx, path, _cb, namespace, + &instance); + if (mret != SSSD_METHOD_ERROR_OK) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + KReturnInstance(cr, instance); + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string(dbus_ctx, &path); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDBackendCreateInstance( @@ -91,7 +160,7 @@ CMInstanceMIStub( LMI_SSSDBackend, LMI_SSSDBackend, _cb, - LMI_SSSDBackendInitialize()) + LMI_SSSDBackendInitialize(ctx)) static CMPIStatus LMI_SSSDBackendMethodCleanup( CMPIMethodMI* mi, @@ -118,7 +187,7 @@ CMMethodMIStub( LMI_SSSDBackend, LMI_SSSDBackend, _cb, - LMI_SSSDBackendInitialize()) + LMI_SSSDBackendInitialize(ctx)) KUint32 LMI_SSSDBackend_SetDebugLevelPermanently( const CMPIBroker* cb, @@ -128,10 +197,9 @@ KUint32 LMI_SSSDBackend_SetDebugLevelPermanently( const KUint16* debug_level, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_set_debug_permanently(self->Name.chars, + SSSD_COMPONENT_BACKEND, + debug_level, status); } KUint32 LMI_SSSDBackend_SetDebugLevelTemporarily( @@ -142,10 +210,9 @@ KUint32 LMI_SSSDBackend_SetDebugLevelTemporarily( const KUint16* debug_level, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_set_debug_temporarily(self->Name.chars, + SSSD_COMPONENT_BACKEND, + debug_level, status); } KUint32 LMI_SSSDBackend_Enable( @@ -155,10 +222,8 @@ KUint32 LMI_SSSDBackend_Enable( const LMI_SSSDBackendRef* self, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_enable(self->Name.chars, SSSD_COMPONENT_BACKEND, + status); } KUint32 LMI_SSSDBackend_Disable( @@ -168,10 +233,8 @@ KUint32 LMI_SSSDBackend_Disable( const LMI_SSSDBackendRef* self, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_disable(self->Name.chars, SSSD_COMPONENT_BACKEND, + status); } KONKRET_REGISTRATION( diff --git a/src/sssd/LMI_SSSDBackendProviderProvider.c b/src/sssd/LMI_SSSDBackendProviderProvider.c index 9e25834..0ecf0b6 100644 --- a/src/sssd/LMI_SSSDBackendProviderProvider.c +++ b/src/sssd/LMI_SSSDBackendProviderProvider.c @@ -1,10 +1,15 @@ +#include +#include #include +#include #include "LMI_SSSDBackendProvider.h" +#include "utils.h" static const CMPIBroker* _cb; -static void LMI_SSSDBackendProviderInitialize() +static void LMI_SSSDBackendProviderInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDBackendProviderCleanup( @@ -32,7 +37,90 @@ static CMPIStatus LMI_SSSDBackendProviderEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + LMI_SSSDBackendProvider association; + LMI_SSSDBackendRef ref_backend; + LMI_SSSDProviderRef ref_provider; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_attr **attrs = NULL; + sss_dbus_error error; + char **paths = NULL; + const char *backend_name = NULL; + const char * const *providers = NULL; + char *provider_type = NULL; + char *provider_module = NULL; + unsigned int num_providers; + CMPIrc ret; + unsigned int j; + int i; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_BACKENDS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + for (i = 0; paths[i] != NULL; i++) { + error = sss_dbus_fetch_all_attrs(dbus_ctx, paths[i], + SSS_DBUS_IFACE_COMPONENTS, &attrs); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + error = sss_dbus_find_attr_as_string(attrs, "name", &backend_name); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + error = sss_dbus_find_attr_as_string_array(attrs, "providers", + &num_providers, &providers); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + if (num_providers == 0) { + sss_dbus_free_attrs(dbus_ctx, &attrs); + continue; + } + + LMI_SSSDBackendRef_Init(&ref_backend, _cb, namespace); + LMI_SSSDBackendRef_Set_Name(&ref_backend, backend_name); + + for (j = 0; j < num_providers; j++) { + /* provider is a key=value pair */ + provider_type = strdup(providers[j]); + if (provider_type == NULL) { + goto done; + } + + provider_module = strchr(provider_type, '='); + if (provider_module == NULL) { + provider_module = ""; + } else { + *provider_module = '\0'; + provider_module++; + } + + LMI_SSSDProviderRef_Init(&ref_provider, _cb, namespace); + LMI_SSSDProviderRef_Set_Type(&ref_provider, provider_type); + LMI_SSSDProviderRef_Set_Module(&ref_provider, provider_module); + free(provider_type); + + LMI_SSSDBackendProvider_Init(&association, _cb, namespace); + LMI_SSSDBackendProvider_Set_Backend(&association, &ref_backend); + LMI_SSSDBackendProvider_Set_Provider(&association, &ref_provider); + + KReturnInstance(cr, association); + } + + sss_dbus_free_attrs(dbus_ctx, &attrs); + } + + ret = CMPI_RC_OK; + +done: + if (attrs != NULL) { + sss_dbus_free_attrs(dbus_ctx, &attrs); + } + + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDBackendProviderGetInstance( @@ -187,13 +275,13 @@ CMInstanceMIStub( LMI_SSSDBackendProvider, LMI_SSSDBackendProvider, _cb, - LMI_SSSDBackendProviderInitialize()) + LMI_SSSDBackendProviderInitialize(ctx)) CMAssociationMIStub( LMI_SSSDBackendProvider, LMI_SSSDBackendProvider, _cb, - LMI_SSSDBackendProviderInitialize()) + LMI_SSSDBackendProviderInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDDomainProvider.c b/src/sssd/LMI_SSSDDomainProvider.c index 1c4d036..a6e0c4b 100644 --- a/src/sssd/LMI_SSSDDomainProvider.c +++ b/src/sssd/LMI_SSSDDomainProvider.c @@ -1,10 +1,14 @@ #include +#include #include "LMI_SSSDDomain.h" +#include "utils.h" +#include "sssd_domains.h" static const CMPIBroker* _cb = NULL; -static void LMI_SSSDDomainInitialize() +static void LMI_SSSDDomainInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDDomainCleanup( @@ -32,7 +36,39 @@ static CMPIStatus LMI_SSSDDomainEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + LMI_SSSDDomain instance; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + char **paths = NULL; + sssd_method_error mret; + CMPIrc ret; + int i; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_DOMAINS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + for (i = 0; paths[i] != NULL; i++) { + mret = sssd_domain_set_instance(dbus_ctx, paths[i], _cb, namespace, + &instance); + if (mret != SSSD_METHOD_ERROR_OK) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + KReturnInstance(cr, instance); + } + + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDDomainGetInstance( @@ -42,8 +78,41 @@ static CMPIStatus LMI_SSSDDomainGetInstance( const CMPIObjectPath* cop, const char** properties) { - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); + LMI_SSSDDomain instance; + LMI_SSSDDomainRef ref; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + const char *name = NULL; + char *path = NULL; + sssd_method_error mret; + CMPIrc ret; + + LMI_SSSDDomainRef_InitFromObjectPath(&ref, _cb, cop); + name = ref.Name.chars; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_find(dbus_ctx, SSSD_DBUS_FIND_DOMAIN, &path, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + mret = sssd_domain_set_instance(dbus_ctx, path, _cb, namespace, + &instance); + if (mret != SSSD_METHOD_ERROR_OK) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + KReturnInstance(cr, instance); + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string(dbus_ctx, &path); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDDomainCreateInstance( @@ -91,7 +160,7 @@ CMInstanceMIStub( LMI_SSSDDomain, LMI_SSSDDomain, _cb, - LMI_SSSDDomainInitialize()) + LMI_SSSDDomainInitialize(ctx)) static CMPIStatus LMI_SSSDDomainMethodCleanup( CMPIMethodMI* mi, @@ -118,7 +187,7 @@ CMMethodMIStub( LMI_SSSDDomain, LMI_SSSDDomain, _cb, - LMI_SSSDDomainInitialize()) + LMI_SSSDDomainInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDDomainSubdomainProvider.c b/src/sssd/LMI_SSSDDomainSubdomainProvider.c index fb53dc4..1094b9b 100644 --- a/src/sssd/LMI_SSSDDomainSubdomainProvider.c +++ b/src/sssd/LMI_SSSDDomainSubdomainProvider.c @@ -1,10 +1,15 @@ +#include #include +#include +#include #include "LMI_SSSDDomainSubdomain.h" +#include "utils.h" static const CMPIBroker* _cb; -static void LMI_SSSDDomainSubdomainInitialize() +static void LMI_SSSDDomainSubdomainInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDDomainSubdomainCleanup( @@ -25,14 +30,143 @@ static CMPIStatus LMI_SSSDDomainSubdomainEnumInstanceNames( _cb, mi, cc, cr, cop); } -static CMPIStatus LMI_SSSDDomainSubdomainEnumInstances( +static CMPIStatus LMI_SSSDDomainSubdomainEnumInstances( CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) { - CMReturn(CMPI_RC_OK); + const char *namespace = KNameSpace(cop); + LMI_SSSDDomainSubdomain association; + LMI_SSSDDomainRef ref_parent; + LMI_SSSDDomainRef ref_sub; + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_attr **subdomain = NULL; + sss_dbus_attr **parent = NULL; + sss_dbus_error error; + char **paths = NULL; + const char *parent_path = NULL; + const char *parent_name = NULL; + const char *sub_name = NULL; + sss_dbus_bool is_subdomain; + hash_table_t *table = NULL; + hash_key_t key; + hash_value_t value; + int hret; + CMPIrc ret; + int i; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_DOMAINS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + hret = hash_create(10, &table, hash_delete_cb, NULL); + if (hret != HASH_SUCCESS) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + for (i = 0; paths[i] != NULL; i++) { + /* fetch information about potential subdomain */ + error = sss_dbus_fetch_all_attrs(dbus_ctx, paths[i], + SSS_DBUS_IFACE_DOMAINS, &subdomain); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_find_attr_as_bool(subdomain, "subdomain", + &is_subdomain); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + /* if it is not subdomain just continue with the next one */ + if (!is_subdomain) { + sss_dbus_free_attrs(dbus_ctx, &subdomain); + continue; + } + + /* get subdomain name and parent */ + error = sss_dbus_find_attr_as_string(subdomain, "name", + &sub_name); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_find_attr_as_string(subdomain, "parent_domain", + &parent_path); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + /* first try to lookup the parent in the hash table */ + key.type = HASH_KEY_STRING; + key.str = strdup(parent_path); + if (key.str == NULL) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + hret = hash_lookup(table, &key, &value); + if (hret == HASH_SUCCESS) { + parent_name = (const char*)value.ptr; + free(key.str); + } else { + /* fetch the parent and store it in the hash table */ + error = sss_dbus_fetch_attr(dbus_ctx, parent_path, + SSS_DBUS_IFACE_DOMAINS, "name", + &parent); + + error = sss_dbus_find_attr_as_string(parent, "name", + &parent_name); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + value.type = HASH_VALUE_PTR; + value.ptr = strdup(parent_name); + if (value.ptr == NULL) { + free(key.str); + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + hret = hash_enter(table, &key, &value); + if (hret != HASH_SUCCESS) { + free(key.str); + free(value.ptr); + } + } + + /* create association */ + LMI_SSSDDomainRef_Init(&ref_parent, _cb, namespace); + LMI_SSSDDomainRef_Set_Name(&ref_parent, parent_name); + + LMI_SSSDDomainRef_Init(&ref_sub, _cb, namespace); + LMI_SSSDDomainRef_Set_Name(&ref_sub, sub_name); + + LMI_SSSDDomainSubdomain_Init(&association, _cb, namespace); + LMI_SSSDDomainSubdomain_Set_ParentDomain(&association, &ref_parent); + LMI_SSSDDomainSubdomain_Set_Subdomain(&association, &ref_sub); + + KReturnInstance(cr, association); + + sss_dbus_free_attrs(dbus_ctx, &subdomain); + sss_dbus_free_attrs(dbus_ctx, &parent); + } + + ret = CMPI_RC_OK; + +done: + if (table != NULL) { + hash_destroy(table); + } + + if (subdomain != NULL) { + sss_dbus_free_attrs(dbus_ctx, &subdomain); + } + + if (parent != NULL) { + sss_dbus_free_attrs(dbus_ctx, &parent); + } + + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDDomainSubdomainGetInstance( @@ -187,13 +321,13 @@ CMInstanceMIStub( LMI_SSSDDomainSubdomain, LMI_SSSDDomainSubdomain, _cb, - LMI_SSSDDomainSubdomainInitialize()) + LMI_SSSDDomainSubdomainInitialize(ctx)) CMAssociationMIStub( LMI_SSSDDomainSubdomain, LMI_SSSDDomainSubdomain, _cb, - LMI_SSSDDomainSubdomainInitialize()) + LMI_SSSDDomainSubdomainInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDMonitorProvider.c b/src/sssd/LMI_SSSDMonitorProvider.c index 5581fbd..cba3dda 100644 --- a/src/sssd/LMI_SSSDMonitorProvider.c +++ b/src/sssd/LMI_SSSDMonitorProvider.c @@ -1,10 +1,15 @@ #include +#include +#include #include "LMI_SSSDMonitor.h" +#include "utils.h" +#include "sssd_components.h" static const CMPIBroker* _cb = NULL; -static void LMI_SSSDMonitorInitialize() +static void LMI_SSSDMonitorInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDMonitorCleanup( @@ -32,7 +37,34 @@ static CMPIStatus LMI_SSSDMonitorEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + LMI_SSSDMonitor instance; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + char *path = NULL; + sssd_method_error mret; + CMPIrc ret; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_find(dbus_ctx, "Monitor", &path, DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + mret = sssd_monitor_set_instance(dbus_ctx, path, _cb, namespace, + &instance); + if (mret != SSSD_METHOD_ERROR_OK) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + KReturnInstance(cr, instance); + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string(dbus_ctx, &path); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDMonitorGetInstance( @@ -91,7 +123,7 @@ CMInstanceMIStub( LMI_SSSDMonitor, LMI_SSSDMonitor, _cb, - LMI_SSSDMonitorInitialize()) + LMI_SSSDMonitorInitialize(ctx)) static CMPIStatus LMI_SSSDMonitorMethodCleanup( CMPIMethodMI* mi, @@ -118,7 +150,7 @@ CMMethodMIStub( LMI_SSSDMonitor, LMI_SSSDMonitor, _cb, - LMI_SSSDMonitorInitialize()) + LMI_SSSDMonitorInitialize(ctx)) KUint32 LMI_SSSDMonitor_SetDebugLevelPermanently( const CMPIBroker* cb, @@ -128,10 +160,9 @@ KUint32 LMI_SSSDMonitor_SetDebugLevelPermanently( const KUint16* debug_level, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_set_debug_permanently(self->Name.chars, + SSSD_COMPONENT_MONITOR, + debug_level, status); } KUint32 LMI_SSSDMonitor_SetDebugLevelTemporarily( @@ -142,10 +173,9 @@ KUint32 LMI_SSSDMonitor_SetDebugLevelTemporarily( const KUint16* debug_level, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_set_debug_temporarily(self->Name.chars, + SSSD_COMPONENT_MONITOR, + debug_level, status); } KUint32 LMI_SSSDMonitor_Enable( @@ -155,10 +185,8 @@ KUint32 LMI_SSSDMonitor_Enable( const LMI_SSSDMonitorRef* self, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_enable(self->Name.chars, SSSD_COMPONENT_MONITOR, + status); } KUint32 LMI_SSSDMonitor_Disable( @@ -168,10 +196,8 @@ KUint32 LMI_SSSDMonitor_Disable( const LMI_SSSDMonitorRef* self, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_disable(self->Name.chars, SSSD_COMPONENT_MONITOR, + status); } KONKRET_REGISTRATION( diff --git a/src/sssd/LMI_SSSDProviderProvider.c b/src/sssd/LMI_SSSDProviderProvider.c index 29397a2..57d738b 100644 --- a/src/sssd/LMI_SSSDProviderProvider.c +++ b/src/sssd/LMI_SSSDProviderProvider.c @@ -1,11 +1,13 @@ #include #include "LMI_SSSDProvider.h" +#include "utils.h" static const CMPIBroker* _cb = NULL; -static void LMI_SSSDProviderInitialize() -{ -} +static void LMI_SSSDProviderInitialize(const CMPIContext *ctx) + { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); + } static CMPIStatus LMI_SSSDProviderCleanup( CMPIInstanceMI* mi, @@ -32,7 +34,9 @@ static CMPIStatus LMI_SSSDProviderEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + /* no instances to enumerate */ + + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); } static CMPIStatus LMI_SSSDProviderGetInstance( @@ -42,8 +46,27 @@ static CMPIStatus LMI_SSSDProviderGetInstance( const CMPIObjectPath* cop, const char** properties) { - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); + const char *namespace = KNameSpace(cop); + LMI_SSSDProvider instance; + LMI_SSSDProviderRef ref; + CMPIStatus ret; + + ret = LMI_SSSDProviderRef_InitFromObjectPath(&ref, _cb, cop); + if (!KOkay(ret)) { + return ret; + } + + LMI_SSSDProvider_Init(&instance, _cb, namespace); + LMI_SSSDProvider_Set_Type(&instance, ref.Type.chars); + LMI_SSSDProvider_Set_Module(&instance, ref.Module.chars); + + LMI_SSSDProvider_Set_Caption(&instance, "SSSD Provider Module"); + LMI_SSSDProvider_Set_Description(&instance, "SSSD Provider Module"); + LMI_SSSDProvider_Set_ElementName(&instance, ref.Type.chars); + + KReturnInstance(cr, instance); + + CMReturn(CMPI_RC_OK); } static CMPIStatus LMI_SSSDProviderCreateInstance( @@ -91,7 +114,7 @@ CMInstanceMIStub( LMI_SSSDProvider, LMI_SSSDProvider, _cb, - LMI_SSSDProviderInitialize()) + LMI_SSSDProviderInitialize(ctx)) static CMPIStatus LMI_SSSDProviderMethodCleanup( CMPIMethodMI* mi, @@ -118,7 +141,7 @@ CMMethodMIStub( LMI_SSSDProvider, LMI_SSSDProvider, _cb, - LMI_SSSDProviderInitialize()) + LMI_SSSDProviderInitialize(ctx)) KONKRET_REGISTRATION( "root/cimv2", diff --git a/src/sssd/LMI_SSSDResponderProvider.c b/src/sssd/LMI_SSSDResponderProvider.c index b370bc5..1cc9d17 100644 --- a/src/sssd/LMI_SSSDResponderProvider.c +++ b/src/sssd/LMI_SSSDResponderProvider.c @@ -1,10 +1,14 @@ #include +#include #include "LMI_SSSDResponder.h" +#include "utils.h" +#include "sssd_components.h" static const CMPIBroker* _cb = NULL; -static void LMI_SSSDResponderInitialize() +static void LMI_SSSDResponderInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDResponderCleanup( @@ -32,7 +36,39 @@ static CMPIStatus LMI_SSSDResponderEnumInstances( const CMPIObjectPath* cop, const char** properties) { - CMReturn(CMPI_RC_OK); + LMI_SSSDResponder instance; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + char **paths = NULL; + sssd_method_error mret; + CMPIrc ret; + int i; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_list(dbus_ctx, SSSD_DBUS_LIST_RESPONDERS, &paths, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + for (i = 0; paths[i] != NULL; i++) { + mret = sssd_responder_set_instance(dbus_ctx, paths[i], _cb, namespace, + &instance); + if (mret != SSSD_METHOD_ERROR_OK) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + KReturnInstance(cr, instance); + } + + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string_array(dbus_ctx, &paths); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDResponderGetInstance( @@ -42,8 +78,41 @@ static CMPIStatus LMI_SSSDResponderGetInstance( const CMPIObjectPath* cop, const char** properties) { - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); + LMI_SSSDResponder instance; + LMI_SSSDResponderRef ref; + const char *namespace = KNameSpace(cop); + sss_dbus_ctx *dbus_ctx = NULL; + sss_dbus_error error; + const char *name = NULL; + char *path = NULL; + sssd_method_error mret; + CMPIrc ret; + + LMI_SSSDResponderRef_InitFromObjectPath(&ref, _cb, cop); + name = ref.Name.chars; + + error = sss_dbus_init(&dbus_ctx); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + error = sss_dbus_invoke_find(dbus_ctx, SSSD_DBUS_FIND_RESPONDER, &path, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + check_sss_dbus_error(error, ret, CMPI_RC_ERR_FAILED, done); + + mret = sssd_responder_set_instance(dbus_ctx, path, _cb, namespace, + &instance); + if (mret != SSSD_METHOD_ERROR_OK) { + ret = CMPI_RC_ERR_FAILED; + goto done; + } + + KReturnInstance(cr, instance); + ret = CMPI_RC_OK; + +done: + sss_dbus_free_string(dbus_ctx, &path); + sss_dbus_free(&dbus_ctx); + CMReturn(ret); } static CMPIStatus LMI_SSSDResponderCreateInstance( @@ -91,7 +160,7 @@ CMInstanceMIStub( LMI_SSSDResponder, LMI_SSSDResponder, _cb, - LMI_SSSDResponderInitialize()) + LMI_SSSDResponderInitialize(ctx)) static CMPIStatus LMI_SSSDResponderMethodCleanup( CMPIMethodMI* mi, @@ -118,7 +187,7 @@ CMMethodMIStub( LMI_SSSDResponder, LMI_SSSDResponder, _cb, - LMI_SSSDResponderInitialize()) + LMI_SSSDResponderInitialize(ctx)) KUint32 LMI_SSSDResponder_SetDebugLevelPermanently( const CMPIBroker* cb, @@ -128,10 +197,9 @@ KUint32 LMI_SSSDResponder_SetDebugLevelPermanently( const KUint16* debug_level, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_set_debug_permanently(self->Name.chars, + SSSD_COMPONENT_RESPONDER, + debug_level, status); } KUint32 LMI_SSSDResponder_SetDebugLevelTemporarily( @@ -142,10 +210,9 @@ KUint32 LMI_SSSDResponder_SetDebugLevelTemporarily( const KUint16* debug_level, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_set_debug_temporarily(self->Name.chars, + SSSD_COMPONENT_RESPONDER, + debug_level, status); } KUint32 LMI_SSSDResponder_Enable( @@ -155,10 +222,8 @@ KUint32 LMI_SSSDResponder_Enable( const LMI_SSSDResponderRef* self, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_enable(self->Name.chars, SSSD_COMPONENT_RESPONDER, + status); } KUint32 LMI_SSSDResponder_Disable( @@ -168,10 +233,8 @@ KUint32 LMI_SSSDResponder_Disable( const LMI_SSSDResponderRef* self, CMPIStatus* status) { - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; + return sssd_component_disable(self->Name.chars, SSSD_COMPONENT_RESPONDER, + status); } KONKRET_REGISTRATION( diff --git a/src/sssd/LMI_SSSDServiceProvider.c b/src/sssd/LMI_SSSDServiceProvider.c index d79647e..47836ab 100644 --- a/src/sssd/LMI_SSSDServiceProvider.c +++ b/src/sssd/LMI_SSSDServiceProvider.c @@ -1,10 +1,12 @@ #include #include "LMI_SSSDService.h" +#include "utils.h" static const CMPIBroker* _cb = NULL; -static void LMI_SSSDServiceInitialize() +static void LMI_SSSDServiceInitialize(const CMPIContext *ctx) { + lmi_init(PROVIDER_NAME, _cb, ctx, NULL); } static CMPIStatus LMI_SSSDServiceCleanup( @@ -32,6 +34,26 @@ static CMPIStatus LMI_SSSDServiceEnumInstances( const CMPIObjectPath* cop, const char** properties) { + LMI_SSSDService lmi_sssd; + const char *namespace = KNameSpace(cop); + const char *hostname = lmi_get_system_name(); + + /* LMI_SSSDService is a singleton. */ + + LMI_SSSDService_Init(&lmi_sssd, _cb, namespace); + LMI_SSSDService_Set_Name(&lmi_sssd, SERVICE_NAME); + LMI_SSSDService_Set_SystemName(&lmi_sssd, hostname); + LMI_SSSDService_Set_CreationClassName(&lmi_sssd, LMI_SSSDService_ClassName); + LMI_SSSDService_Set_SystemCreationClassName(&lmi_sssd, + lmi_get_system_creation_class_name()); + + LMI_SSSDService_Set_Caption(&lmi_sssd, SERVICE_NAME); + LMI_SSSDService_Set_Description(&lmi_sssd, + "System Security Services Daemon"); + LMI_SSSDService_Set_ElementName(&lmi_sssd, SERVICE_NAME); + + KReturnInstance(cr, lmi_sssd); + CMReturn(CMPI_RC_OK); } @@ -91,7 +113,7 @@ CMInstanceMIStub( LMI_SSSDService, LMI_SSSDService, _cb, - LMI_SSSDServiceInitialize()) + LMI_SSSDServiceInitialize(ctx)) static CMPIStatus LMI_SSSDServiceMethodCleanup( CMPIMethodMI* mi, @@ -118,7 +140,7 @@ CMMethodMIStub( LMI_SSSDService, LMI_SSSDService, _cb, - LMI_SSSDServiceInitialize()) + LMI_SSSDServiceInitialize(ctx)) KUint32 LMI_SSSDService_RequestStateChange( const CMPIBroker* cb, diff --git a/src/sssd/LMI_SSSD_utils.c b/src/sssd/LMI_SSSD_utils.c deleted file mode 100644 index adf77e4..0000000 --- a/src/sssd/LMI_SSSD_utils.c +++ /dev/null @@ -1,63 +0,0 @@ -/* - Authors: - Pavel Březina - - 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 . -*/ - -#include -#include "LMI_SSSD_utils.h" - -void LMI_SSSDService_Get_Ref(const CMPIBroker *cb, - const char *namespace, - LMI_SSSDServiceRef *ref) -{ - const char *hostname = lmi_get_system_name(); - const char *sysclass = lmi_get_system_creation_class_name(); - - LMI_SSSDServiceRef_Init(ref, cb, namespace); - LMI_SSSDServiceRef_Set_Name(ref, SERVICE_NAME); - LMI_SSSDServiceRef_Set_SystemName(ref, hostname); - LMI_SSSDServiceRef_Set_CreationClassName(ref, LMI_SSSDService_ClassName); - LMI_SSSDServiceRef_Set_SystemCreationClassName(ref, sysclass); -} - -void LMI_SSSDResponder_Get_Ref(const CMPIBroker *cb, - const char *namespace, - const char *name, - LMI_SSSDResponderRef *ref) -{ - LMI_SSSDResponderRef_Init(ref, cb, namespace); - LMI_SSSDResponderRef_Set_Name(ref, name); -} - -void LMI_SSSDDomain_Get_Ref(const CMPIBroker *cb, - const char *namespace, - const char *name, - LMI_SSSDDomainRef *ref) -{ - LMI_SSSDDomainRef_Init(ref, cb, namespace); - LMI_SSSDDomainRef_Set_Name(ref, name); -} - -void LMI_SSSDSubdomain_Get_Ref(const CMPIBroker *cb, - const char *namespace, - const char *name, - LMI_SSSDSubdomainRef *ref) -{ - LMI_SSSDSubdomainRef_Init(ref, cb, namespace); - LMI_SSSDSubdomainRef_Set_Name(ref, name); -} diff --git a/src/sssd/LMI_SSSD_utils.h b/src/sssd/LMI_SSSD_utils.h deleted file mode 100644 index 3fb403b..0000000 --- a/src/sssd/LMI_SSSD_utils.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - Authors: - Pavel Březina - - 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 . -*/ - -#ifndef LMI_SSSD_UTILS_H_ -#define LMI_SSSD_UTILS_H_ - -#include -#include "LMI_SSSDService.h" -#include "LMI_SSSDResponder.h" -#include "LMI_SSSDDomain.h" -#include "LMI_SSSDSubdomain.h" - -#define PROVIDER_NAME "sssd" -#define SERVICE_NAME "OpenLMI SSSD Service" - -#ifndef true - #define true 1 -#endif -#ifndef false - #define false 0 -#endif - -void LMI_SSSDService_Get_Ref(const CMPIBroker *cb, - const char *namespace, - LMI_SSSDServiceRef *ref); - -void LMI_SSSDResponder_Get_Ref(const CMPIBroker *cb, - const char *namespace, - const char *name, - LMI_SSSDResponderRef *ref); - -void LMI_SSSDDomain_Get_Ref(const CMPIBroker *cb, - const char *namespace, - const char *name, - LMI_SSSDDomainRef *ref); - -void LMI_SSSDSubdomain_Get_Ref(const CMPIBroker *cb, - const char *namespace, - const char *name, - LMI_SSSDSubdomainRef *ref); - -#endif /* LMI_SSSD_UTILS_H_ */ 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 + + 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 . +*/ + +#include +#include +#include +#include +#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; +} diff --git a/src/sssd/sssd_components.h b/src/sssd/sssd_components.h new file mode 100644 index 0000000..d501366 --- /dev/null +++ b/src/sssd/sssd_components.h @@ -0,0 +1,78 @@ +/* + Authors: + Pavel Březina + + 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 . +*/ + +#ifndef SSSD_COMPONENTS_H_ +#define SSSD_COMPONENTS_H_ + +#include +#include +#include "LMI_SSSDMonitor.h" +#include "LMI_SSSDResponder.h" +#include "LMI_SSSDBackend.h" +#include "utils.h" + +typedef enum sssd_component_type { + SSSD_COMPONENT_MONITOR = 0, + SSSD_COMPONENT_RESPONDER, + SSSD_COMPONENT_BACKEND +} sssd_component_type; + +KUint32 +sssd_component_set_debug_permanently(const char *name, + sssd_component_type type, + const KUint16* debug_level, + CMPIStatus* _status); + +KUint32 +sssd_component_set_debug_temporarily(const char *name, + sssd_component_type type, + const KUint16* debug_level, + CMPIStatus* _status); + +KUint32 sssd_component_enable(const char *name, + sssd_component_type type, + CMPIStatus* _status); + +KUint32 sssd_component_disable(const char *name, + sssd_component_type type, + CMPIStatus* _status); + +sssd_method_error +sssd_monitor_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDMonitor *instance); + +sssd_method_error +sssd_responder_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDResponder *instance); + +sssd_method_error +sssd_backend_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDBackend *instance); + +#endif /* SSSD_COMPONENTS_H_ */ diff --git a/src/sssd/sssd_domains.c b/src/sssd/sssd_domains.c new file mode 100644 index 0000000..b60ca0c --- /dev/null +++ b/src/sssd/sssd_domains.c @@ -0,0 +1,183 @@ +/* + Authors: + Pavel Březina + + 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 . +*/ + +#include +#include +#include +#include "sssd_domains.h" +#include "utils.h" + +struct sssd_domain_attrs { + const char *name; + const char *provider; + const char * const *primary_servers; + unsigned int num_primary; + const char * const *backup_servers; + unsigned int num_backup; + uint32_t min_id; + uint32_t max_id; + const char *realm; + const char *forest; + const char *login_format; + const char *fqn_format; + sss_dbus_bool enumerable; + sss_dbus_bool use_fqn; + sss_dbus_bool subdomain; + const char *parent_domain; +}; + +static sssd_method_error +sssd_domain_get_attrs(sss_dbus_attr **attrs, + const char *path, + struct sssd_domain_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_string(attrs, "provider", &out->provider); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_string_array(attrs, "primary_servers", + &out->num_primary, &out->primary_servers); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_string_array(attrs, "backup_servers", + &out->num_backup, &out->backup_servers); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_uint32(attrs, "min_id", &out->min_id); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_uint32(attrs, "max_id", &out->max_id); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "realm", &out->realm); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "forest", &out->forest); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "login_format", + &out->login_format); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "fully_qualified_name_format", + &out->fqn_format); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_bool(attrs, "enumerable", &out->enumerable); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_bool(attrs, "use_fully_qualified_names", + &out->use_fqn); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_bool(attrs, "subdomain", &out->subdomain); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + error = sss_dbus_find_attr_as_string(attrs, "parent_domain", + &out->parent_domain); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + ret = SSSD_METHOD_ERROR_OK; + +done: + return ret; +} + +sssd_method_error +sssd_domain_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDDomain *instance) +{ + sss_dbus_attr **attrs = NULL; + sss_dbus_attr **parent = NULL; + sss_dbus_error error; + struct sssd_domain_attrs values; + sssd_method_error ret; + int i; + + error = sss_dbus_fetch_all_attrs(dbus_ctx, path, + SSS_DBUS_IFACE_DOMAINS, &attrs); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + ret = sssd_domain_get_attrs(attrs, path, &values); + if (ret != SSSD_METHOD_ERROR_OK) { + goto done; + } + + LMI_SSSDDomain_Init(instance, cb, namespace); + + /* CIM_ManagedElement */ + LMI_SSSDDomain_Set_Caption(instance, "SSSD Domain"); + LMI_SSSDDomain_Set_Description(instance, "SSSD Domain"); + LMI_SSSDDomain_Set_ElementName(instance, values.name); + + /* LMI_SSSDDomain */ + LMI_SSSDDomain_Set_Name(instance, values.name); + LMI_SSSDDomain_Set_Provider(instance, values.provider); + LMI_SSSDDomain_Set_MinId(instance, values.min_id); + LMI_SSSDDomain_Set_MaxId(instance, values.max_id); + LMI_SSSDDomain_Set_Realm(instance, values.realm); + LMI_SSSDDomain_Set_Forest(instance, values.forest); + LMI_SSSDDomain_Set_LoginFormat(instance, values.login_format); + LMI_SSSDDomain_Set_FullyQualifiedNameFormat(instance, values.fqn_format); + LMI_SSSDDomain_Set_Enumerate(instance, values.enumerable); + LMI_SSSDDomain_Set_UseFullyQualifiedNames(instance, values.use_fqn); + LMI_SSSDDomain_Set_IsSubdomain(instance, values.subdomain); + + LMI_SSSDDomain_Init_PrimaryServers(instance, values.num_primary); + for (i = 0; i < values.num_primary; i++) { + LMI_SSSDDomain_Set_PrimaryServers(instance, i, + values.primary_servers[i]); + } + + LMI_SSSDDomain_Init_BackupServers(instance, values.num_backup); + for (i = 0; i < values.num_backup; i++) { + LMI_SSSDDomain_Set_BackupServers(instance, i, + values.backup_servers[i]); + } + + if (strcmp(values.parent_domain, "/") == 0) { + LMI_SSSDDomain_Null_ParentDomain(instance); + } else { + error = sss_dbus_fetch_attr(dbus_ctx, values.parent_domain, + SSS_DBUS_IFACE_DOMAINS, "name", &parent); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_IO, done); + + error = sss_dbus_find_attr_as_string(parent, "name", + &values.parent_domain); + check_sss_dbus_error(error, ret, SSSD_METHOD_ERROR_FAILED, done); + + LMI_SSSDDomain_Set_ParentDomain(instance, values.parent_domain); + } + + ret = SSSD_METHOD_ERROR_OK; + +done: + sss_dbus_free_attrs(dbus_ctx, &attrs); + sss_dbus_free_attrs(dbus_ctx, &parent); + return ret; +} diff --git a/src/sssd/sssd_domains.h b/src/sssd/sssd_domains.h new file mode 100644 index 0000000..0067701 --- /dev/null +++ b/src/sssd/sssd_domains.h @@ -0,0 +1,36 @@ +/* + Authors: + Pavel Březina + + 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 . +*/ + +#ifndef SSSD_DOMAINS_H_ +#define SSSD_DOMAINS_H_ + +#include +#include +#include "LMI_SSSDDomain.h" +#include "utils.h" + +sssd_method_error +sssd_domain_set_instance(sss_dbus_ctx *dbus_ctx, + const char *path, + const CMPIBroker* cb, + const char *namespace, + LMI_SSSDDomain *_instance); + +#endif /* SSSD_DOMAINS_H_ */ diff --git a/src/sssd/utils.c b/src/sssd/utils.c new file mode 100644 index 0000000..23bfeff --- /dev/null +++ b/src/sssd/utils.c @@ -0,0 +1,44 @@ +/* + Authors: + Pavel Březina + + 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 . +*/ + +#include +#include +#include "utils.h" + +void LMI_SSSDService_Get_Ref(const CMPIBroker *cb, + const char *namespace, + LMI_SSSDServiceRef *ref) +{ + const char *hostname = lmi_get_system_name(); + const char *sysclass = lmi_get_system_creation_class_name(); + + LMI_SSSDServiceRef_Init(ref, cb, namespace); + LMI_SSSDServiceRef_Set_Name(ref, SERVICE_NAME); + LMI_SSSDServiceRef_Set_SystemName(ref, hostname); + LMI_SSSDServiceRef_Set_CreationClassName(ref, LMI_SSSDService_ClassName); + LMI_SSSDServiceRef_Set_SystemCreationClassName(ref, sysclass); +} + +void hash_delete_cb(hash_entry_t *item, + hash_destroy_enum type, + void *pvt) +{ + free(item->value.ptr); +} diff --git a/src/sssd/utils.h b/src/sssd/utils.h new file mode 100644 index 0000000..640d4ce --- /dev/null +++ b/src/sssd/utils.h @@ -0,0 +1,73 @@ +/* + Authors: + Pavel Březina + + 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 . +*/ + +#ifndef LMI_SSSD_UTILS_H_ +#define LMI_SSSD_UTILS_H_ + +#include +#include +#include "LMI_SSSDService.h" +#include "LMI_SSSDMonitor.h" +#include "LMI_SSSDResponder.h" +#include "LMI_SSSDDomain.h" + +#define PROVIDER_NAME "sssd" +#define SERVICE_NAME "OpenLMI SSSD Service" + +/* SSSD D-Bus methods */ +#define SSSD_DBUS_LIST_COMPONENTS "Components" +#define SSSD_DBUS_LIST_RESPONDERS "Responders" +#define SSSD_DBUS_LIST_BACKENDS "Backends" +#define SSSD_DBUS_LIST_DOMAINS "Domains" +#define SSSD_DBUS_FIND_MONITOR "Monitor" +#define SSSD_DBUS_FIND_RESPONDER "ResponderByName" +#define SSSD_DBUS_FIND_BACKEND "BackendByName" +#define SSSD_DBUS_FIND_DOMAIN "DomainByName" + +typedef enum { + SSSD_METHOD_ERROR_OK, + SSSD_METHOD_ERROR_FAILED, + SSSD_METHOD_ERROR_NOT_SUPPORTED, + SSSD_METHOD_ERROR_IO +} sssd_method_error; + +#ifndef true + #define true 1 +#endif +#ifndef false + #define false 0 +#endif + +#define check_sss_dbus_error(error, ret, val, label) do { \ +if (error != SSS_DBUS_OK) { \ + ret = val; \ + goto label; \ +} \ +} while (0) + +void LMI_SSSDService_Get_Ref(const CMPIBroker *cb, + const char *namespace, + LMI_SSSDServiceRef *ref); + +void hash_delete_cb(hash_entry_t *item, + hash_destroy_enum type, + void *pvt); + +#endif /* LMI_SSSD_UTILS_H_ */ -- cgit