celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [1/5] celix git commit: CELIX-354: Fixes concerning high impact issues reported by coverity
Date Wed, 20 Apr 2016 16:31:09 GMT
Repository: celix
Updated Branches:
  refs/heads/develop 3a3795429 -> 9653f0683


http://git-wip-us.apache.org/repos/asf/celix/blob/777b8311/remote_services/topology_manager/private/src/activator.c
----------------------------------------------------------------------
diff --git a/remote_services/topology_manager/private/src/activator.c b/remote_services/topology_manager/private/src/activator.c
index a6ee750..1ec4fed 100644
--- a/remote_services/topology_manager/private/src/activator.c
+++ b/remote_services/topology_manager/private/src/activator.c
@@ -44,24 +44,24 @@
 #include "topology_manager.h"
 
 struct activator {
-    bundle_context_pt context;
+	bundle_context_pt context;
 
-    topology_manager_pt manager;
+	topology_manager_pt manager;
 
-    service_tracker_pt endpointListenerTracker;
-    service_tracker_pt remoteServiceAdminTracker;
-    service_listener_pt serviceListener;
+	service_tracker_pt endpointListenerTracker;
+	service_tracker_pt remoteServiceAdminTracker;
+	service_listener_pt serviceListener;
 
-    endpoint_listener_pt endpointListener;
-    service_registration_pt endpointListenerService;
+	endpoint_listener_pt endpointListener;
+	service_registration_pt endpointListenerService;
 
-    listener_hook_service_pt hookService;
-    service_registration_pt hook;
+	listener_hook_service_pt hookService;
+	service_registration_pt hook;
 
-    tm_scope_service_pt	scopeService;
-    service_registration_pt scopeReg;
+	tm_scope_service_pt	scopeService;
+	service_registration_pt scopeReg;
 
-    log_helper_pt loghelper;
+	log_helper_pt loghelper;
 };
 
 
@@ -70,216 +70,220 @@ static celix_status_t bundleActivator_createRSATracker(struct activator *activat
 static celix_status_t bundleActivator_createServiceListener(struct activator *activator, service_listener_pt *listener);
 
 celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
-    celix_status_t status = CELIX_SUCCESS;
-    struct activator *activator = NULL;
-    void *scope;
-
-    activator = calloc(1, sizeof(struct activator));
-
-    if (!activator) {
-        return CELIX_ENOMEM;
-    }
-
-    activator->context = context;
-    activator->endpointListenerService = NULL;
-    activator->endpointListenerTracker = NULL;
-    activator->hook = NULL;
-    activator->manager = NULL;
-    activator->remoteServiceAdminTracker = NULL;
-    activator->serviceListener = NULL;
-    activator->scopeService = calloc(1, sizeof(*(activator->scopeService)));
-    if (activator->scopeService == NULL)
-    {
-    	free(activator);
-    	return CELIX_ENOMEM;
-    }
-
-    activator->scopeService->addExportScope = tm_addExportScope;
-    activator->scopeService->removeExportScope = tm_removeExportScope;
-    activator->scopeService->addImportScope = tm_addImportScope;
-    activator->scopeService->removeImportScope = tm_removeImportScope;
-    activator->scopeReg = NULL; // explicitly needed, otherwise exception
-
-    logHelper_create(context, &activator->loghelper);
-    logHelper_start(activator->loghelper);
-
-    status = topologyManager_create(context, activator->loghelper, &activator->manager, &scope);
-    activator->scopeService->handle = scope;
-
-    if (status == CELIX_SUCCESS) {
-        status = bundleActivator_createEPLTracker(activator, &activator->endpointListenerTracker);
-        if (status == CELIX_SUCCESS) {
-            status = bundleActivator_createRSATracker(activator, &activator->remoteServiceAdminTracker);
-            if (status == CELIX_SUCCESS) {
-                status = bundleActivator_createServiceListener(activator, &activator->serviceListener);
-                if (status == CELIX_SUCCESS) {
-                	*userData = activator;
-                }
-            }
-        }
-    }
-
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+	struct activator *activator = NULL;
+	void *scope;
+
+	activator = calloc(1, sizeof(struct activator));
+
+	if (!activator) {
+		return CELIX_ENOMEM;
+	}
+
+	activator->context = context;
+	activator->endpointListenerService = NULL;
+	activator->endpointListenerTracker = NULL;
+	activator->hook = NULL;
+	activator->manager = NULL;
+	activator->remoteServiceAdminTracker = NULL;
+	activator->serviceListener = NULL;
+	activator->scopeService = calloc(1, sizeof(*(activator->scopeService)));
+	if (activator->scopeService == NULL)
+	{
+		free(activator);
+		return CELIX_ENOMEM;
+	}
+
+	activator->scopeService->addExportScope = tm_addExportScope;
+	activator->scopeService->removeExportScope = tm_removeExportScope;
+	activator->scopeService->addImportScope = tm_addImportScope;
+	activator->scopeService->removeImportScope = tm_removeImportScope;
+	activator->scopeReg = NULL; // explicitly needed, otherwise exception
+
+	logHelper_create(context, &activator->loghelper);
+	logHelper_start(activator->loghelper);
+
+	status = topologyManager_create(context, activator->loghelper, &activator->manager, &scope);
+	activator->scopeService->handle = scope;
+
+	if (status == CELIX_SUCCESS) {
+		status = bundleActivator_createEPLTracker(activator, &activator->endpointListenerTracker);
+		if (status == CELIX_SUCCESS) {
+			status = bundleActivator_createRSATracker(activator, &activator->remoteServiceAdminTracker);
+			if (status == CELIX_SUCCESS) {
+				status = bundleActivator_createServiceListener(activator, &activator->serviceListener);
+				if (status == CELIX_SUCCESS) {
+					*userData = activator;
+				}
+			}
+		}
+	}
+
+	if(status != CELIX_SUCCESS){
+		bundleActivator_destroy(activator,context);
+	}
+
+	return status;
 }
 
 static celix_status_t bundleActivator_createEPLTracker(struct activator *activator, service_tracker_pt *tracker) {
-    celix_status_t status;
+	celix_status_t status;
 
-    service_tracker_customizer_pt customizer = NULL;
+	service_tracker_customizer_pt customizer = NULL;
 
-    status = serviceTrackerCustomizer_create(activator->manager, topologyManager_endpointListenerAdding, topologyManager_endpointListenerAdded, topologyManager_endpointListenerModified,
-            topologyManager_endpointListenerRemoved, &customizer);
+	status = serviceTrackerCustomizer_create(activator->manager, topologyManager_endpointListenerAdding, topologyManager_endpointListenerAdded, topologyManager_endpointListenerModified,
+			topologyManager_endpointListenerRemoved, &customizer);
 
-    if (status == CELIX_SUCCESS) {
-        status = serviceTracker_create(activator->context, (char *) OSGI_ENDPOINT_LISTENER_SERVICE, customizer, tracker);
-    }
+	if (status == CELIX_SUCCESS) {
+		status = serviceTracker_create(activator->context, (char *) OSGI_ENDPOINT_LISTENER_SERVICE, customizer, tracker);
+	}
 
-    return status;
+	return status;
 }
 
 static celix_status_t bundleActivator_createRSATracker(struct activator *activator, service_tracker_pt *tracker) {
-    celix_status_t status;
+	celix_status_t status;
 
-    service_tracker_customizer_pt customizer = NULL;
+	service_tracker_customizer_pt customizer = NULL;
 
-    status = serviceTrackerCustomizer_create(activator->manager, topologyManager_rsaAdding, topologyManager_rsaAdded, topologyManager_rsaModified, topologyManager_rsaRemoved, &customizer);
+	status = serviceTrackerCustomizer_create(activator->manager, topologyManager_rsaAdding, topologyManager_rsaAdded, topologyManager_rsaModified, topologyManager_rsaRemoved, &customizer);
 
-    if (status == CELIX_SUCCESS) {
-        status = serviceTracker_create(activator->context, OSGI_RSA_REMOTE_SERVICE_ADMIN, customizer, tracker);
-    }
+	if (status == CELIX_SUCCESS) {
+		status = serviceTracker_create(activator->context, OSGI_RSA_REMOTE_SERVICE_ADMIN, customizer, tracker);
+	}
 
-    return status;
+	return status;
 }
 
 static celix_status_t bundleActivator_createServiceListener(struct activator *activator, service_listener_pt *listener) {
-    celix_status_t status = CELIX_SUCCESS;
+	celix_status_t status = CELIX_SUCCESS;
 
-    *listener = malloc(sizeof(**listener));
-    if (!*listener) {
-        return CELIX_ENOMEM;
-    }
+	*listener = malloc(sizeof(**listener));
+	if (!*listener) {
+		return CELIX_ENOMEM;
+	}
 
-    (*listener)->handle = activator->manager;
-    (*listener)->serviceChanged = topologyManager_serviceChanged;
+	(*listener)->handle = activator->manager;
+	(*listener)->serviceChanged = topologyManager_serviceChanged;
 
-    return status;
+	return status;
 }
 
 celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
-    celix_status_t status;
-    struct activator *activator = userData;
+	celix_status_t status;
+	struct activator *activator = userData;
 
-    endpoint_listener_pt endpointListener = malloc(sizeof(*endpointListener));
-    endpointListener->handle = activator->manager;
-    endpointListener->endpointAdded = topologyManager_addImportedService;
-    endpointListener->endpointRemoved = topologyManager_removeImportedService;
-    activator->endpointListener = endpointListener;
+	endpoint_listener_pt endpointListener = malloc(sizeof(*endpointListener));
+	endpointListener->handle = activator->manager;
+	endpointListener->endpointAdded = topologyManager_addImportedService;
+	endpointListener->endpointRemoved = topologyManager_removeImportedService;
+	activator->endpointListener = endpointListener;
 
