celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [03/19] celix git commit: CELIX-417: Refactor for CMake usage in RSA, PSA and Docker. mostly trying to identify the api and common libraries
Date Tue, 21 Nov 2017 20:08:00 GMT
http://git-wip-us.apache.org/repos/asf/celix/blob/2a670f26/remote_services/topology_manager/src/topology_manager.c
----------------------------------------------------------------------
diff --git a/remote_services/topology_manager/src/topology_manager.c b/remote_services/topology_manager/src/topology_manager.c
new file mode 100644
index 0000000..6472b01
--- /dev/null
+++ b/remote_services/topology_manager/src/topology_manager.c
@@ -0,0 +1,985 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * topology_manager.c
+ *
+ *  \date       Sep 29, 2011
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "celixbool.h"
+#include "topology_manager.h"
+#include "bundle_context.h"
+#include "constants.h"
+#include "bundle.h"
+#include "remote_service_admin.h"
+#include "remote_constants.h"
+#include "filter.h"
+#include "listener_hook_service.h"
+#include "utils.h"
+#include "service_reference.h"
+#include "service_registration.h"
+#include "log_service.h"
+#include "log_helper.h"
+#include "topology_manager.h"
+#include "scope.h"
+#include "hash_map.h"
+
+struct topology_manager {
+	bundle_context_pt context;
+
+	celix_thread_mutex_t rsaListLock;
+	celix_thread_mutexattr_t rsaListLockAttr;
+	array_list_pt rsaList;
+
+	celix_thread_mutex_t listenerListLock;
+	hash_map_pt listenerList;
+
+	celix_thread_mutex_t exportedServicesLock;
+	hash_map_pt exportedServices;
+
+	celix_thread_mutex_t importedServicesLock;
+	celix_thread_mutexattr_t importedServicesLockAttr;
+	hash_map_pt importedServices;
+
+	scope_pt scope;
+
+	log_helper_pt loghelper;
+};
+
+celix_status_t topologyManager_exportScopeChanged(void *handle, char *service_name);
+celix_status_t topologyManager_importScopeChanged(void *handle, char *service_name);
+celix_status_t topologyManager_notifyListenersEndpointAdded(topology_manager_pt manager, remote_service_admin_service_pt rsa, array_list_pt registrations);
+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;
+
+	*manager = calloc(1, sizeof(**manager));
+
+	if (!*manager) {
+		return CELIX_ENOMEM;
+	}
+
+	(*manager)->context = context;
+	(*manager)->rsaList = NULL;
+
+	arrayList_create(&(*manager)->rsaList);
+
+
+	celixThreadMutexAttr_create(&(*manager)->rsaListLockAttr);
+	celixThreadMutexAttr_settype(&(*manager)->rsaListLockAttr, CELIX_THREAD_MUTEX_RECURSIVE);
+	celixThreadMutex_create(&(*manager)->rsaListLock, &(*manager)->rsaListLockAttr);
+
+	celixThreadMutexAttr_create(&(*manager)->importedServicesLockAttr);
+	celixThreadMutexAttr_settype(&(*manager)->importedServicesLockAttr, CELIX_THREAD_MUTEX_RECURSIVE);
+	celixThreadMutex_create(&(*manager)->importedServicesLock, &(*manager)->importedServicesLockAttr);
+
+	celixThreadMutex_create(&(*manager)->exportedServicesLock, 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);
+
+	status = scope_scopeCreate(*manager, &(*manager)->scope);
+	scope_setExportScopeChangedCallback((*manager)->scope, topologyManager_exportScopeChanged);
+	scope_setImportScopeChangedCallback((*manager)->scope, topologyManager_importScopeChanged);
+	*scope = (*manager)->scope;
+
+	(*manager)->loghelper = logHelper;
+
+
+	return status;
+}
+
+celix_status_t topologyManager_destroy(topology_manager_pt manager) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	celixThreadMutex_lock(&manager->listenerListLock);
+	hashMap_destroy(manager->listenerList, false, false);
+
+	celixThreadMutex_unlock(&manager->listenerListLock);
+	celixThreadMutex_destroy(&manager->listenerListLock);
+
+	celixThreadMutex_lock(&manager->rsaListLock);
+
+	arrayList_destroy(manager->rsaList);
+
+	celixThreadMutex_unlock(&manager->rsaListLock);
+	celixThreadMutex_destroy(&manager->rsaListLock);
+	celixThreadMutexAttr_destroy(&manager->rsaListLockAttr);
+
+	celixThreadMutex_lock(&manager->exportedServicesLock);
+
+	hashMap_destroy(manager->exportedServices, false, false);
+
+	celixThreadMutex_unlock(&manager->exportedServicesLock);
+	celixThreadMutex_destroy(&manager->exportedServicesLock);
+
+	celixThreadMutex_lock(&manager->importedServicesLock);
+
+	hashMap_destroy(manager->importedServices, false, false);
+
+	celixThreadMutex_unlock(&manager->importedServicesLock);
+	celixThreadMutex_destroy(&manager->importedServicesLock);
+	celixThreadMutexAttr_destroy(&manager->importedServicesLockAttr);
+
+	scope_scopeDestroy(manager->scope);
+	free(manager);
+
+	return status;
+}
+
+celix_status_t topologyManager_closeImports(topology_manager_pt manager) {
+	celix_status_t status;
+
+	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);
+
+		if (imports != NULL) {
+			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);
+
+				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);
+
+			hashMapIterator_remove(iter);
+
+			hashMap_destroy(imports, false, false);
+		}
+	}
+	hashMapIterator_destroy(iter);
+
+	status = celixThreadMutex_unlock(&manager->importedServicesLock);
+
+	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;
+
+	status = bundleContext_getService(manager->context, reference, service);
+
+	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");
+
+	status = celixThreadMutex_lock(&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);
+
+		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);
+
+					if (status == CELIX_SUCCESS) {
+						hash_map_pt imports = hashMapEntry_getValue(entry);
+
+						if (imports == NULL) {
+							imports = hashMap_create(NULL, NULL, NULL, NULL);
+							hashMap_put(manager->importedServices,endpoint,imports);
+						}
+
+						hashMap_put(imports, service, import);
+					}
+				}
+			}
+
+			hashMapIterator_destroy(importedServicesIterator);
+
+			celixThreadMutex_unlock(&manager->importedServicesLock);
+		}
+	}
+
+	// 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);
+
+			while (hashMapIterator_hasNext(exportedServicesIterator)) {
+				hash_map_entry_pt entry = hashMapIterator_nextEntry(exportedServicesIterator);
+				service_reference_pt reference = hashMapEntry_getKey(entry);
+				const char* serviceId = NULL;
+
+				serviceReference_getProperty(reference, OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
+
+				scope_getExportProperties(manager->scope, reference, &serviceProperties);
+
+				array_list_pt endpoints = NULL;
+				status = rsa->exportService(rsa->admin, (char*)serviceId, serviceProperties, &endpoints);
+
+				if (status == CELIX_SUCCESS) {
+					hash_map_pt exports = hashMapEntry_getValue(entry);
+
+					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);
+				}
+			}
+
+			hashMapIterator_destroy(exportedServicesIterator);
+
+			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;
+
+	// Nop...
+
+	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){
+            	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;
+}
+
+
+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;
+
+	const char* export = NULL;
+	const char* serviceId = NULL;
+	serviceReference_getProperty(event->reference, OSGI_RSA_SERVICE_EXPORTED_INTERFACES, &export);
+	serviceReference_getProperty(event->reference, 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, (char*)serviceId);
+		break;
+	case OSGI_FRAMEWORK_SERVICE_EVENT_MODIFIED:
+		status = topologyManager_removeExportedService(manager, event->reference, (char*)serviceId);
+
+		if (status == CELIX_SUCCESS) {
+			status = topologyManager_addExportedService(manager, event->reference, (char*)serviceId);
+		}
+		break;
+	case OSGI_FRAMEWORK_SERVICE_EVENT_UNREGISTERING:
+		status = topologyManager_removeExportedService(manager, event->reference, (char*)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;
+	const 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, OSGI_FRAMEWORK_SERVICE_ID, &serviceId);
+					srvIds[nrFound++] = (char*)serviceId;
+				}
+			}
+		}
+
+		hashMapIterator_destroy(exportedServicesIterator);
+		celixThreadMutex_unlock(&manager->exportedServicesLock);
+
+		if (nrFound > 0) {
+			for (int i = 0; i < nrFound; i++) {
+				// Question: can srvRefs become invalid meanwhile??
+				const 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 topologyManager_addImportedService(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: Add imported service (%s; %s).", endpoint->service, endpoint->id);
+
+	if (celixThreadMutex_lock(&manager->importedServicesLock) == CELIX_SUCCESS) {
+
+		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);
+
+				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);
+	}
+
+
+	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 (imports != NULL && 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 (substatus == CELIX_SUCCESS) {
+						hashMapIterator_remove(importsIter);
+					} else {
+						status = substatus;
+					}
+				}
+				hashMapIterator_destroy(importsIter);
+				hashMapIterator_remove(iter);
+
+				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 topologyManager_removeExportedService(topology_manager_pt manager, service_reference_pt reference, char *serviceId) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	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);
+
+				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);
+				}
+
+				hashMap_remove(exports, rsa);
+				//arrayList_destroy(exportRegistrations);
+				hashMapIterator_destroy(iter);
+				iter = hashMapIterator_create(exports);
+
+			}
+			hashMapIterator_destroy(iter);
+		}
+		exports = hashMap_remove(manager->exportedServices, reference);
+
+		if (exports != NULL) {
+			hashMap_destroy(exports, false, false);
+		}
+
+		celixThreadMutex_unlock(&manager->exportedServicesLock);
+	}
+
+	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;
+
+	export_reference_pt reference = NULL;
+	status = rsa->exportRegistration_getExportReference(export, &reference);
+
+	if (status == CELIX_SUCCESS) {
+		status = rsa->exportReference_getExportedEndpoint(reference, endpoint);
+	}
+
+	free(reference);
+
+	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;
+
+	bundleContext_getService(manager->context, reference, service);
+
+	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;
+	const 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, 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, (char*)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;
+
+	status = topologyManager_endpointListenerRemoved(handle, reference, service);
+
+	if (status == CELIX_SUCCESS) {
+		status = topologyManager_endpointListenerAdded(handle, reference, service);
+	}
+
+	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;
+
+	if (celixThreadMutex_lock(&manager->listenerListLock) == CELIX_SUCCESS) {
+
+		if (hashMap_remove(manager->listenerList, reference)) {
+			logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "EndpointListener Removed");
+		}
+
+		celixThreadMutex_unlock(&manager->listenerListLock);
+	}
+
+	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)) {
+			const char* scope = NULL;
+			endpoint_listener_pt epl = NULL;
+			service_reference_pt reference = hashMapIterator_nextKey(iter);
+
+			serviceReference_getProperty(reference, 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, (char*)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;
+
+	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;
+			const char* scope = NULL;
+
+			service_reference_pt reference = hashMapIterator_nextKey(iter);
+			serviceReference_getProperty(reference, OSGI_ENDPOINT_LISTENER_SCOPE, &scope);
+
+			substatus = bundleContext_getService(manager->context, reference, (void **) &epl);
+
+			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) {
+             status = substatus;
+
+             }
+			 */
+		}
+		hashMapIterator_destroy(iter);
+		celixThreadMutex_unlock(&manager->listenerListLock);
+	}
+
+	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;
+	const char* uuid = NULL;
+
+	status = bundleContext_getProperty(context, OSGI_FRAMEWORK_FRAMEWORK_UUID, &uuid);
+
+	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;
+	}
+
+	snprintf(*updatedFilter, len, "(&%s(!(%s=%s)))", filter, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, uuid);
+
+	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;
+		bool free_filter = true;
+		status = topologyManager_extendFilter(manager, info->filter, &filter);
+#if 0
+		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 (filter != NULL && free_filter) {
+			free(filter);
+		}
+
+	}
+
+	return status;
+}
+
+celix_status_t topologyManager_listenerRemoved(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\" removed.", info->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);
+		}
+#endif
+
+		if (filter != NULL) {
+			free(filter);
+		}
+#if 0
+		status = celixThreadMutex_unlock(&manager->importScopesLock);
+#endif
+	}
+
+	return status;
+}
+

