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:[email protected]";>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, ®); + 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:[email protected]";>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 */