-    char *uuid = NULL;
-    status = bundleContext_getProperty(activator->context, (char *) OSGI_FRAMEWORK_FRAMEWORK_UUID, &uuid);
-    if (!uuid) {
-        logHelper_log(activator->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: no framework UUID defined?!");
-        return CELIX_ILLEGAL_STATE;
-    }
+	char *uuid = NULL;
+	status = bundleContext_getProperty(activator->context, (char *) OSGI_FRAMEWORK_FRAMEWORK_UUID, &uuid);
+	if (!uuid) {
+		logHelper_log(activator->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: no framework UUID defined?!");
+		return CELIX_ILLEGAL_STATE;
+	}
 
-    size_t len = 14 + strlen(OSGI_FRAMEWORK_OBJECTCLASS) + strlen(OSGI_RSA_ENDPOINT_FRAMEWORK_UUID) + strlen(uuid);
-    char *scope = malloc(len);
-    if (!scope) {
-        return CELIX_ENOMEM;
-    }
+	size_t len = 14 + strlen(OSGI_FRAMEWORK_OBJECTCLASS) + strlen(OSGI_RSA_ENDPOINT_FRAMEWORK_UUID) + strlen(uuid);
+	char *scope = malloc(len);
+	if (!scope) {
+		return CELIX_ENOMEM;
+	}
 
-    snprintf(scope, len, "(&(%s=*)(!(%s=%s)))", OSGI_FRAMEWORK_OBJECTCLASS, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, uuid);
+	snprintf(scope, len, "(&(%s=*)(!(%s=%s)))", OSGI_FRAMEWORK_OBJECTCLASS, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, uuid);
 
-    logHelper_log(activator->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: endpoint listener scope is %s", scope);
+	logHelper_log(activator->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: endpoint listener scope is %s", scope);
 
-    properties_pt props = properties_create();
-    properties_set(props, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, scope);
+	properties_pt props = properties_create();
+	properties_set(props, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, scope);
 
-    // We can release the scope, as properties_set makes a copy of the key & value...
-    free(scope);
+	// We can release the scope, as properties_set makes a copy of the key & value...
+	free(scope);
 
-    bundleContext_registerService(context, (char *) OSGI_ENDPOINT_LISTENER_SERVICE, endpointListener, props, &activator->endpointListenerService);
+	bundleContext_registerService(context, (char *) OSGI_ENDPOINT_LISTENER_SERVICE, endpointListener, props, &activator->endpointListenerService);
 
-    listener_hook_service_pt hookService = malloc(sizeof(*hookService));
-    hookService->handle = activator->manager;
-    hookService->added = topologyManager_listenerAdded;
-    hookService->removed = topologyManager_listenerRemoved;
-    activator->hookService = hookService;
+	listener_hook_service_pt hookService = malloc(sizeof(*hookService));
+	hookService->handle = activator->manager;
+	hookService->added = topologyManager_listenerAdded;
+	hookService->removed = topologyManager_listenerRemoved;
+	activator->hookService = hookService;
 
-    bundleContext_registerService(context, (char *) OSGI_FRAMEWORK_LISTENER_HOOK_SERVICE_NAME, hookService, NULL, &activator->hook);
-    bundleContext_addServiceListener(context, activator->serviceListener, "(service.exported.interfaces=*)");
+	bundleContext_registerService(context, (char *) OSGI_FRAMEWORK_LISTENER_HOOK_SERVICE_NAME, hookService, NULL, &activator->hook);
+	bundleContext_addServiceListener(context, activator->serviceListener, "(service.exported.interfaces=*)");
 
-    if (status == CELIX_SUCCESS) {
-        serviceTracker_open(activator->remoteServiceAdminTracker);
-    }
+	if (status == CELIX_SUCCESS) {
+		serviceTracker_open(activator->remoteServiceAdminTracker);
+	}
 
-    if (status == CELIX_SUCCESS) {
-        status = serviceTracker_open(activator->endpointListenerTracker);
-    }
+	if (status == CELIX_SUCCESS) {
+		status = serviceTracker_open(activator->endpointListenerTracker);
+	}
 
 	bundleContext_registerService(context, (char *) TOPOLOGYMANAGER_SCOPE_SERVICE, activator->scopeService, NULL, &activator->scopeReg);
 
-    array_list_pt references = NULL;
-    bundleContext_getServiceReferences(context, NULL, "(service.exported.interfaces=*)", &references);
-    int i;
-    for (i = 0; i < arrayList_size(references); i++) {
-        service_reference_pt reference = arrayList_get(references, i);
-        char *serviceId = NULL;
-        status = CELIX_DO_IF(status, serviceReference_getProperty(reference, (char *)OSGI_FRAMEWORK_SERVICE_ID, &serviceId));
+	array_list_pt references = NULL;
+	bundleContext_getServiceReferences(context, NULL, "(service.exported.interfaces=*)", &references);
+	int i;
+	for (i = 0; i < arrayList_size(references); i++) {
+		service_reference_pt reference = arrayList_get(references, i);
+		char *serviceId = NULL;
+		status = CELIX_DO_IF(status, serviceReference_getProperty(reference, (char *)OSGI_FRAMEWORK_SERVICE_ID, &serviceId));
 
-        CELIX_DO_IF(status, topologyManager_addExportedService(activator->manager, reference, serviceId));
-    }
-    arrayList_destroy(references);
+		CELIX_DO_IF(status, topologyManager_addExportedService(activator->manager, reference, serviceId));
+	}
+	arrayList_destroy(references);
 
-    return status;
+	return status;
 }
 
 celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
-    celix_status_t status = CELIX_SUCCESS;
-    struct activator *activator = userData;
+	celix_status_t status = CELIX_SUCCESS;
+	struct activator *activator = userData;
 
-    if (serviceTracker_close(activator->remoteServiceAdminTracker) == CELIX_SUCCESS) {
-        serviceTracker_destroy(activator->remoteServiceAdminTracker);
-    }
+	if (serviceTracker_close(activator->remoteServiceAdminTracker) == CELIX_SUCCESS) {
+		serviceTracker_destroy(activator->remoteServiceAdminTracker);
+	}
 
-    if (serviceTracker_close(activator->endpointListenerTracker) == CELIX_SUCCESS) {
-        serviceTracker_destroy(activator->endpointListenerTracker);
-    }
+	if (serviceTracker_close(activator->endpointListenerTracker) == CELIX_SUCCESS) {
+		serviceTracker_destroy(activator->endpointListenerTracker);
+	}
 
-    bundleContext_removeServiceListener(context, activator->serviceListener);
-    free(activator->serviceListener);
+	bundleContext_removeServiceListener(context, activator->serviceListener);
+	free(activator->serviceListener);
 
-    serviceRegistration_unregister(activator->hook);
-    free(activator->hookService);
+	serviceRegistration_unregister(activator->hook);
+	free(activator->hookService);
 
-    serviceRegistration_unregister(activator->endpointListenerService);
-    free(activator->endpointListener);
+	serviceRegistration_unregister(activator->endpointListenerService);
+	free(activator->endpointListener);
 
-    serviceRegistration_unregister(activator->scopeReg);
+	serviceRegistration_unregister(activator->scopeReg);
 
-    topologyManager_closeImports(activator->manager);
+	topologyManager_closeImports(activator->manager);
 
-    return status;
+	return status;
 }
 
 celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
-    celix_status_t status = CELIX_SUCCESS;
+	celix_status_t status = CELIX_SUCCESS;
 
-    struct activator *activator = userData;
-    if (!activator || !activator->manager) {
-        status = CELIX_BUNDLE_EXCEPTION;
-    } else {
-        logHelper_stop(activator->loghelper);
-        logHelper_destroy(&activator->loghelper);
+	struct activator *activator = userData;
+	if (!activator || !activator->manager) {
+		status = CELIX_BUNDLE_EXCEPTION;
+	} else {
+		logHelper_stop(activator->loghelper);
+		logHelper_destroy(&activator->loghelper);
 
-        status = topologyManager_destroy(activator->manager);
+		status = topologyManager_destroy(activator->manager);
 
-        if (activator->scopeService) {
-        	free(activator->scopeService);
-        }
+		if (activator->scopeService) {
+			free(activator->scopeService);
+		}
 
-        free(activator);
-    }
+		free(activator);
+	}
 
-    return status;
+	return status;
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/777b8311/remote_services/topology_manager/private/src/topology_manager.c
----------------------------------------------------------------------
diff --git a/remote_services/topology_manager/private/src/topology_manager.c b/remote_services/topology_manager/private/src/topology_manager.c
index a116383..16afdc0 100644
--- a/remote_services/topology_manager/private/src/topology_manager.c
+++ b/remote_services/topology_manager/private/src/topology_manager.c
@@ -46,23 +46,23 @@
 #include "hash_map.h"
 
 struct topology_manager {
-    bundle_context_pt context;
+	bundle_context_pt context;
 
-    celix_thread_mutex_t rsaListLock;
-    array_list_pt rsaList;
+	celix_thread_mutex_t rsaListLock;
+	array_list_pt rsaList;
 
-    celix_thread_mutex_t listenerListLock;
-    hash_map_pt listenerList;
+	celix_thread_mutex_t listenerListLock;
+	hash_map_pt listenerList;
 
-    celix_thread_mutex_t exportedServicesLock;
-    hash_map_pt exportedServices;
+	celix_thread_mutex_t exportedServicesLock;
+	hash_map_pt exportedServices;
 
-    celix_thread_mutex_t importedServicesLock;
-    hash_map_pt importedServices;
+	celix_thread_mutex_t importedServicesLock;
+	hash_map_pt importedServices;
 
-    scope_pt scope;
+	scope_pt scope;
 
-    log_helper_pt loghelper;
+	log_helper_pt loghelper;
 };
 
 celix_status_t topologyManager_exportScopeChanged(void *handle, char *service_name);
@@ -71,899 +71,906 @@ celix_status_t topologyManager_notifyListenersEndpointAdded(topology_manager_pt
 celix_status_t topologyManager_notifyListenersEndpointRemoved(topology_manager_pt manager, remote_service_admin_service_pt rsa, export_registration_pt export);
 
 celix_status_t topologyManager_create(bundle_context_pt context, log_helper_pt logHelper, topology_manager_pt *manager, void **scope) {
-    celix_status_t status = CELIX_SUCCESS;
+	celix_status_t status = CELIX_SUCCESS;
 
-    *manager = calloc(1, sizeof(**manager));
+	*manager = calloc(1, sizeof(**manager));
 
-    if (!*manager) {
-        return CELIX_ENOMEM;
-    }
+	if (!*manager) {
+		return CELIX_ENOMEM;
+	}
 
-    (*manager)->context = context;
-    (*manager)->rsaList = NULL;
+	(*manager)->context = context;
+	(*manager)->rsaList = NULL;
 
-    arrayList_create(&(*manager)->rsaList);
+	arrayList_create(&(*manager)->rsaList);
 
-    celixThreadMutex_create(&(*manager)->rsaListLock, NULL);
-    celixThreadMutex_create(&(*manager)->exportedServicesLock, NULL);
-    celixThreadMutex_create(&(*manager)->importedServicesLock, NULL);
-    celixThreadMutex_create(&(*manager)->listenerListLock, NULL);
+	celixThreadMutex_create(&(*manager)->rsaListLock, NULL);
+	celixThreadMutex_create(&(*manager)->exportedServicesLock, NULL);
+	celixThreadMutex_create(&(*manager)->importedServicesLock, NULL);
+	celixThreadMutex_create(&(*manager)->listenerListLock, NULL);
 
-    (*manager)->listenerList = hashMap_create(serviceReference_hashCode, NULL, serviceReference_equals2, NULL);
-    (*manager)->exportedServices = hashMap_create(serviceReference_hashCode, NULL, serviceReference_equals2, NULL);
-    (*manager)->importedServices = hashMap_create(NULL, NULL, NULL, NULL);
+	(*manager)->listenerList = hashMap_create(serviceReference_hashCode, NULL, serviceReference_equals2, NULL);
+	(*manager)->exportedServices = hashMap_create(serviceReference_hashCode, NULL, serviceReference_equals2, NULL);
+	(*manager)->importedServices = hashMap_create(NULL, NULL, NULL, NULL);
 
-    status = scope_scopeCreate(*manager, &(*manager)->scope);
-    scope_setExportScopeChangedCallback((*manager)->scope, topologyManager_exportScopeChanged);
-    scope_setImportScopeChangedCallback((*manager)->scope, topologyManager_importScopeChanged);
-    *scope = (*manager)->scope;
+	status = scope_scopeCreate(*manager, &(*manager)->scope);
+	scope_setExportScopeChangedCallback((*manager)->scope, topologyManager_exportScopeChanged);
+	scope_setImportScopeChangedCallback((*manager)->scope, topologyManager_importScopeChanged);
+	*scope = (*manager)->scope;
 
-    (*manager)->loghelper = logHelper;
+	(*manager)->loghelper = logHelper;
 
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_destroy(topology_manager_pt manager) {
-    celix_status_t status = CELIX_SUCCESS;
+	celix_status_t status = CELIX_SUCCESS;
 
-    celixThreadMutex_lock(&manager->listenerListLock);
-    hashMap_destroy(manager->listenerList, false, false);
+	celixThreadMutex_lock(&manager->listenerListLock);
+	hashMap_destroy(manager->listenerList, false, false);
 
-    celixThreadMutex_unlock(&manager->listenerListLock);
-    celixThreadMutex_destroy(&manager->listenerListLock);
+	celixThreadMutex_unlock(&manager->listenerListLock);
+	celixThreadMutex_destroy(&manager->listenerListLock);
 
-    celixThreadMutex_lock(&manager->rsaListLock);
+	celixThreadMutex_lock(&manager->rsaListLock);
 
-    arrayList_destroy(manager->rsaList);
+	arrayList_destroy(manager->rsaList);
 
-    celixThreadMutex_unlock(&manager->rsaListLock);
-    celixThreadMutex_destroy(&manager->rsaListLock);
+	celixThreadMutex_unlock(&manager->rsaListLock);
+	celixThreadMutex_destroy(&manager->rsaListLock);
 
-    celixThreadMutex_lock(&manager->exportedServicesLock);
+	celixThreadMutex_lock(&manager->exportedServicesLock);
 
-    hashMap_destroy(manager->exportedServices, false, false);
+	hashMap_destroy(manager->exportedServices, false, false);
 
-    celixThreadMutex_unlock(&manager->exportedServicesLock);
-    celixThreadMutex_destroy(&manager->exportedServicesLock);
+	celixThreadMutex_unlock(&manager->exportedServicesLock);
+	celixThreadMutex_destroy(&manager->exportedServicesLock);
 
-    celixThreadMutex_lock(&manager->importedServicesLock);
+	celixThreadMutex_lock(&manager->importedServicesLock);
 
-    hashMap_destroy(manager->importedServices, false, false);
+	hashMap_destroy(manager->importedServices, false, false);
 
-    celixThreadMutex_unlock(&manager->importedServicesLock);
-    celixThreadMutex_destroy(&manager->importedServicesLock);
+	celixThreadMutex_unlock(&manager->importedServicesLock);
+	celixThreadMutex_destroy(&manager->importedServicesLock);
 
-    scope_scopeDestroy(manager->scope);
-    free(manager);
+	scope_scopeDestroy(manager->scope);
+	free(manager);
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_closeImports(topology_manager_pt manager) {
-    celix_status_t status;
+	celix_status_t status;
 
-    status = celixThreadMutex_lock(&manager->importedServicesLock);
+	status = celixThreadMutex_lock(&manager->importedServicesLock);
 
-    hash_map_iterator_pt iter = hashMapIterator_create(manager->importedServices);
-    while (hashMapIterator_hasNext(iter)) {
-        hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
-        endpoint_description_pt ep = hashMapEntry_getKey(entry);
-        hash_map_pt imports = hashMapEntry_getValue(entry);
+	hash_map_iterator_pt iter = hashMapIterator_create(manager->importedServices);
+	while (hashMapIterator_hasNext(iter)) {
+		hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
+		endpoint_description_pt ep = hashMapEntry_getKey(entry);
+		hash_map_pt imports = hashMapEntry_getValue(entry);
 
-        logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Remove imported service (%s; %s).", ep->service, ep->id);
-        hash_map_iterator_pt importsIter = hashMapIterator_create(imports);
+		logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Remove imported service (%s; %s).", ep->service, ep->id);
+		hash_map_iterator_pt importsIter = hashMapIterator_create(imports);
 
-        while (hashMapIterator_hasNext(importsIter)) {
-            hash_map_entry_pt entry = hashMapIterator_nextEntry(importsIter);
+		while (hashMapIterator_hasNext(importsIter)) {
+			hash_map_entry_pt entry = hashMapIterator_nextEntry(importsIter);
 
-            remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
-            import_registration_pt import = hashMapEntry_getValue(entry);
+			remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
+			import_registration_pt import = hashMapEntry_getValue(entry);
 
-            status = rsa->importRegistration_close(rsa->admin, import);
-            if (status == CELIX_SUCCESS) {
-                hashMapIterator_remove(importsIter);
-            }
-        }
-        hashMapIterator_destroy(importsIter);
+			status = rsa->importRegistration_close(rsa->admin, import);
+			if (status == CELIX_SUCCESS) {
+				hashMapIterator_remove(importsIter);
+			}
+		}
+		hashMapIterator_destroy(importsIter);
 
-        hashMapIterator_remove(iter);
+		hashMapIterator_remove(iter);
 
-        if (imports != NULL) {
-            hashMap_destroy(imports, false, false);
-        }
-    }
-    hashMapIterator_destroy(iter);
+		if (imports != NULL) {
+			hashMap_destroy(imports, false, false);
+		}
+	}
+	hashMapIterator_destroy(iter);
 
-    status = celixThreadMutex_unlock(&manager->importedServicesLock);
+	status = celixThreadMutex_unlock(&manager->importedServicesLock);
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_rsaAdding(void * handle, service_reference_pt reference, void **service) {
-    celix_status_t status;
-    topology_manager_pt manager = (topology_manager_pt) handle;
+	celix_status_t status;
+	topology_manager_pt manager = (topology_manager_pt) handle;
 
-    status = bundleContext_getService(manager->context, reference, service);
+	status = bundleContext_getService(manager->context, reference, service);
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_rsaAdded(void * handle, service_reference_pt reference, void * service) {
-    celix_status_t status;
-    topology_manager_pt manager = (topology_manager_pt) handle;
-    properties_pt serviceProperties = NULL;
-    remote_service_admin_service_pt rsa = (remote_service_admin_service_pt) service;
-    logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Added RSA");
+	celix_status_t status;
+	topology_manager_pt manager = (topology_manager_pt) handle;
+	properties_pt serviceProperties = NULL;
+	remote_service_admin_service_pt rsa = (remote_service_admin_service_pt) service;
+	logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Added RSA");
 
-    status = celixThreadMutex_lock(&manager->rsaListLock);
+	status = celixThreadMutex_lock(&manager->rsaListLock);
 
-    if (status == CELIX_SUCCESS) {
-        arrayList_add(manager->rsaList, rsa);
-        status = celixThreadMutex_unlock(&manager->rsaListLock);
-    }
+	if (status == CELIX_SUCCESS) {
+		arrayList_add(manager->rsaList, rsa);
+		status = celixThreadMutex_unlock(&manager->rsaListLock);
+	}
 
-    // add already imported services to new rsa
-    if (status == CELIX_SUCCESS) {
-        status = celixThreadMutex_lock(&manager->importedServicesLock);
+	// add already imported services to new rsa
+	if (status == CELIX_SUCCESS) {
+		status = celixThreadMutex_lock(&manager->importedServicesLock);
 
-        if (status == CELIX_SUCCESS) {
-            hash_map_iterator_pt importedServicesIterator = hashMapIterator_create(manager->importedServices);
+		if (status == CELIX_SUCCESS) {
+			hash_map_iterator_pt importedServicesIterator = hashMapIterator_create(manager->importedServices);
 
-            while (hashMapIterator_hasNext(importedServicesIterator)) {
-                hash_map_entry_pt entry = hashMapIterator_nextEntry(importedServicesIterator);
-                endpoint_description_pt endpoint = hashMapEntry_getKey(entry);
-                if (scope_allowImport(manager->scope, endpoint)) {
-                    import_registration_pt import = NULL;
-                    status = rsa->importService(rsa->admin, endpoint, &import);
+			while (hashMapIterator_hasNext(importedServicesIterator)) {
+				hash_map_entry_pt entry = hashMapIterator_nextEntry(importedServicesIterator);
+				endpoint_description_pt endpoint = hashMapEntry_getKey(entry);
+				if (scope_allowImport(manager->scope, endpoint)) {
+					import_registration_pt import = NULL;
+					status = rsa->importService(rsa->admin, endpoint, &import);
 
-                    if (status == CELIX_SUCCESS) {
-                        hash_map_pt imports = hashMapEntry_getValue(entry);
+					if (status == CELIX_SUCCESS) {
+						hash_map_pt imports = hashMapEntry_getValue(entry);
 
-                        if (imports == NULL) {
-                            imports = hashMap_create(NULL, NULL, NULL, NULL);
-                        }
+						if (imports == NULL) {
+							imports = hashMap_create(NULL, NULL, NULL, NULL);
+							hashMap_put(manager->importedServices,endpoint,imports);
+						}
 
-                        hashMap_put(imports, service, import);
-                    }
-                }
-            }
+						hashMap_put(imports, service, import);
+					}
+				}
+			}
 
-            hashMapIterator_destroy(importedServicesIterator);
+			hashMapIterator_destroy(importedServicesIterator);
 
-            celixThreadMutex_unlock(&manager->importedServicesLock);
-        }
-    }
+			celixThreadMutex_unlock(&manager->importedServicesLock);
+		}
+	}
 
-    // add already exported services to new rsa
-    if (status == CELIX_SUCCESS) {
-        status = celixThreadMutex_lock(&manager->exportedServicesLock);
+	// add already exported services to new rsa
+	if (status == CELIX_SUCCESS) {
+		status = celixThreadMutex_lock(&manager->exportedServicesLock);
 
-        if (status == CELIX_SUCCESS) {
-            hash_map_iterator_pt exportedServicesIterator = hashMapIterator_create(manager->exportedServices);
+		if (status == CELIX_SUCCESS) {
+			hash_map_iterator_pt exportedServicesIterator = hashMapIterator_create(manager->exportedServices);
 
-            while (hashMapIterator_hasNext(exportedServicesIterator)) {
-                hash_map_entry_pt entry = hashMapIterator_nextEntry(exportedServicesIterator);
-                service_reference_pt reference = hashMapEntry_getKey(entry);
-                char *serviceId = NULL;
+			while (hashMapIterator_hasNext(exportedServicesIterator)) {
+				hash_map_entry_pt entry = hashMapIterator_nextEntry(exportedServicesIterator);
+				service_reference_pt reference = hashMapEntry_getKey(entry);
+				char *serviceId = NULL;
 
-                serviceReference_getProperty(reference, (char *) OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
+				serviceReference_getProperty(reference, (char *) OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
 
-                scope_getExportProperties(manager->scope, reference, &serviceProperties);
+				scope_getExportProperties(manager->scope, reference, &serviceProperties);
 
-                array_list_pt endpoints = NULL;
-                status = rsa->exportService(rsa->admin, serviceId, serviceProperties, &endpoints);
+				array_list_pt endpoints = NULL;
+				status = rsa->exportService(rsa->admin, serviceId, serviceProperties, &endpoints);
 
-                if (status == CELIX_SUCCESS) {
-                    hash_map_pt exports = hashMapEntry_getValue(entry);
+				if (status == CELIX_SUCCESS) {
+					hash_map_pt exports = hashMapEntry_getValue(entry);
 
-                    if (exports == NULL) {
-                        exports = hashMap_create(NULL, NULL, NULL, NULL);
-                    }
+					if (exports == NULL) {
+						exports = hashMap_create(NULL, NULL, NULL, NULL);
+						hashMap_put(manager->exportedServices,reference,exports);
+					}
 
-                    hashMap_put(exports, rsa, endpoints);
-                    status = topologyManager_notifyListenersEndpointAdded(manager, rsa, endpoints);
-                }
-            }
+					hashMap_put(exports, rsa, endpoints);
+					status = topologyManager_notifyListenersEndpointAdded(manager, rsa, endpoints);
+				}
+			}
 
-            hashMapIterator_destroy(exportedServicesIterator);
+			hashMapIterator_destroy(exportedServicesIterator);
 
-            celixThreadMutex_unlock(&manager->exportedServicesLock);
-        }
-    }
-    return status;
+			celixThreadMutex_unlock(&manager->exportedServicesLock);
+		}
+	}
+	return status;
 }
 
 celix_status_t topologyManager_rsaModified(void * handle, service_reference_pt reference, void * service) {
-    celix_status_t status = CELIX_SUCCESS;
+	celix_status_t status = CELIX_SUCCESS;
 
-    // Nop...
+	// Nop...
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_rsaRemoved(void * handle, service_reference_pt reference, void * service) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = (topology_manager_pt) handle;
-    remote_service_admin_service_pt rsa = (remote_service_admin_service_pt) service;
-
-    if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
-        hash_map_iterator_pt iter = hashMapIterator_create(manager->exportedServices);
-
-        while (hashMapIterator_hasNext(iter)) {
-
-            hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
-            service_reference_pt key = hashMapEntry_getKey(entry);
-            hash_map_pt exports = hashMapEntry_getValue(entry);
-
-            /*
-             * the problem here is that also the rsa has a a list of
-             * endpoints which is destroyed when closing the exportRegistration
-             */
-            array_list_pt exports_list = hashMap_get(exports, rsa);
-
-            if (exports_list != NULL) {
-                int exportsIter = 0;
-                int exportListSize = arrayList_size(exports_list);
-                for (exportsIter = 0; exports_list != NULL && exportsIter < exportListSize; exportsIter++) {
-                    export_registration_pt export = arrayList_get(exports_list, exportsIter);
-                    topologyManager_notifyListenersEndpointRemoved(manager, rsa, export);
-                    rsa->exportRegistration_close(rsa->admin, export);
-                }
-            }
-
-            hashMap_remove(exports, rsa);
-            /*if(exports_list!=NULL){
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = (topology_manager_pt) handle;
+	remote_service_admin_service_pt rsa = (remote_service_admin_service_pt) service;
+
+	if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
+		hash_map_iterator_pt iter = hashMapIterator_create(manager->exportedServices);
+
+		while (hashMapIterator_hasNext(iter)) {
+
+			hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
+			service_reference_pt key = hashMapEntry_getKey(entry);
+			hash_map_pt exports = hashMapEntry_getValue(entry);
+
+			/*
+			 * the problem here is that also the rsa has a a list of
+			 * endpoints which is destroyed when closing the exportRegistration
+			 */
+			array_list_pt exports_list = hashMap_get(exports, rsa);
+
+			if (exports_list != NULL) {
+				int exportsIter = 0;
+				int exportListSize = arrayList_size(exports_list);
+				for (exportsIter = 0; exports_list != NULL && exportsIter < exportListSize; exportsIter++) {
+					export_registration_pt export = arrayList_get(exports_list, exportsIter);
+					topologyManager_notifyListenersEndpointRemoved(manager, rsa, export);
+					rsa->exportRegistration_close(rsa->admin, export);
+				}
+			}
+
+			hashMap_remove(exports, rsa);
+			/*if(exports_list!=NULL){
             	arrayList_destroy(exports_list);
             }*/
 
-            if (hashMap_size(exports) == 0) {
-                hashMap_remove(manager->exportedServices, key);
-                hashMap_destroy(exports, false, false);
-
-                hashMapIterator_destroy(iter);
-                iter = hashMapIterator_create(manager->exportedServices);
-            }
-        }
-        hashMapIterator_destroy(iter);
-        celixThreadMutex_unlock(&manager->exportedServicesLock);
-    }
-
-    if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
-        hash_map_iterator_pt iter = hashMapIterator_create(manager->importedServices);
-
-        while (hashMapIterator_hasNext(iter)) {
-            hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
-            hash_map_pt imports = hashMapEntry_getValue(entry);
-
-            import_registration_pt import = hashMap_get(imports, rsa);
-
-            if (import != NULL) {
-                celix_status_t subStatus = rsa->importRegistration_close(rsa->admin, import);
-
-                if (subStatus == CELIX_SUCCESS) {
-                    hashMap_remove(imports, rsa);
-                } else {
-                    status = subStatus;
-                }
-            }
-        }
-        hashMapIterator_destroy(iter);
-        celixThreadMutex_unlock(&manager->importedServicesLock);
-    }
-
-    if (celixThreadMutex_lock(&manager->rsaListLock) == CELIX_SUCCESS) {
-        arrayList_removeElement(manager->rsaList, rsa);
-        celixThreadMutex_unlock(&manager->rsaListLock);
-    }
-
-    logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Removed RSA");
-
-    return status;
+			if (hashMap_size(exports) == 0) {
+				hashMap_remove(manager->exportedServices, key);
+				hashMap_destroy(exports, false, false);
+
+				hashMapIterator_destroy(iter);
+				iter = hashMapIterator_create(manager->exportedServices);
+			}
+		}
+		hashMapIterator_destroy(iter);
+		celixThreadMutex_unlock(&manager->exportedServicesLock);
+	}
+
+	if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
+		hash_map_iterator_pt iter = hashMapIterator_create(manager->importedServices);
+
+		while (hashMapIterator_hasNext(iter)) {
+			hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
+			hash_map_pt imports = hashMapEntry_getValue(entry);
+
+			import_registration_pt import = hashMap_get(imports, rsa);
+
+			if (import != NULL) {
+				celix_status_t subStatus = rsa->importRegistration_close(rsa->admin, import);
+
+				if (subStatus == CELIX_SUCCESS) {
+					hashMap_remove(imports, rsa);
+				} else {
+					status = subStatus;
+				}
+			}
+		}
+		hashMapIterator_destroy(iter);
+		celixThreadMutex_unlock(&manager->importedServicesLock);
+	}
+
+	if (celixThreadMutex_lock(&manager->rsaListLock) == CELIX_SUCCESS) {
+		arrayList_removeElement(manager->rsaList, rsa);
+		celixThreadMutex_unlock(&manager->rsaListLock);
+	}
+
+	logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Removed RSA");
+
+	return status;
 }
 
 
 celix_status_t topologyManager_serviceChanged(void *listener, service_event_pt event) {
-    celix_status_t status = CELIX_SUCCESS;
-    service_listener_pt listen = listener;
-    topology_manager_pt manager = listen->handle;
-
-    char *export = NULL;
-    char *serviceId = NULL;
-    serviceReference_getProperty(event->reference, (char *) OSGI_RSA_SERVICE_EXPORTED_INTERFACES, &export);
-    serviceReference_getProperty(event->reference, (char *) OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
-
-    if (!export) {
-        // Nothing needs to be done: we're not interested...
-        return status;
-    }
-
-    switch (event->type) {
-        case OSGI_FRAMEWORK_SERVICE_EVENT_REGISTERED:
-            status = topologyManager_addExportedService(manager, event->reference, serviceId);
-            break;
-        case OSGI_FRAMEWORK_SERVICE_EVENT_MODIFIED:
-            status = topologyManager_removeExportedService(manager, event->reference, serviceId);
-
-            if (status == CELIX_SUCCESS) {
-                status = topologyManager_addExportedService(manager, event->reference, serviceId);
-            }
-            break;
-        case OSGI_FRAMEWORK_SERVICE_EVENT_UNREGISTERING:
-            status = topologyManager_removeExportedService(manager, event->reference, serviceId);
-            break;
-        case OSGI_FRAMEWORK_SERVICE_EVENT_MODIFIED_ENDMATCH:
-            break;
-    }
-
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+	service_listener_pt listen = listener;
+	topology_manager_pt manager = listen->handle;
+
+	char *export = NULL;
+	char *serviceId = NULL;
+	serviceReference_getProperty(event->reference, (char *) OSGI_RSA_SERVICE_EXPORTED_INTERFACES, &export);
+	serviceReference_getProperty(event->reference, (char *) OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
+
+	if (!export) {
+		// Nothing needs to be done: we're not interested...
+		return status;
+	}
+
+	switch (event->type) {
+	case OSGI_FRAMEWORK_SERVICE_EVENT_REGISTERED:
+		status = topologyManager_addExportedService(manager, event->reference, serviceId);
+		break;
+	case OSGI_FRAMEWORK_SERVICE_EVENT_MODIFIED:
+		status = topologyManager_removeExportedService(manager, event->reference, serviceId);
+
+		if (status == CELIX_SUCCESS) {
+			status = topologyManager_addExportedService(manager, event->reference, serviceId);
+		}
+		break;
+	case OSGI_FRAMEWORK_SERVICE_EVENT_UNREGISTERING:
+		status = topologyManager_removeExportedService(manager, event->reference, serviceId);
+		break;
+	case OSGI_FRAMEWORK_SERVICE_EVENT_MODIFIED_ENDMATCH:
+		break;
+	}
+
+	return status;
 }
 
 celix_status_t topologyManager_exportScopeChanged(void *handle, char *filterStr) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = (topology_manager_pt) handle;
-    service_registration_pt reg = NULL;
-    char *serviceId = NULL;
-    bool found;
-    properties_pt props;
-    filter_pt filter = filter_create(filterStr);
-
-    if (filter == NULL) {
-        printf("filter creating failed\n");
-        return CELIX_ENOMEM;
-    }
-
-    // add already exported services to new rsa
-    if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
-        hash_map_iterator_pt exportedServicesIterator = hashMapIterator_create(manager->exportedServices);
-        int size = hashMap_size(manager->exportedServices);
-        service_reference_pt *srvRefs = (service_reference_pt *) calloc(size, sizeof(service_reference_pt));
-        char **srvIds = (char **) calloc(size, sizeof(char*));
-        int nrFound = 0;
-
-        found = false;
-
-        while (hashMapIterator_hasNext(exportedServicesIterator)) {
-            hash_map_entry_pt entry = hashMapIterator_nextEntry(exportedServicesIterator);
-            service_reference_pt reference = hashMapEntry_getKey(entry);
-            reg = NULL;
-            serviceReference_getServiceRegistration(reference, &reg);
-            if (reg != NULL) {
-                props = NULL;
-                serviceRegistration_getProperties(reg, &props);
-                status = filter_match(filter, props, &found);
-                if (found) {
-                    srvRefs[nrFound] = reference;
-                    serviceReference_getProperty(reference, (char *) OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
-                    srvIds[nrFound++] = serviceId;
-                }
-            }
-        }
-
-        hashMapIterator_destroy(exportedServicesIterator);
-        celixThreadMutex_unlock(&manager->exportedServicesLock);
-
-        if (nrFound > 0) {
-            for (int i = 0; i < nrFound; i++) {
-                // Question: can srvRefs become invalid meanwhile??
-                char *export = NULL;
-                serviceReference_getProperty(srvRefs[i], (char *) OSGI_RSA_SERVICE_EXPORTED_INTERFACES, &export);
-
-                if (export) {
-                    celix_status_t substatus = topologyManager_removeExportedService(manager, srvRefs[i], srvIds[i]);
-
-                    if (substatus != CELIX_SUCCESS) {
-                        logHelper_log(manager->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: Removal of exported service (%s) failed.", srvIds[i]);
-                    } else {
-                        substatus = topologyManager_addExportedService(manager, srvRefs[i], srvIds[i]);
-                    }
-
-                    if (substatus != CELIX_SUCCESS) {
-                        status = substatus;
-                    }
-                }
-            }
-        }
-
-        free(srvRefs);
-        free(srvIds);
-    }
-
-    filter_destroy(filter);
-
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = (topology_manager_pt) handle;
+	service_registration_pt reg = NULL;
+	char *serviceId = NULL;
+	bool found;
+	properties_pt props;
+	filter_pt filter = filter_create(filterStr);
+
+	if (filter == NULL) {
+		printf("filter creating failed\n");
+		return CELIX_ENOMEM;
+	}
+
+	// add already exported services to new rsa
+	if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
+		hash_map_iterator_pt exportedServicesIterator = hashMapIterator_create(manager->exportedServices);
+		int size = hashMap_size(manager->exportedServices);
+		service_reference_pt *srvRefs = (service_reference_pt *) calloc(size, sizeof(service_reference_pt));
+		char **srvIds = (char **) calloc(size, sizeof(char*));
+		int nrFound = 0;
+
+		found = false;
+
+		while (hashMapIterator_hasNext(exportedServicesIterator)) {
+			hash_map_entry_pt entry = hashMapIterator_nextEntry(exportedServicesIterator);
+			service_reference_pt reference = hashMapEntry_getKey(entry);
+			reg = NULL;
+			serviceReference_getServiceRegistration(reference, &reg);
+			if (reg != NULL) {
+				props = NULL;
+				serviceRegistration_getProperties(reg, &props);
+				status = filter_match(filter, props, &found);
+				if (found) {
+					srvRefs[nrFound] = reference;
+					serviceReference_getProperty(reference, (char *) OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
+					srvIds[nrFound++] = serviceId;
+				}
+			}
+		}
+
+		hashMapIterator_destroy(exportedServicesIterator);
+		celixThreadMutex_unlock(&manager->exportedServicesLock);
+
+		if (nrFound > 0) {
+			for (int i = 0; i < nrFound; i++) {
+				// Question: can srvRefs become invalid meanwhile??
+						char *export = NULL;
+				serviceReference_getProperty(srvRefs[i], (char *) OSGI_RSA_SERVICE_EXPORTED_INTERFACES, &export);
+
+				if (export) {
+					celix_status_t substatus = topologyManager_removeExportedService(manager, srvRefs[i], srvIds[i]);
+
+					if (substatus != CELIX_SUCCESS) {
+						logHelper_log(manager->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: Removal of exported service (%s) failed.", srvIds[i]);
+					} else {
+						substatus = topologyManager_addExportedService(manager, srvRefs[i], srvIds[i]);
+					}
+
+					if (substatus != CELIX_SUCCESS) {
+						status = substatus;
+					}
+				}
+			}
+		}
+
+		free(srvRefs);
+		free(srvIds);
+	}
+
+	filter_destroy(filter);
+
+	return status;
 }
 
 celix_status_t topologyManager_importScopeChanged(void *handle, char *service_name) {
-    celix_status_t status = CELIX_SUCCESS;
-    endpoint_description_pt endpoint;
-    topology_manager_pt manager = (topology_manager_pt) handle;
-    bool found = false;
-
-    // add already exported services to new rsa
-    if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
-        hash_map_iterator_pt importedServicesIterator = hashMapIterator_create(manager->importedServices);
-        while (!found && hashMapIterator_hasNext(importedServicesIterator)) {
-            hash_map_entry_pt entry = hashMapIterator_nextEntry(importedServicesIterator);
-            endpoint = hashMapEntry_getKey(entry);
-
-            entry = hashMap_getEntry(endpoint->properties, (void *) OSGI_FRAMEWORK_OBJECTCLASS);
-            char* name = (char *) hashMapEntry_getValue(entry);
-            // Test if a service with the same name is imported
-            if (strcmp(name, service_name) == 0) {
-                found = true;
-            }
-        }
-        hashMapIterator_destroy(importedServicesIterator);
-        celixThreadMutex_unlock(&manager->importedServicesLock);
-    }
-
-    if (found) {
-        status = topologyManager_removeImportedService(manager, endpoint, NULL);
-
-        if (status != CELIX_SUCCESS) {
-            logHelper_log(manager->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: Removal of imported service (%s; %s) failed.", endpoint->service, endpoint->id);
-        } else {
-            status = topologyManager_addImportedService(manager, endpoint, NULL);
-        }
-    }
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+	endpoint_description_pt endpoint;
+	topology_manager_pt manager = (topology_manager_pt) handle;
+	bool found = false;
+
+	// add already exported services to new rsa
+	if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
+		hash_map_iterator_pt importedServicesIterator = hashMapIterator_create(manager->importedServices);
+		while (!found && hashMapIterator_hasNext(importedServicesIterator)) {
+			hash_map_entry_pt entry = hashMapIterator_nextEntry(importedServicesIterator);
+			endpoint = hashMapEntry_getKey(entry);
+
+			entry = hashMap_getEntry(endpoint->properties, (void *) OSGI_FRAMEWORK_OBJECTCLASS);
+			char* name = (char *) hashMapEntry_getValue(entry);
+			// Test if a service with the same name is imported
+			if (strcmp(name, service_name) == 0) {
+				found = true;
+			}
+		}
+		hashMapIterator_destroy(importedServicesIterator);
+		celixThreadMutex_unlock(&manager->importedServicesLock);
+	}
+
+	if (found) {
+		status = topologyManager_removeImportedService(manager, endpoint, NULL);
+
+		if (status != CELIX_SUCCESS) {
+			logHelper_log(manager->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: Removal of imported service (%s; %s) failed.", endpoint->service, endpoint->id);
+		} else {
+			status = topologyManager_addImportedService(manager, endpoint, NULL);
+		}
+	}
+	return status;
 }
 
 celix_status_t topologyManager_addImportedService(void *handle, endpoint_description_pt endpoint, char *matchedFilter) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = handle;
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = handle;
 
-    logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Add imported service (%s; %s).", endpoint->service, endpoint->id);
+	logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Add imported service (%s; %s).", endpoint->service, endpoint->id);
 
-    if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
+	if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
 
-        hash_map_pt imports = hashMap_create(NULL, NULL, NULL, NULL);
-        hashMap_put(manager->importedServices, endpoint, imports);
+		hash_map_pt imports = hashMap_create(NULL, NULL, NULL, NULL);
+		hashMap_put(manager->importedServices, endpoint, imports);
 
-        if (scope_allowImport(manager->scope, endpoint)) {
-            if (celixThreadMutex_lock(&manager->rsaListLock) == CELIX_SUCCESS) {
-                int size = arrayList_size(manager->rsaList);
+		if (scope_allowImport(manager->scope, endpoint)) {
+			if (celixThreadMutex_lock(&manager->rsaListLock) == CELIX_SUCCESS) {
+				int size = arrayList_size(manager->rsaList);
 
-                for (int iter = 0; iter < size; iter++) {
-                    import_registration_pt import = NULL;
-                    remote_service_admin_service_pt rsa = arrayList_get(manager->rsaList, iter);
-                    celix_status_t substatus = rsa->importService(rsa->admin, endpoint, &import);
-                    if (substatus == CELIX_SUCCESS) {
-                        hashMap_put(imports, rsa, import);
-                    } else {
-                        status = substatus;
-                    }
-                }
-                celixThreadMutex_unlock(&manager->rsaListLock);
-            }
+				for (int iter = 0; iter < size; iter++) {
+					import_registration_pt import = NULL;
+					remote_service_admin_service_pt rsa = arrayList_get(manager->rsaList, iter);
+					celix_status_t substatus = rsa->importService(rsa->admin, endpoint, &import);
+					if (substatus == CELIX_SUCCESS) {
+						hashMap_put(imports, rsa, import);
+					} else {
+						status = substatus;
+					}
+				}
+				celixThreadMutex_unlock(&manager->rsaListLock);
+			}
 
-        }
+		}
 
-        celixThreadMutex_unlock(&manager->importedServicesLock);
-    }
+		celixThreadMutex_unlock(&manager->importedServicesLock);
+	}
 
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_removeImportedService(void *handle, endpoint_description_pt endpoint, char *matchedFilter) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = handle;
-
-    logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Remove imported service (%s; %s).", endpoint->service, endpoint->id);
-
-    if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
-
-        hash_map_iterator_pt iter = hashMapIterator_create(manager->importedServices);
-        while (hashMapIterator_hasNext(iter)) {
-            hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
-            endpoint_description_pt ep = hashMapEntry_getKey(entry);
-            hash_map_pt imports = hashMapEntry_getValue(entry);
-
-            if (strcmp(endpoint->id, ep->id) == 0) {
-                hash_map_iterator_pt importsIter = hashMapIterator_create(imports);
-
-                while (hashMapIterator_hasNext(importsIter)) {
-                    hash_map_entry_pt entry = hashMapIterator_nextEntry(importsIter);
-                    remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
-                    import_registration_pt import = hashMapEntry_getValue(entry);
-                    celix_status_t substatus = rsa->importRegistration_close(rsa->admin, import);
-                    if (status == CELIX_SUCCESS) {
-                        hashMapIterator_remove(importsIter);
-                    } else {
-                        status = substatus;
-                    }
-                }
-                hashMapIterator_destroy(importsIter);
-                hashMapIterator_remove(iter);
-
-                if (imports != NULL) {
-                    hashMap_destroy(imports, false, false);
-                }
-            }
-        }
-        hashMapIterator_destroy(iter);
-        celixThreadMutex_unlock(&manager->importedServicesLock);
-    }
-
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = handle;
+
+	logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Remove imported service (%s; %s).", endpoint->service, endpoint->id);
+
+	if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
+
+		hash_map_iterator_pt iter = hashMapIterator_create(manager->importedServices);
+		while (hashMapIterator_hasNext(iter)) {
+			hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
+			endpoint_description_pt ep = hashMapEntry_getKey(entry);
+			hash_map_pt imports = hashMapEntry_getValue(entry);
+
+			if (strcmp(endpoint->id, ep->id) == 0) {
+				hash_map_iterator_pt importsIter = hashMapIterator_create(imports);
+
+				while (hashMapIterator_hasNext(importsIter)) {
+					hash_map_entry_pt entry = hashMapIterator_nextEntry(importsIter);
+					remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
+					import_registration_pt import = hashMapEntry_getValue(entry);
+					celix_status_t substatus = rsa->importRegistration_close(rsa->admin, import);
+					if (status == CELIX_SUCCESS) {
+						hashMapIterator_remove(importsIter);
+					} else {
+						status = substatus;
+					}
+				}
+				hashMapIterator_destroy(importsIter);
+				hashMapIterator_remove(iter);
+
+				if (imports != NULL) {
+					hashMap_destroy(imports, false, false);
+				}
+			}
+		}
+		hashMapIterator_destroy(iter);
+		celixThreadMutex_unlock(&manager->importedServicesLock);
+	}
+
+	return status;
 }
 
 celix_status_t topologyManager_addExportedService(topology_manager_pt manager, service_reference_pt reference, char *serviceId) {
-    celix_status_t status = CELIX_SUCCESS;
-    properties_pt serviceProperties = NULL;
-
-    logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Add exported service (%s).", serviceId);
-
-    if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
-        scope_getExportProperties(manager->scope, reference, &serviceProperties);
-        hash_map_pt exports = hashMap_create(NULL, NULL, NULL, NULL);
-        hashMap_put(manager->exportedServices, reference, exports);
-
-        if (celixThreadMutex_lock(&manager->rsaListLock) == CELIX_SUCCESS) {
-            int size = arrayList_size(manager->rsaList);
-
-            if (size == 0) {
-                logHelper_log(manager->loghelper, OSGI_LOGSERVICE_WARNING, "TOPOLOGY_MANAGER: No RSA available yet.");
-            }
-
-            for (int iter = 0; iter < size; iter++) {
-                remote_service_admin_service_pt rsa = arrayList_get(manager->rsaList, iter);
-
-                array_list_pt endpoints = NULL;
-                celix_status_t substatus = rsa->exportService(rsa->admin, serviceId, serviceProperties, &endpoints);
-
-                if (substatus == CELIX_SUCCESS) {
-                    hashMap_put(exports, rsa, endpoints);
-                    topologyManager_notifyListenersEndpointAdded(manager, rsa, endpoints);
-                } else {
-                    status = substatus;
-                }
-            }
-            celixThreadMutex_unlock(&manager->rsaListLock);
-        }
-        celixThreadMutex_unlock(&manager->exportedServicesLock);
-    }
-
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+	properties_pt serviceProperties = NULL;
+
+	logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Add exported service (%s).", serviceId);
+
+	if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
+		scope_getExportProperties(manager->scope, reference, &serviceProperties);
+		hash_map_pt exports = hashMap_create(NULL, NULL, NULL, NULL);
+		hashMap_put(manager->exportedServices, reference, exports);
+
+		if (celixThreadMutex_lock(&manager->rsaListLock) == CELIX_SUCCESS) {
+			int size = arrayList_size(manager->rsaList);
+
+			if (size == 0) {
+				logHelper_log(manager->loghelper, OSGI_LOGSERVICE_WARNING, "TOPOLOGY_MANAGER: No RSA available yet.");
+			}
+
+			for (int iter = 0; iter < size; iter++) {
+				remote_service_admin_service_pt rsa = arrayList_get(manager->rsaList, iter);
+
+				array_list_pt endpoints = NULL;
+				celix_status_t substatus = rsa->exportService(rsa->admin, serviceId, serviceProperties, &endpoints);
+
+				if (substatus == CELIX_SUCCESS) {
+					hashMap_put(exports, rsa, endpoints);
+					topologyManager_notifyListenersEndpointAdded(manager, rsa, endpoints);
+				} else {
+					status = substatus;
+				}
+			}
+			celixThreadMutex_unlock(&manager->rsaListLock);
+		}
+		celixThreadMutex_unlock(&manager->exportedServicesLock);
+	}
+
+	return status;
 }
 
 celix_status_t topologyManager_removeExportedService(topology_manager_pt manager, service_reference_pt reference, char *serviceId) {
-    celix_status_t status = CELIX_SUCCESS;
+	celix_status_t status = CELIX_SUCCESS;
 
-    logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Remove exported service (%s).", serviceId);
+	logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Remove exported service (%s).", serviceId);
 
-    if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
-        hash_map_pt exports = hashMap_get(manager->exportedServices, reference);
-        if (exports) {
-            hash_map_iterator_pt iter = hashMapIterator_create(exports);
-            while (hashMapIterator_hasNext(iter)) {
-                hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
-                remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
-                array_list_pt exportRegistrations = hashMapEntry_getValue(entry);
+	if (celixThreadMutex_lock(&manager->exportedServicesLock) == CELIX_SUCCESS) {
+		hash_map_pt exports = hashMap_get(manager->exportedServices, reference);
+		if (exports) {
+			hash_map_iterator_pt iter = hashMapIterator_create(exports);
+			while (hashMapIterator_hasNext(iter)) {
+				hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
+				remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
+				array_list_pt exportRegistrations = hashMapEntry_getValue(entry);
 
-                int size = arrayList_size(exportRegistrations);
+				int size = arrayList_size(exportRegistrations);
 
-                for (int exportsIter = 0; exportsIter < size; exportsIter++) {
-                    export_registration_pt export = arrayList_get(exportRegistrations, exportsIter);
-                    topologyManager_notifyListenersEndpointRemoved(manager, rsa, export);
-                    rsa->exportRegistration_close(rsa->admin, export);
-                }
+				for (int exportsIter = 0; exportsIter < size; exportsIter++) {
+					export_registration_pt export = arrayList_get(exportRegistrations, exportsIter);
+					topologyManager_notifyListenersEndpointRemoved(manager, rsa, export);
+					rsa->exportRegistration_close(rsa->admin, export);
+				}
 
-                hashMap_remove(exports, rsa);
-                //arrayList_destroy(exportRegistrations);
-                hashMapIterator_destroy(iter);
-                iter = hashMapIterator_create(exports);
+				hashMap_remove(exports, rsa);
+				//arrayList_destroy(exportRegistrations);
+				hashMapIterator_destroy(iter);
+				iter = hashMapIterator_create(exports);
 
-            }
-            hashMapIterator_destroy(iter);
-        }
-        exports = hashMap_remove(manager->exportedServices, reference);
+			}
+			hashMapIterator_destroy(iter);
+		}
+		exports = hashMap_remove(manager->exportedServices, reference);
 
-        if (exports != NULL) {
-            hashMap_destroy(exports, false, false);
-        }
+		if (exports != NULL) {
+			hashMap_destroy(exports, false, false);
+		}
 
-        celixThreadMutex_unlock(&manager->exportedServicesLock);
-    }
+		celixThreadMutex_unlock(&manager->exportedServicesLock);
+	}
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_getEndpointDescriptionForExportRegistration(remote_service_admin_service_pt rsa, export_registration_pt export, endpoint_description_pt *endpoint) {
-    celix_status_t status;
+	celix_status_t status;
 
-    export_reference_pt reference = NULL;
-    status = rsa->exportRegistration_getExportReference(export, &reference);
+	export_reference_pt reference = NULL;
+	status = rsa->exportRegistration_getExportReference(export, &reference);
 
-    if (status == CELIX_SUCCESS) {
-        status = rsa->exportReference_getExportedEndpoint(reference, endpoint);
-    }
+	if (status == CELIX_SUCCESS) {
+		status = rsa->exportReference_getExportedEndpoint(reference, endpoint);
+	}
 
-    free(reference);
+	free(reference);
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_endpointListenerAdding(void* handle, service_reference_pt reference, void** service) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = (topology_manager_pt) handle;
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = (topology_manager_pt) handle;
 
-    bundleContext_getService(manager->context, reference, service);
+	bundleContext_getService(manager->context, reference, service);
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_endpointListenerAdded(void* handle, service_reference_pt reference, void* service) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = handle;
-    char *scope = NULL;
-
-    logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Added ENDPOINT_LISTENER");
-
-    if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
-        hashMap_put(manager->listenerList, reference, NULL);
-        celixThreadMutex_unlock(&manager->listenerListLock);
-
-        serviceReference_getProperty(reference, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, &scope);
-
-        filter_pt filter = filter_create(scope);
-        hash_map_iterator_pt refIter = hashMapIterator_create(manager->exportedServices);
-
-        while (hashMapIterator_hasNext(refIter)) {
-            hash_map_pt rsaExports = hashMapIterator_nextValue(refIter);
-            hash_map_iterator_pt rsaIter = hashMapIterator_create(rsaExports);
-
-            while (hashMapIterator_hasNext(rsaIter)) {
-                hash_map_entry_pt entry = hashMapIterator_nextEntry(rsaIter);
-                remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
-                array_list_pt registrations = hashMapEntry_getValue(entry);
-
-                int arrayListSize = arrayList_size(registrations);
-                int cnt = 0;
-
-                for (; cnt < arrayListSize; cnt++) {
-                    export_registration_pt export = arrayList_get(registrations, cnt);
-                    endpoint_description_pt endpoint = NULL;
-
-                    status = topologyManager_getEndpointDescriptionForExportRegistration(rsa, export, &endpoint);
-                    if (status == CELIX_SUCCESS) {
-                        bool matchResult = false;
-                        filter_match(filter, endpoint->properties, &matchResult);
-                        if (matchResult) {
-                            endpoint_listener_pt listener = (endpoint_listener_pt) service;
-                            status = listener->endpointAdded(listener->handle, endpoint, scope);
-                        }
-                    }
-                }
-            }
-            hashMapIterator_destroy(rsaIter);
-        }
-        hashMapIterator_destroy(refIter);
-
-        filter_destroy(filter);
-    }
-
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = handle;
+	char *scope = NULL;
+
+	logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: Added ENDPOINT_LISTENER");
+
+	if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
+		hashMap_put(manager->listenerList, reference, NULL);
+		celixThreadMutex_unlock(&manager->listenerListLock);
+
+		serviceReference_getProperty(reference, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, &scope);
+
+		filter_pt filter = filter_create(scope);
+		hash_map_iterator_pt refIter = hashMapIterator_create(manager->exportedServices);
+
+		while (hashMapIterator_hasNext(refIter)) {
+			hash_map_pt rsaExports = hashMapIterator_nextValue(refIter);
+			hash_map_iterator_pt rsaIter = hashMapIterator_create(rsaExports);
+
+			while (hashMapIterator_hasNext(rsaIter)) {
+				hash_map_entry_pt entry = hashMapIterator_nextEntry(rsaIter);
+				remote_service_admin_service_pt rsa = hashMapEntry_getKey(entry);
+				array_list_pt registrations = hashMapEntry_getValue(entry);
+
+				int arrayListSize = arrayList_size(registrations);
+				int cnt = 0;
+
+				for (; cnt < arrayListSize; cnt++) {
+					export_registration_pt export = arrayList_get(registrations, cnt);
+					endpoint_description_pt endpoint = NULL;
+
+					status = topologyManager_getEndpointDescriptionForExportRegistration(rsa, export, &endpoint);
+					if (status == CELIX_SUCCESS) {
+						bool matchResult = false;
+						filter_match(filter, endpoint->properties, &matchResult);
+						if (matchResult) {
+							endpoint_listener_pt listener = (endpoint_listener_pt) service;
+							status = listener->endpointAdded(listener->handle, endpoint, scope);
+						}
+					}
+				}
+			}
+			hashMapIterator_destroy(rsaIter);
+		}
+		hashMapIterator_destroy(refIter);
+
+		filter_destroy(filter);
+	}
+
+	return status;
 }
 
 celix_status_t topologyManager_endpointListenerModified(void * handle, service_reference_pt reference, void * service) {
-    celix_status_t status;
+	celix_status_t status;
 
-    status = topologyManager_endpointListenerRemoved(handle, reference, service);
+	status = topologyManager_endpointListenerRemoved(handle, reference, service);
 
-    if (status == CELIX_SUCCESS) {
-        status = topologyManager_endpointListenerAdded(handle, reference, service);
-    }
+	if (status == CELIX_SUCCESS) {
+		status = topologyManager_endpointListenerAdded(handle, reference, service);
+	}
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_endpointListenerRemoved(void * handle, service_reference_pt reference, void * service) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = handle;
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = handle;
 
-    if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
+	if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
 
-        if (hashMap_remove(manager->listenerList, reference)) {
-            logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "EndpointListener Removed");
-        }
+		if (hashMap_remove(manager->listenerList, reference)) {
+			logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "EndpointListener Removed");
+		}
 