http://git-wip-us.apache.org/repos/asf/celix/blob/2a670f26/remote_services/topology_manager/src/topology_manager.h
----------------------------------------------------------------------
diff --git a/remote_services/topology_manager/src/topology_manager.h b/remote_services/topology_manager/src/topology_manager.h
new file mode 100644
index 0000000..7e5e917
--- /dev/null
+++ b/remote_services/topology_manager/src/topology_manager.h
@@ -0,0 +1,65 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * topology_manager.h
+ *
+ *  \date       Sep 29, 2011
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#ifndef TOPOLOGY_MANAGER_H_
+#define TOPOLOGY_MANAGER_H_
+
+#include "endpoint_listener.h"
+#include "service_reference.h"
+#include "bundle_context.h"
+#include "log_helper.h"
+#include "scope.h"
+
+#define OSGI_RSA_REMOTE_SERVICE_ADMIN "remote_service_admin"
+
+typedef struct topology_manager *topology_manager_pt;
+
+celix_status_t topologyManager_create(bundle_context_pt context, log_helper_pt logHelper, topology_manager_pt *manager, void **scope);
+celix_status_t topologyManager_destroy(topology_manager_pt manager);
+celix_status_t topologyManager_closeImports(topology_manager_pt manager);
+
+celix_status_t topologyManager_rsaAdding(void *handle, service_reference_pt reference, void **service);
+celix_status_t topologyManager_rsaAdded(void *handle, service_reference_pt reference, void *service);
+celix_status_t topologyManager_rsaModified(void *handle, service_reference_pt reference, void *service);
+celix_status_t topologyManager_rsaRemoved(void *handle, service_reference_pt reference, void *service);
+
+celix_status_t topologyManager_endpointListenerAdding(void* handle, service_reference_pt reference, void** service);
+celix_status_t topologyManager_endpointListenerAdded(void* handle, service_reference_pt reference, void* service);
+celix_status_t topologyManager_endpointListenerModified(void * handle, service_reference_pt reference, void* service);
+celix_status_t topologyManager_endpointListenerRemoved(void * handle, service_reference_pt reference, void* service);
+
+celix_status_t topologyManager_serviceChanged(void *listener, service_event_pt event);
+
+celix_status_t topologyManager_addImportedService(void *handle, endpoint_description_pt endpoint, char *matchedFilter);
+celix_status_t topologyManager_removeImportedService(void *handle, endpoint_description_pt endpoint, char *matchedFilter);
+
+celix_status_t topologyManager_addExportedService(topology_manager_pt manager, service_reference_pt reference, char *serviceId);
+celix_status_t topologyManager_removeExportedService(topology_manager_pt manager, service_reference_pt reference, char *serviceId);
+
+celix_status_t topologyManager_listenerAdded(void *handle, array_list_pt listeners);
+celix_status_t topologyManager_listenerRemoved(void *handle, array_list_pt listeners);
+
+#endif /* TOPOLOGY_MANAGER_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/2a670f26/remote_services/topology_manager/tms_tst/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/remote_services/topology_manager/tms_tst/CMakeLists.txt b/remote_services/topology_manager/tms_tst/CMakeLists.txt
index dc671e4..6d0713c 100644
--- a/remote_services/topology_manager/tms_tst/CMakeLists.txt
+++ b/remote_services/topology_manager/tms_tst/CMakeLists.txt
@@ -36,10 +36,8 @@ SET(CMAKE_INSTALL_RPATH "${PROJECT_BINARY_DIR}/framework" "${PROJECT_BINARY_DIR}
 add_executable(test_tm_scoped
     run_tests.cpp
     tms_tests.cpp
-    
-   ${PROJECT_SOURCE_DIR}/remote_services/remote_service_admin/private/src/endpoint_description.c
 )
-target_link_libraries(test_tm_scoped Celix::framework ${CPPUTEST_LIBRARY} ${JANSSON_LIBRARY} Celix::log_helper)
+target_link_libraries(test_tm_scoped Celix::framework ${CPPUTEST_LIBRARY} ${JANSSON_LIBRARY} Celix::log_helper remote_service_admin_common)
 
 add_dependencies(test_tm_scoped remote_service_admin_dfi topology_manager calculator)
 

http://git-wip-us.apache.org/repos/asf/celix/blob/2a670f26/remote_services/topology_manager/tms_tst/bundle/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/remote_services/topology_manager/tms_tst/bundle/CMakeLists.txt b/remote_services/topology_manager/tms_tst/bundle/CMakeLists.txt
index 9e36e4c..fc9d9bf 100644
--- a/remote_services/topology_manager/tms_tst/bundle/CMakeLists.txt
+++ b/remote_services/topology_manager/tms_tst/bundle/CMakeLists.txt
@@ -32,4 +32,4 @@ bundle_files(topology_manager_test_bundle
     DESTINATION .
 )
 
-target_link_libraries(topology_manager_test_bundle PRIVATE ${CPPUTEST_LIBRARY})
+target_link_libraries(topology_manager_test_bundle PRIVATE ${CPPUTEST_LIBRARY} remote_service_admin calculator_api)

http://git-wip-us.apache.org/repos/asf/celix/blob/2a670f26/remote_services/topology_manager/tms_tst/disc_mock/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/remote_services/topology_manager/tms_tst/disc_mock/CMakeLists.txt b/remote_services/topology_manager/tms_tst/disc_mock/CMakeLists.txt
index b961de7..bfd7fc1 100644
--- a/remote_services/topology_manager/tms_tst/disc_mock/CMakeLists.txt
+++ b/remote_services/topology_manager/tms_tst/disc_mock/CMakeLists.txt
@@ -15,14 +15,6 @@
 # specific language governing permissions and limitations
 # under the License.
 
-include_directories(
-        ${CPPUTEST_INCLUDE_DIR}
-        ${PROJECT_SOURCE_DIR}/framework/public/include
-        ${PROJECT_SOURCE_DIR}/utils/public/include
-        ${PROJECT_SOURCE_DIR}/remote_services/discovery/private/include
-)
-
-
 add_bundle(topology_manager_disc_mock_bundle
     VERSION 0.0.1
     SOURCES
@@ -30,4 +22,5 @@ add_bundle(topology_manager_disc_mock_bundle
         disc_mock_service.c
 
 )
-target_link_libraries(topology_manager_disc_mock_bundle PRIVATE ${CPPUTEST_LIBRARY} Celix::framework)
+target_include_directories(topology_manager_disc_mock_bundle PRIVATE ${CPPUTEST_INCLUDE_DIR})
+target_link_libraries(topology_manager_disc_mock_bundle PRIVATE ${CPPUTEST_LIBRARY} Celix::framework discovery_common)

http://git-wip-us.apache.org/repos/asf/celix/blob/2a670f26/remote_services/utils/private/include/civetweb.h
----------------------------------------------------------------------
diff --git a/remote_services/utils/private/include/civetweb.h b/remote_services/utils/private/include/civetweb.h
deleted file mode 100644
index 61a8e98..0000000
--- a/remote_services/utils/private/include/civetweb.h
+++ /dev/null
@@ -1,657 +0,0 @@
-/* Copyright (c) 2013-2014 the Civetweb developers
- * Copyright (c) 2004-2013 Sergey Lyubka
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef CIVETWEB_HEADER_INCLUDED
-#define CIVETWEB_HEADER_INCLUDED
-
-#ifndef CIVETWEB_VERSION
-#define CIVETWEB_VERSION "1.7"
-#endif
-
-#ifndef CIVETWEB_API
-    #if defined(_WIN32)
-        #if defined(CIVETWEB_DLL_EXPORTS)
-            #define CIVETWEB_API __declspec(dllexport)
-        #elif defined(CIVETWEB_DLL_IMPORTS)
-            #define CIVETWEB_API __declspec(dllimport)
-        #else
-            #define CIVETWEB_API
-        #endif
-    #else
-        #define CIVETWEB_API
-    #endif
-#endif
-
-#include <stdio.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-struct mg_context;     /* Handle for the HTTP service itself */
-struct mg_connection;  /* Handle for the individual connection */
-
-
-/* This structure contains information about the HTTP request. */
-struct mg_request_info {
-    const char *request_method; /* "GET", "POST", etc */
-    const char *uri;            /* URL-decoded URI */
-    const char *http_version;   /* E.g. "1.0", "1.1" */
-    const char *query_string;   /* URL part after '?', not including '?', or
-                                   NULL */
-    const char *remote_user;    /* Authenticated user, or NULL if no auth
-                                   used */
-    char remote_addr[48];       /* Client's IP address as a string. */
-    long remote_ip;             /* Client's IP address. Deprecated: use remote_addr instead */
-
-    long long content_length;   /* Length (in bytes) of the request body,
-                                   can be -1 if no length was given. */
-    int remote_port;            /* Client's port */
-    int is_ssl;                 /* 1 if SSL-ed, 0 if not */
-    void *user_data;            /* User data pointer passed to mg_start() */
-    void *conn_data;            /* Connection-specific user data */
-
-    int num_headers;            /* Number of HTTP headers */
-    struct mg_header {
-        const char *name;       /* HTTP header name */
-        const char *value;      /* HTTP header value */
-    } http_headers[64];         /* Maximum 64 headers */
-};
-
-
-/* This structure needs to be passed to mg_start(), to let civetweb know
-   which callbacks to invoke. For a detailed description, see
-   https://github.com/bel2125/civetweb/blob/master/docs/UserManual.md */
-struct mg_callbacks {
-    /* Called when civetweb has received new HTTP request.
-       If the callback returns one, it must process the request
-       by sending valid HTTP headers and a body. Civetweb will not do
-       any further processing. Otherwise it must return zero.
-       Note that since V1.7 the "begin_request" function is called
-       before an authorization check. If an authorization check is
-       required, use a request_handler instead.
-       Return value:
-         0: civetweb will process the request itself. In this case,
-            the callback must not send any data to the client.
-         1: callback already processed the request. Civetweb will
-            not send any data after the callback returned. */
-    int  (*begin_request)(struct mg_connection *);
-
-    /* Called when civetweb has finished processing request. */
-    void (*end_request)(const struct mg_connection *, int reply_status_code);
-
-    /* Called when civetweb is about to log a message. If callback returns
-       non-zero, civetweb does not log anything. */
-    int  (*log_message)(const struct mg_connection *, const char *message);
-
-    /* Called when civetweb initializes SSL library.
-       Parameters:
-         user_data: parameter user_data passed when starting the server.
-       Return value:
-         0: civetweb will set up the SSL certificate.
-         1: civetweb assumes the callback already set up the certificate.
-        -1: initializing ssl fails. */
-    int  (*init_ssl)(void *ssl_context, void *user_data);
-
-    /* Called when websocket request is received, before websocket handshake.
-       Return value:
-         0: civetweb proceeds with websocket handshake.
-         1: connection is closed immediately. */
-    int (*websocket_connect)(const struct mg_connection *);
-
-    /* Called when websocket handshake is successfully completed, and
-       connection is ready for data exchange. */
-    void (*websocket_ready)(struct mg_connection *);
-
-    /* Called when data frame has been received from the client.
-       Parameters:
-         bits: first byte of the websocket frame, see websocket RFC at
-               http://tools.ietf.org/html/rfc6455, section 5.2
-         data, data_len: payload, with mask (if any) already applied.
-       Return value:
-         1: keep this websocket connection open.
-         0: close this websocket connection. */
-    int  (*websocket_data)(struct mg_connection *, int bits,
-                           char *data, size_t data_len);
-
-    /* Called when civetweb is closing a connection.  The per-context mutex is
-       locked when this is invoked.  This is primarily useful for noting when
-       a websocket is closing and removing it from any application-maintained
-       list of clients. */
-    void (*connection_close)(struct mg_connection *);
-
-    /* Called when civetweb tries to open a file. Used to intercept file open
-       calls, and serve file data from memory instead.
-       Parameters:
-          path:     Full path to the file to open.
-          data_len: Placeholder for the file size, if file is served from
-                    memory.
-       Return value:
-         NULL: do not serve file from memory, proceed with normal file open.
-         non-NULL: pointer to the file contents in memory. data_len must be
-           initilized with the size of the memory block. */
-    const char * (*open_file)(const struct mg_connection *,
-                              const char *path, size_t *data_len);
-
-    /* Called when civetweb is about to serve Lua server page, if
-       Lua support is enabled.
-       Parameters:
-         lua_context: "lua_State *" pointer. */
-    void (*init_lua)(struct mg_connection *, void *lua_context);
-
-    /* Called when civetweb has uploaded a file to a temporary directory as a
-       result of mg_upload() call.
-       Parameters:
-         file_name: full path name to the uploaded file. */
-    void (*upload)(struct mg_connection *, const char *file_name);
-
-    /* Called when civetweb is about to send HTTP error to the client.
-       Implementing this callback allows to create custom error pages.
-       Parameters:
-         status: HTTP error status code.
-       Return value:
-         1: run civetweb error handler.
-         0: callback already handled the error. */
-    int  (*http_error)(struct mg_connection *, int status);
-
-    /* Called after civetweb context has been created, before requests
-       are processed.
-       Parameters:
-         ctx: context handle */
-    void (*init_context)(struct mg_context * ctx);
-
-    /* Called when civetweb context is deleted.
-       Parameters:
-         ctx: context handle */
-    void (*exit_context)(struct mg_context * ctx);
-};
-
-
-/* Start web server.
-
-   Parameters:
-     callbacks: mg_callbacks structure with user-defined callbacks.
-     options: NULL terminated list of option_name, option_value pairs that
-              specify Civetweb configuration parameters.
-
-   Side-effects: on UNIX, ignores SIGCHLD and SIGPIPE signals. If custom
-      processing is required for these, signal handlers must be set up
-      after calling mg_start().
-
-
-   Example:
-     const char *options[] = {
-       "document_root", "/var/www",
-       "listening_ports", "80,443s",
-       NULL
-     };
-     struct mg_context *ctx = mg_start(&my_func, NULL, options);
-
-   Refer to https://github.com/bel2125/civetweb/blob/master/docs/UserManual.md
-   for the list of valid option and their possible values.
-
-   Return:
-     web server context, or NULL on error. */
-CIVETWEB_API struct mg_context *mg_start(const struct mg_callbacks *callbacks,
-                            void *user_data,
-                            const char **configuration_options);
-
-
-/* Stop the web server.
-
-   Must be called last, when an application wants to stop the web server and
-   release all associated resources. This function blocks until all Civetweb
-   threads are stopped. Context pointer becomes invalid. */
-CIVETWEB_API void mg_stop(struct mg_context *);
-
-
-/* mg_request_handler
-
-   Called when a new request comes in.  This callback is URI based
-   and configured with mg_set_request_handler().
-
-   Parameters:
-      conn: current connection information.
-      cbdata: the callback data configured with mg_set_request_handler().
-   Returns:
-      0: the handler could not handle the request, so fall through.
-      1: the handler processed the request. */
-typedef int (* mg_request_handler)(struct mg_connection *conn, void *cbdata);
-
-
-/* mg_set_request_handler
-
-   Sets or removes a URI mapping for a request handler.
-
-   URI's are ordered and prefixed URI's are supported. For example,
-   consider two URIs: /a/b and /a
-           /a   matches /a
-           /a/b matches /a/b
-           /a/c matches /a
-
-   Parameters:
-      ctx: server context
-      uri: the URI to configure
-      handler: the callback handler to use when the URI is requested.
-               If NULL, the URI will be removed.
-      cbdata: the callback data to give to the handler when it s requested. */
-CIVETWEB_API void mg_set_request_handler(struct mg_context *ctx, const char *uri, mg_request_handler handler, void *cbdata);
-
-
-/* Get the value of particular configuration parameter.
-   The value returned is read-only. Civetweb does not allow changing
-   configuration at run time.
-   If given parameter name is not valid, NULL is returned. For valid
-   names, return value is guaranteed to be non-NULL. If parameter is not
-   set, zero-length string is returned. */
-CIVETWEB_API const char *mg_get_option(const struct mg_context *ctx, const char *name);
-
-
-/* Get context from connection. */
-CIVETWEB_API struct mg_context *mg_get_context(struct mg_connection *conn);
-
-
-/* Get user data passed to mg_start from context. */
-CIVETWEB_API void *mg_get_user_data(struct mg_context *ctx);
-
-
-#if defined(MG_LEGACY_INTERFACE)
-/* Return array of strings that represent valid configuration options.
-   For each option, option name and default value is returned, i.e. the
-   number of entries in the array equals to number_of_options x 2.
-   Array is NULL terminated. */
-/* Deprecated: Use mg_get_valid_options instead. */
-CIVETWEB_API const char **mg_get_valid_option_names(void);
-#endif
-
-
-struct mg_option {
-    const char * name;
-    int type;
-    const char * default_value;
-};
-
-enum {
-    CONFIG_TYPE_UNKNOWN = 0x0,
-    CONFIG_TYPE_NUMBER = 0x1,
-    CONFIG_TYPE_STRING = 0x2,
-    CONFIG_TYPE_FILE = 0x3,
-    CONFIG_TYPE_DIRECTORY = 0x4,
-    CONFIG_TYPE_BOOLEAN = 0x5,
-    CONFIG_TYPE_EXT_PATTERN = 0x6
-};
-
-
-/* Return array of struct mg_option, representing all valid configuration
-   options of civetweb.c.
-   The array is terminated by a NULL name option. */
-CIVETWEB_API const struct mg_option *mg_get_valid_options(void);
-
-
-/* Get the list of ports that civetweb is listening on.
-   size is the size of the ports int array and ssl int array to fill.
-   It is the caller's responsibility to make sure ports and ssl each
-   contain at least size int elements worth of memory to write into.
-   Return value is the number of ports and ssl information filled in.
-   The value returned is read-only. Civetweb does not allow changing
-   configuration at run time. */
-CIVETWEB_API size_t mg_get_ports(const struct mg_context *ctx, size_t size, int* ports, int* ssl);
-
-
-/* Add, edit or delete the entry in the passwords file.
-
-   This function allows an application to manipulate .htpasswd files on the
-   fly by adding, deleting and changing user records. This is one of the
-   several ways of implementing authentication on the server side. For another,
-   cookie-based way please refer to the examples/chat in the source tree.
-
-   If password is not NULL, entry is added (or modified if already exists).
-   If password is NULL, entry is deleted.
-
-   Return:
-     1 on success, 0 on error. */
-CIVETWEB_API int mg_modify_passwords_file(const char *passwords_file_name,
-                                          const char *domain,
-                                          const char *user,
-                                          const char *password);
-
-
-/* Return information associated with the request. */
-CIVETWEB_API struct mg_request_info *mg_get_request_info(struct mg_connection *);
-
-
-/* Send data to the client.
-   Return:
-    0   when the connection has been closed
-    -1  on error
-    >0  number of bytes written on success */
-CIVETWEB_API int mg_write(struct mg_connection *, const void *buf, size_t len);
-
-
-/* Send data to a websocket client wrapped in a websocket frame.  Uses mg_lock
-   to ensure that the transmission is not interrupted, i.e., when the
-   application is proactively communicating and responding to a request
-   simultaneously.
-
-   Send data to a websocket client wrapped in a websocket frame.
-   This function is available when civetweb is compiled with -DUSE_WEBSOCKET
-
-   Return:
-    0   when the connection has been closed
-    -1  on error
-    >0  number of bytes written on success */
-CIVETWEB_API int mg_websocket_write(struct mg_connection* conn, int opcode,
-                                    const char *data, size_t data_len);
-
-
-/* Blocks until unique access is obtained to this connection. Intended for use
-   with websockets only.
-   Invoke this before mg_write or mg_printf when communicating with a
-   websocket if your code has server-initiated communication as well as
-   communication in direct response to a message. */
-CIVETWEB_API void mg_lock_connection(struct mg_connection* conn);
-CIVETWEB_API void mg_unlock_connection(struct mg_connection* conn);
-
-#if defined(MG_LEGACY_INTERFACE)
-#define mg_lock mg_lock_connection
-#define mg_unlock mg_unlock_connection
-#endif
-
-/* Lock server context.  This lock may be used to protect ressources
-   that are shared between different connection/worker threads. */
-CIVETWEB_API void mg_lock_context(struct mg_context* ctx);
-CIVETWEB_API void mg_unlock_context(struct mg_context* ctx);
-
-
-/* Opcodes, from http://tools.ietf.org/html/rfc6455 */
-enum {
-    WEBSOCKET_OPCODE_CONTINUATION = 0x0,
-    WEBSOCKET_OPCODE_TEXT = 0x1,
-    WEBSOCKET_OPCODE_BINARY = 0x2,
-    WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8,
-    WEBSOCKET_OPCODE_PING = 0x9,
-    WEBSOCKET_OPCODE_PONG = 0xa
-};
-
-
-/* Macros for enabling compiler-specific checks forprintf-like arguments. */
-#undef PRINTF_FORMAT_STRING
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-#include <sal.h>
-#if defined(_MSC_VER) && _MSC_VER > 1400
-#define PRINTF_FORMAT_STRING(s) _Printf_format_string_ s
-#else
-#define PRINTF_FORMAT_STRING(s) __format_string s
-#endif
-#else
-#define PRINTF_FORMAT_STRING(s) s
-#endif
-
-#ifdef __GNUC__
-#define PRINTF_ARGS(x, y) __attribute__((format(printf, x, y)))
-#else
-#define PRINTF_ARGS(x, y)
-#endif
-
-/* Send data to the client usingprintf() semantics.
-   Works exactly like mg_write(), but allows to do message formatting. */
-CIVETWEB_API int mg_printf(struct mg_connection *,
-                           PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
-
-
-/* Send contents of the entire file together with HTTP headers. */
-CIVETWEB_API void mg_send_file(struct mg_connection *conn, const char *path);
-
-
-/* Read data from the remote end, return number of bytes read.
-   Return:
-     0     connection has been closed by peer. No more data could be read.
-     < 0   read error. No more data could be read from the connection.
-     > 0   number of bytes read into the buffer. */
-CIVETWEB_API int mg_read(struct mg_connection *, void *buf, size_t len);
-
-
-/* Get the value of particular HTTP header.
-
-   This is a helper function. It traverses request_info->http_headers array,
-   and if the header is present in the array, returns its value. If it is
-   not present, NULL is returned. */
-CIVETWEB_API const char *mg_get_header(const struct mg_connection *, const char *name);
-
-
-/* Get a value of particular form variable.
-
-   Parameters:
-     data: pointer to form-uri-encoded buffer. This could be either POST data,
-           or request_info.query_string.
-     data_len: length of the encoded data.
-     var_name: variable name to decode from the buffer
-     dst: destination buffer for the decoded variable
-     dst_len: length of the destination buffer
-
-   Return:
-     On success, length of the decoded variable.
-     On error:
-        -1 (variable not found).
-        -2 (destination buffer is NULL, zero length or too small to hold the
-            decoded variable).
-
-   Destination buffer is guaranteed to be '\0' - terminated if it is not
-   NULL or zero length. */
-CIVETWEB_API int mg_get_var(const char *data, size_t data_len,
-                            const char *var_name, char *dst, size_t dst_len);
-
-
-/* Get a value of particular form variable.
-
-   Parameters:
-     data: pointer to form-uri-encoded buffer. This could be either POST data,
-           or request_info.query_string.
-     data_len: length of the encoded data.
-     var_name: variable name to decode from the buffer
-     dst: destination buffer for the decoded variable
-     dst_len: length of the destination buffer
-     occurrence: which occurrence of the variable, 0 is the first, 1 the
-                 second...
-                this makes it possible to parse a query like
-                b=x&a=y&a=z which will have occurrence values b:0, a:0 and a:1
-
-   Return:
-     On success, length of the decoded variable.
-     On error:
-        -1 (variable not found).
-        -2 (destination buffer is NULL, zero length or too small to hold the
-            decoded variable).
-
-   Destination buffer is guaranteed to be '\0' - terminated if it is not
-   NULL or zero length. */
-CIVETWEB_API int mg_get_var2(const char *data, size_t data_len,
-                             const char *var_name, char *dst, size_t dst_len, size_t occurrence);
-
-
-/* Fetch value of certain cookie variable into the destination buffer.
-
-   Destination buffer is guaranteed to be '\0' - terminated. In case of
-   failure, dst[0] == '\0'. Note that RFC allows many occurrences of the same
-   parameter. This function returns only first occurrence.
-
-   Return:
-     On success, value length.
-     On error:
-        -1 (either "Cookie:" header is not present at all or the requested
-            parameter is not found).
-        -2 (destination buffer is NULL, zero length or too small to hold the
-            value). */
-CIVETWEB_API int mg_get_cookie(const char *cookie, const char *var_name,
-                               char *buf, size_t buf_len);
-
-
-/* Download data from the remote web server.
-     host: host name to connect to, e.g. "foo.com", or "10.12.40.1".
-     port: port number, e.g. 80.
-     use_ssl: wether to use SSL connection.
-     error_buffer, error_buffer_size: error message placeholder.
-     request_fmt,...: HTTP request.
-   Return:
-     On success, valid pointer to the new connection, suitable for mg_read().
-     On error, NULL. error_buffer contains error message.
-   Example:
-     char ebuf[100];
-     struct mg_connection *conn;
-     conn = mg_download("google.com", 80, 0, ebuf, sizeof(ebuf),
-                        "%s", "GET / HTTP/1.0\r\nHost: google.com\r\n\r\n");
- */
-CIVETWEB_API struct mg_connection *mg_download(const char *host, int port, int use_ssl,
-                                               char *error_buffer, size_t error_buffer_size,
-                                               PRINTF_FORMAT_STRING(const char *request_fmt),
-                                               ...) PRINTF_ARGS(6, 7);
-
-
-/* Close the connection opened by mg_download(). */
-CIVETWEB_API void mg_close_connection(struct mg_connection *conn);
-
-
-/* File upload functionality. Each uploaded file gets saved into a temporary
-   file and MG_UPLOAD event is sent.
-   Return number of uploaded files. */
-CIVETWEB_API int mg_upload(struct mg_connection *conn, const char *destination_dir);
-
-
-/* Convenience function -- create detached thread.
-   Return: 0 on success, non-0 on error. */
-typedef void * (*mg_thread_func_t)(void *);
-CIVETWEB_API int mg_start_thread(mg_thread_func_t f, void *p);
-
-
-/* Return builtin mime type for the given file name.
-   For unrecognized extensions, "text/plain" is returned. */
-CIVETWEB_API const char *mg_get_builtin_mime_type(const char *file_name);
-
-
-/* Return Civetweb version. */
-CIVETWEB_API const char *mg_version(void);
-
-
-/* URL-decode input buffer into destination buffer.
-   0-terminate the destination buffer.
-   form-url-encoded data differs from URI encoding in a way that it
-   uses '+' as character for space, see RFC 1866 section 8.2.1
-   http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt
-   Return: length of the decoded data, or -1 if dst buffer is too small. */
-CIVETWEB_API int mg_url_decode(const char *src, int src_len, char *dst,
-                               int dst_len, int is_form_url_encoded);
-
-
-/* URL-encode input buffer into destination buffer.
-   returns the length of the resulting buffer or -1
-   is the buffer is too small. */
-CIVETWEB_API int mg_url_encode(const char *src, char *dst, size_t dst_len);
-
-
-/* MD5 hash given strings.
-   Buffer 'buf' must be 33 bytes long. Varargs is a NULL terminated list of
-   ASCIIz strings. When function returns, buf will contain human-readable
-   MD5 hash. Example:
-     char buf[33];
-     mg_md5(buf, "aa", "bb", NULL); */
-CIVETWEB_API char *mg_md5(char buf[33], ...);
-
-
-/* Print error message to the opened error log stream.
-   This utilizes the provided logging configuration.
-     conn: connection
-     fmt: format string without the line return
-     ...: variable argument list
-   Example:
-     mg_cry(conn,"i like %s", "logging"); */
-CIVETWEB_API void mg_cry(struct mg_connection *conn,
-                         PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
-
-
-/* utility method to compare two buffers, case incensitive. */
-CIVETWEB_API int mg_strncasecmp(const char *s1, const char *s2, size_t len);
-
-/* Connect to a websocket as a client
-   Parameters:
-     host: host to connect to, i.e. "echo.websocket.org" or "192.168.1.1" or "localhost"
-     port: server port
-     use_ssl: make a secure connection to server
-     error_buffer, error_buffer_size: buffer for an error message
-     path: server path you are trying to connect to, i.e. if connection to localhost/app, path should be "/app"
-     origin: value of the Origin HTTP header
-     data_func: callback that should be used when data is received from the server
-     user_data: user supplied argument
-
-   Return:
-     On success, valid mg_connection object.
-     On error, NULL. Se error_buffer for details.
-*/
-
-typedef int  (*websocket_data_func)(struct mg_connection *, int bits,
-                           char *data, size_t data_len);
-
-typedef void (*websocket_close_func)(struct mg_connection *);
-
-CIVETWEB_API struct mg_connection *mg_connect_websocket_client(const char *host, int port, int use_ssl,
-                                               char *error_buffer, size_t error_buffer_size,
-                                               const char *path, const char *origin,
-                                               websocket_data_func data_func, websocket_close_func close_func,
-                                               void * user_data);
-
-/* Connect to a TCP server as a client (can be used to connect to a HTTP server)
-   Parameters:
-     host: host to connect to, i.e. "www.wikipedia.org" or "192.168.1.1" or "localhost"
-     port: server port
-     use_ssl: make a secure connection to server
-     error_buffer, error_buffer_size: buffer for an error message
-
-   Return:
-     On success, valid mg_connection object.
-     On error, NULL. Se error_buffer for details.
-*/
-CIVETWEB_API struct mg_connection *mg_connect_client(const char *host, int port, int use_ssl,
-                                               char *error_buffer, size_t error_buffer_size);
-
-
-enum {
-    TIMEOUT_INFINITE = -1
-};
-
-/* Wait for a response from the server
-   Parameters:
-     conn: connection
-     ebuf, ebuf_len: error message placeholder.
-     timeout: time to wait for a response in milliseconds (if < 0 then wait forever)
-
-   Return:
-     On success, >= 0
-     On error/timeout, < 0
-*/
-CIVETWEB_API int mg_get_response(struct mg_connection *conn, char *ebuf, size_t ebuf_len, int timeout);
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* CIVETWEB_HEADER_INCLUDED */


Mime
View raw message