summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorPavel Březina <pbrezina@redhat.com>2014-05-08 12:58:06 +0200
committerPavel Březina <pbrezina@redhat.com>2014-05-14 09:37:52 +0200
commitadb98a993104ac3e5922d5fad99bd00867233944 (patch)
tree1f1db6230e1a4ec9cc32cf4c49c3ad40197b89c6
parentee6c9177f161239f4420f5679001330e477061ec (diff)
downloadopenlmi_sssd-wip.tar.gz
openlmi_sssd-wip.tar.xz
openlmi_sssd-wip.zip
Implement the schemawip
-rw-r--r--CMakeLists.txt1
-rw-r--r--src/sssd/CMakeLists.txt20
-rw-r--r--src/sssd/LMI_HostedSSSDServiceProvider.c21
-rw-r--r--src/sssd/LMI_SSSDAvailableComponentProvider.c89
-rw-r--r--src/sssd/LMI_SSSDAvailableDomainProvider.c59
-rw-r--r--src/sssd/LMI_SSSDBackendDomainProvider.c67
-rw-r--r--src/sssd/LMI_SSSDBackendProvider.c107
-rw-r--r--src/sssd/LMI_SSSDBackendProviderProvider.c96
-rw-r--r--src/sssd/LMI_SSSDDomainProvider.c81
-rw-r--r--src/sssd/LMI_SSSDDomainSubdomainProvider.c152
-rw-r--r--src/sssd/LMI_SSSDMonitorProvider.c66
-rw-r--r--src/sssd/LMI_SSSDProviderProvider.c39
-rw-r--r--src/sssd/LMI_SSSDResponderProvider.c107
-rw-r--r--src/sssd/LMI_SSSDServiceProvider.c28
-rw-r--r--src/sssd/sssd_components.c360
-rw-r--r--src/sssd/sssd_components.h78
-rw-r--r--src/sssd/sssd_domains.c183
-rw-r--r--src/sssd/sssd_domains.h36
-rw-r--r--src/sssd/utils.c (renamed from src/sssd/LMI_SSSD_utils.c)31
-rw-r--r--src/sssd/utils.h (renamed from src/sssd/LMI_SSSD_utils.h)44
20 files changed, 1513 insertions, 152 deletions
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 <konkret/konkret.h>
#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 <konkret/konkret.h>
+#include <string.h>
+#include <sss_dbus.h>
#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 <konkret/konkret.h>
+#include <dbus/dbus.h>
+#include <sss_dbus.h>
#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 <konkret/konkret.h>
+#include <dbus/dbus.h>
+#include <sss_dbus.h>
#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 <konkret/konkret.h>
+#include <sss_dbus.h>
#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 <stdlib.h>
+#include <string.h>
#include <konkret/konkret.h>
+#include <sss_dbus.h>
#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 <konkret/konkret.h>
+#include <sss_dbus.h>
#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 <stdlib.h>
#include <konkret/konkret.h>
+#include <sss_dbus.h>
+#include <dhash.h>
#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 <konkret/konkret.h>
+#include <dbus/dbus.h>
+#include <sss_dbus.h>
#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 <konkret/konkret.h>
#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 <konkret/konkret.h>
+#include <sss_dbus.h>
#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 <konkret/konkret.h>
#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/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;
+}
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 <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/>.
+*/
+
+#ifndef SSSD_COMPONENTS_H_
+#define SSSD_COMPONENTS_H_
+
+#include <sss_dbus.h>
+#include <stdint.h>
+#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 <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 <konkret/konkret.h>
+#include <dbus/dbus.h>
+#include <sss_dbus.h>
+#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 <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/>.
+*/
+
+#ifndef SSSD_DOMAINS_H_
+#define SSSD_DOMAINS_H_
+
+#include <sss_dbus.h>
+#include <stdint.h>
+#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/LMI_SSSD_utils.c b/src/sssd/utils.c
index adf77e4..23bfeff 100644
--- a/src/sssd/LMI_SSSD_utils.c
+++ b/src/sssd/utils.c
@@ -18,8 +18,9 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <stdlib.h>
#include <openlmi/openlmi.h>
-#include "LMI_SSSD_utils.h"
+#include "utils.h"
void LMI_SSSDService_Get_Ref(const CMPIBroker *cb,
const char *namespace,
@@ -35,29 +36,9 @@ void LMI_SSSDService_Get_Ref(const CMPIBroker *cb,
LMI_SSSDServiceRef_Set_SystemCreationClassName(ref, sysclass);
}
-void LMI_SSSDResponder_Get_Ref(const CMPIBroker *cb,
- const char *namespace,
- const char *name,
- LMI_SSSDResponderRef *ref)
+void hash_delete_cb(hash_entry_t *item,
+ hash_destroy_enum type,
+ void *pvt)
{
- 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);
+ free(item->value.ptr);
}
diff --git a/src/sssd/LMI_SSSD_utils.h b/src/sssd/utils.h
index 3fb403b..640d4ce 100644
--- a/src/sssd/LMI_SSSD_utils.h
+++ b/src/sssd/utils.h
@@ -22,14 +22,32 @@
#define LMI_SSSD_UTILS_H_
#include <openlmi/openlmi.h>
+#include <dhash.h>
#include "LMI_SSSDService.h"
+#include "LMI_SSSDMonitor.h"
#include "LMI_SSSDResponder.h"
#include "LMI_SSSDDomain.h"
-#include "LMI_SSSDSubdomain.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
@@ -37,23 +55,19 @@
#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 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);
+void hash_delete_cb(hash_entry_t *item,
+ hash_destroy_enum type,
+ void *pvt);
#endif /* LMI_SSSD_UTILS_H_ */