-        celixThreadMutex_unlock(&manager->listenerListLock);
-    }
+		celixThreadMutex_unlock(&manager->listenerListLock);
+	}
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_notifyListenersEndpointAdded(topology_manager_pt manager, remote_service_admin_service_pt rsa, array_list_pt registrations) {
-    celix_status_t status = CELIX_SUCCESS;
-
-    if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
-
-        hash_map_iterator_pt iter = hashMapIterator_create(manager->listenerList);
-        while (hashMapIterator_hasNext(iter)) {
-            char *scope = NULL;
-            endpoint_listener_pt epl = NULL;
-            service_reference_pt reference = hashMapIterator_nextKey(iter);
-
-            serviceReference_getProperty(reference, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, &scope);
-
-            status = bundleContext_getService(manager->context, reference, (void **) &epl);
-            if (status == CELIX_SUCCESS) {
-                filter_pt filter = filter_create(scope);
-
-                int regSize = arrayList_size(registrations);
-                for (int regIt = 0; regIt < regSize; regIt++) {
-                    export_registration_pt export = arrayList_get(registrations, regIt);
-                    endpoint_description_pt endpoint = NULL;
-                    celix_status_t substatus = topologyManager_getEndpointDescriptionForExportRegistration(rsa, export, &endpoint);
-                    if (substatus == CELIX_SUCCESS) {
-                        bool matchResult = false;
-                        filter_match(filter, endpoint->properties, &matchResult);
-                        if (matchResult) {
-                            status = epl->endpointAdded(epl->handle, endpoint, scope);
-                        }
-                    } else {
-                        status = substatus;
-                    }
-                }
-                filter_destroy(filter);
-            }
-        }
-        hashMapIterator_destroy(iter);
-        celixThreadMutex_unlock(&manager->listenerListLock);
-    }
-
-    return status;
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
+
+		hash_map_iterator_pt iter = hashMapIterator_create(manager->listenerList);
+		while (hashMapIterator_hasNext(iter)) {
+			char *scope = NULL;
+			endpoint_listener_pt epl = NULL;
+			service_reference_pt reference = hashMapIterator_nextKey(iter);
+
+			serviceReference_getProperty(reference, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, &scope);
+
+			status = bundleContext_getService(manager->context, reference, (void **) &epl);
+			if (status == CELIX_SUCCESS) {
+				filter_pt filter = filter_create(scope);
+
+				int regSize = arrayList_size(registrations);
+				for (int regIt = 0; regIt < regSize; regIt++) {
+					export_registration_pt export = arrayList_get(registrations, regIt);
+					endpoint_description_pt endpoint = NULL;
+					celix_status_t substatus = topologyManager_getEndpointDescriptionForExportRegistration(rsa, export, &endpoint);
+					if (substatus == CELIX_SUCCESS) {
+						bool matchResult = false;
+						filter_match(filter, endpoint->properties, &matchResult);
+						if (matchResult) {
+							status = epl->endpointAdded(epl->handle, endpoint, scope);
+						}
+					} else {
+						status = substatus;
+					}
+				}
+				filter_destroy(filter);
+			}
+		}
+		hashMapIterator_destroy(iter);
+		celixThreadMutex_unlock(&manager->listenerListLock);
+	}
+
+	return status;
 }
 
 celix_status_t topologyManager_notifyListenersEndpointRemoved(topology_manager_pt manager, remote_service_admin_service_pt rsa, export_registration_pt export) {
-    celix_status_t status = CELIX_SUCCESS;
+	celix_status_t status = CELIX_SUCCESS;
 
-    if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
-        hash_map_iterator_pt iter = hashMapIterator_create(manager->listenerList);
-        while (hashMapIterator_hasNext(iter)) {
-            endpoint_description_pt endpoint = NULL;
-            endpoint_listener_pt epl = NULL;
-            celix_status_t substatus;
-            char *scope = NULL;
+	if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
+		hash_map_iterator_pt iter = hashMapIterator_create(manager->listenerList);
+		while (hashMapIterator_hasNext(iter)) {
+			endpoint_description_pt endpoint = NULL;
+			endpoint_listener_pt epl = NULL;
+			celix_status_t substatus;
+			char *scope = NULL;
 
-            service_reference_pt reference = hashMapIterator_nextKey(iter);
-            serviceReference_getProperty(reference, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, &scope);
+			service_reference_pt reference = hashMapIterator_nextKey(iter);
+			serviceReference_getProperty(reference, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, &scope);
 
-            substatus = bundleContext_getService(manager->context, reference, (void **) &epl);
+			substatus = bundleContext_getService(manager->context, reference, (void **) &epl);
 
-            if (substatus == CELIX_SUCCESS) {
-                substatus = topologyManager_getEndpointDescriptionForExportRegistration(rsa, export, &endpoint);
-            }
+			if (substatus == CELIX_SUCCESS) {
+				substatus = topologyManager_getEndpointDescriptionForExportRegistration(rsa, export, &endpoint);
+			}
 
-            if (substatus == CELIX_SUCCESS) {
-                substatus = epl->endpointRemoved(epl->handle, endpoint, NULL);
-            }
+			if (substatus == CELIX_SUCCESS) {
+				substatus = epl->endpointRemoved(epl->handle, endpoint, NULL);
+			}
 
-            /*            if (substatus != CELIX_SUCCESS) {
+			/*            if (substatus != CELIX_SUCCESS) {
              status = substatus;
 
              }
-             */
-        }
-        hashMapIterator_destroy(iter);
-        celixThreadMutex_unlock(&manager->listenerListLock);
-    }
+			 */
+		}
+		hashMapIterator_destroy(iter);
+		celixThreadMutex_unlock(&manager->listenerListLock);
+	}
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_extendFilter(topology_manager_pt manager, char *filter, char **updatedFilter) {
-    celix_status_t status;
-    bundle_context_pt context = manager->context;
-    char* uuid = NULL;
+	celix_status_t status;
+	bundle_context_pt context = manager->context;
+	char* uuid = NULL;
 
-    status = bundleContext_getProperty(context, (char *) OSGI_FRAMEWORK_FRAMEWORK_UUID, &uuid);
+	status = bundleContext_getProperty(context, (char *) OSGI_FRAMEWORK_FRAMEWORK_UUID, &uuid);
 
-    if (!uuid) {
-        logHelper_log(manager->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: no framework UUID defined?!");
-        return CELIX_BUNDLE_EXCEPTION;
-    }
+	if (!uuid) {
+		logHelper_log(manager->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: no framework UUID defined?!");
+		return CELIX_BUNDLE_EXCEPTION;
+	}
 
-    int len = 10 + strlen(filter) + strlen(OSGI_RSA_ENDPOINT_FRAMEWORK_UUID) + strlen(uuid);
-    *updatedFilter = malloc(len);
-    if (!*updatedFilter) {
-        return CELIX_ENOMEM;
-    }
+	int len = 10 + strlen(filter) + strlen(OSGI_RSA_ENDPOINT_FRAMEWORK_UUID) + strlen(uuid);
+	*updatedFilter = malloc(len);
+	if (!*updatedFilter) {
+		return CELIX_ENOMEM;
+	}
 
-    snprintf(*updatedFilter, len, "(&%s(!(%s=%s)))", filter, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, uuid);
+	snprintf(*updatedFilter, len, "(&%s(!(%s=%s)))", filter, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, uuid);
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_listenerAdded(void *handle, array_list_pt listeners) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = handle;
-
-    for (int i = 0; i < arrayList_size(listeners); i++) {
-        listener_hook_info_pt info = arrayList_get(listeners, i);
-        bundle_pt bundle = NULL, self = NULL;
-        bundleContext_getBundle(info->context, &bundle);
-        bundleContext_getBundle(manager->context, &self);
-        if (bundle == self) {
-            logHelper_log(manager->loghelper, OSGI_LOGSERVICE_DEBUG, "TOPOLOGY_MANAGER: Ignore myself.");
-            continue;
-        }
-
-        logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: listener with filter \"%s\" added", info->filter);
-
-        char *filter = NULL;
-        status = topologyManager_extendFilter(manager, info->filter, &filter);
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = handle;
+
+	for (int i = 0; i < arrayList_size(listeners); i++) {
+		listener_hook_info_pt info = arrayList_get(listeners, i);
+		bundle_pt bundle = NULL, self = NULL;
+		bundleContext_getBundle(info->context, &bundle);
+		bundleContext_getBundle(manager->context, &self);
+		if (bundle == self) {
+			logHelper_log(manager->loghelper, OSGI_LOGSERVICE_DEBUG, "TOPOLOGY_MANAGER: Ignore myself.");
+			continue;
+		}
+
+		logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: listener with filter \"%s\" added", info->filter);
+
+		char *filter = NULL;
+		bool free_filter = true;
+		status = topologyManager_extendFilter(manager, info->filter, &filter);
 #if 0
-        // TODO: add status handling
-        status = celixThreadMutex_lock(&manager->importScopesLock);
-
-        struct scope *interest = hashMap_get(manager->importScopes, filter);
-        if (interest) {
-            interest->refs++;
-            free(filter);
-        } else {
-            interest = malloc(sizeof(*interest));
-            interest->filter = filter;
-            interest->refs = 1;
-            hashMap_put(manager->importScopes, filter, interest);
-        }
-
-        status = celixThreadMutex_unlock(&manager->importScopesLock);
+		if(filter != NULL){
+			// TODO: add status handling
+			status = celixThreadMutex_lock(&manager->importScopesLock);
+
+			struct scope *interest = hashMap_get(manager->importScopes, filter);
+			if (interest) {
+				interest->refs++;
+				free(filter);
+				filter = NULL;
+			} else {
+				interest = malloc(sizeof(*interest));
+				interest->filter = filter;
+				interest->refs = 1;
+				hashMap_put(manager->importScopes, filter, interest);
+				free_filter = false;
+			}
+
+			status = celixThreadMutex_unlock(&manager->importScopesLock);
+		}
 #endif
 
-        if (status == CELIX_SUCCESS) {
-            free(filter);
-        }
+		if (filter != NULL && free_filter) {
+			free(filter);
+		}
 
-    }
+	}
 
-    return status;
+	return status;
 }
 
 celix_status_t topologyManager_listenerRemoved(void *handle, array_list_pt listeners) {
-    celix_status_t status = CELIX_SUCCESS;
-    topology_manager_pt manager = handle;
+	celix_status_t status = CELIX_SUCCESS;
+	topology_manager_pt manager = handle;
 
-    for (int i = 0; i < arrayList_size(listeners); i++) {
-        listener_hook_info_pt info = arrayList_get(listeners, i);
+	for (int i = 0; i < arrayList_size(listeners); i++) {
+		listener_hook_info_pt info = arrayList_get(listeners, i);
 
-        bundle_pt bundle = NULL, self = NULL;
-        bundleContext_getBundle(info->context, &bundle);
-        bundleContext_getBundle(manager->context, &self);
-        if (bundle == self) {
-            logHelper_log(manager->loghelper, OSGI_LOGSERVICE_DEBUG, "TOPOLOGY_MANAGER: Ignore myself.");
-            continue;
-        }
+		bundle_pt bundle = NULL, self = NULL;
+		bundleContext_getBundle(info->context, &bundle);
+		bundleContext_getBundle(manager->context, &self);
+		if (bundle == self) {
+			logHelper_log(manager->loghelper, OSGI_LOGSERVICE_DEBUG, "TOPOLOGY_MANAGER: Ignore myself.");
+			continue;
+		}
 
-        logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: listener with filter \"%s\" removed.", info->filter);
+		logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: listener with filter \"%s\" removed.", info->filter);
 
-        char *filter = NULL;
-        topologyManager_extendFilter(manager, info->filter, &filter);
+		char *filter = NULL;
+		topologyManager_extendFilter(manager, info->filter, &filter);
 #if 0
-        status = celixThreadMutex_lock(&manager->importScopesLock);
-
-        struct scope *interest = hashMap_get(manager->importScopes, filter);
-        if (interest != NULL && --interest->refs <= 0) {
-            // last reference, remove from scope
-            hash_map_entry_pt entry = hashMap_getEntry(manager->importScopes, filter);
-            char* key = (char*) hashMapEntry_getKey(entry);
-            interest = hashMap_remove(manager->importScopes, filter);
-            free(key);
-            free(interest);
-        }
+		status = celixThreadMutex_lock(&manager->importScopesLock);
+
+		struct scope *interest = hashMap_get(manager->importScopes, filter);
+		if (interest != NULL && --interest->refs <= 0) {
+			// last reference, remove from scope
+			hash_map_entry_pt entry = hashMap_getEntry(manager->importScopes, filter);
+			char* key = (char*) hashMapEntry_getKey(entry);
+			interest = hashMap_remove(manager->importScopes, filter);
+			free(key);
+			free(interest);
+		}
 #endif
 
-        if (filter != NULL) {
-            free(filter);
-        }
+		if (filter != NULL) {
+			free(filter);
+		}
 #if 0
-        status = celixThreadMutex_unlock(&manager->importScopesLock);
+		status = celixThreadMutex_unlock(&manager->importScopesLock);
 #endif
-    }
+	}
 
-    return status;
+	return status;
 }
 

http://git-wip-us.apache.org/repos/asf/celix/blob/777b8311/remote_shell/private/src/connection_listener.c
----------------------------------------------------------------------
diff --git a/remote_shell/private/src/connection_listener.c b/remote_shell/private/src/connection_listener.c
index 4083935..3bef9e5 100644
--- a/remote_shell/private/src/connection_listener.c
+++ b/remote_shell/private/src/connection_listener.c
@@ -120,6 +120,7 @@ static void* connection_listener_thread(void *data) {
 	connection_listener_pt instance = data;
 	struct timeval timeout; /* Timeout for select */
 	fd_set active_fd_set;
+	FD_ZERO(&active_fd_set);
 	int listenSocket = 0;
 	int on = 1;
 
@@ -209,7 +210,7 @@ static void* connection_listener_thread(void *data) {
 		}
 	}
 
-	if (listenSocket > 0) {
+	if (listenSocket >= 0) {
 		close(listenSocket);
 	}
 

http://git-wip-us.apache.org/repos/asf/celix/blob/777b8311/utils/private/src/hash_map.c
----------------------------------------------------------------------
diff --git a/utils/private/src/hash_map.c b/utils/private/src/hash_map.c
index 177cf0d..ea41e3a 100644
--- a/utils/private/src/hash_map.c
+++ b/utils/private/src/hash_map.c
@@ -489,16 +489,13 @@ bool hashMapValues_contains(hash_map_values_pt values, void * value) {
 
 void hashMapValues_toArray(hash_map_values_pt values, void* *array[], unsigned int *size) {
 	hash_map_iterator_pt it;
-	int i;
+	int i = 0;
 	int vsize = hashMapValues_size(values);
 	*size = vsize;
 	*array = malloc(vsize * sizeof(*array));
 	it = hashMapValues_iterator(values);
-	for (i = 0; i < vsize; i++) {
-		if (!hashMapIterator_hasNext(it)) {
-			return;
-		}
-		(*array)[i] = hashMapIterator_nextValue(it);
+	while(hashMapIterator_hasNext(it) && i<vsize){
+		(*array)[i++] = hashMapIterator_nextValue(it);
 	}
 	hashMapIterator_destroy(it);
 }


Mime
View raw message