celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [15/46] celix git commit: CELIX-417: Initial refactoring for CMake usage
Date Mon, 20 Nov 2017 20:33:12 GMT
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/framework_private.h
----------------------------------------------------------------------
diff --git a/framework/src/framework_private.h b/framework/src/framework_private.h
new file mode 100644
index 0000000..124a4b6
--- /dev/null
+++ b/framework/src/framework_private.h
@@ -0,0 +1,145 @@
+/**
+ *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.
+ */
+/*
+ * framework_private.h
+ *
+ *  \date       May 22, 2013
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+
+#ifndef FRAMEWORK_PRIVATE_H_
+#define FRAMEWORK_PRIVATE_H_
+
+#include "framework.h"
+
+#include "manifest.h"
+#include "wire.h"
+#include "hash_map.h"
+#include "array_list.h"
+#include "celix_errno.h"
+#include "service_factory.h"
+#include "bundle_archive.h"
+#include "service_listener.h"
+#include "bundle_listener.h"
+#include "framework_listener.h"
+#include "service_registration.h"
+#include "bundle_context.h"
+#include "bundle_cache.h"
+#include "celix_log.h"
+
+#include "celix_threads.h"
+
+struct framework {
+#ifdef WITH_APR
+    apr_pool_t *pool;
+#endif
+    struct bundle * bundle;
+    hash_map_pt installedBundleMap;
+    hash_map_pt installRequestMap;
+    array_list_pt serviceListeners;
+    array_list_pt frameworkListeners;
+
+    array_list_pt bundleListeners;
+    celix_thread_mutex_t bundleListenerLock;
+
+    long nextBundleId;
+    struct serviceRegistry * registry;
+    bundle_cache_pt cache;
+
+    celix_thread_cond_t shutdownGate;
+    celix_thread_cond_t condition;
+
+    celix_thread_mutex_t installedBundleMapLock;
+    celix_thread_mutex_t installRequestLock;
+    celix_thread_mutex_t mutex;
+    celix_thread_mutex_t bundleLock;
+
+    celix_thread_t globalLockThread;
+    array_list_pt globalLockWaitersList;
+    int globalLockCount;
+
+    bool interrupted;
+    bool shutdown;
+
+    properties_pt configurationMap;
+
+    array_list_pt requests;
+    celix_thread_cond_t dispatcher;
+    celix_thread_mutex_t dispatcherLock;
+    celix_thread_t dispatcherThread;
+    celix_thread_t shutdownThread;
+
+    framework_logger_pt logger;
+};
+
+celix_status_t framework_start(framework_pt framework);
+void framework_stop(framework_pt framework);
+
+FRAMEWORK_EXPORT celix_status_t fw_getProperty(framework_pt framework, const char* name, const char* defaultValue, const char** value);
+
+FRAMEWORK_EXPORT celix_status_t fw_installBundle(framework_pt framework, bundle_pt * bundle, const char * location, const char *inputFile);
+FRAMEWORK_EXPORT celix_status_t fw_uninstallBundle(framework_pt framework, bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t framework_getBundleEntry(framework_pt framework, bundle_pt bundle, const char* name, char** entry);
+
+FRAMEWORK_EXPORT celix_status_t fw_startBundle(framework_pt framework, bundle_pt bundle, int options);
+FRAMEWORK_EXPORT celix_status_t framework_updateBundle(framework_pt framework, bundle_pt bundle, const char* inputFile);
+FRAMEWORK_EXPORT celix_status_t fw_stopBundle(framework_pt framework, bundle_pt bundle, bool record);
+
+FRAMEWORK_EXPORT celix_status_t fw_registerService(framework_pt framework, service_registration_pt * registration, bundle_pt bundle, const char* serviceName, const void* svcObj, properties_pt properties);
+FRAMEWORK_EXPORT celix_status_t fw_registerServiceFactory(framework_pt framework, service_registration_pt * registration, bundle_pt bundle, const char* serviceName, service_factory_pt factory, properties_pt properties);
+FRAMEWORK_EXPORT void fw_unregisterService(service_registration_pt registration);
+
+FRAMEWORK_EXPORT celix_status_t fw_getServiceReferences(framework_pt framework, array_list_pt *references, bundle_pt bundle, const char* serviceName, const char* filter);
+FRAMEWORK_EXPORT celix_status_t framework_ungetServiceReference(framework_pt framework, bundle_pt bundle, service_reference_pt reference);
+FRAMEWORK_EXPORT celix_status_t fw_getService(framework_pt framework, bundle_pt bundle, service_reference_pt reference, const void** service);
+FRAMEWORK_EXPORT celix_status_t framework_ungetService(framework_pt framework, bundle_pt bundle, service_reference_pt reference, bool *result);
+FRAMEWORK_EXPORT celix_status_t fw_getBundleRegisteredServices(framework_pt framework, bundle_pt bundle, array_list_pt *services);
+FRAMEWORK_EXPORT celix_status_t fw_getBundleServicesInUse(framework_pt framework, bundle_pt bundle, array_list_pt *services);
+
+FRAMEWORK_EXPORT void fw_addServiceListener(framework_pt framework, bundle_pt bundle, service_listener_pt listener, const char* filter);
+FRAMEWORK_EXPORT void fw_removeServiceListener(framework_pt framework, bundle_pt bundle, service_listener_pt listener);
+
+FRAMEWORK_EXPORT celix_status_t fw_addBundleListener(framework_pt framework, bundle_pt bundle, bundle_listener_pt listener);
+FRAMEWORK_EXPORT celix_status_t fw_removeBundleListener(framework_pt framework, bundle_pt bundle, bundle_listener_pt listener);
+
+FRAMEWORK_EXPORT celix_status_t fw_addFrameworkListener(framework_pt framework, bundle_pt bundle, framework_listener_pt listener);
+FRAMEWORK_EXPORT celix_status_t fw_removeFrameworkListener(framework_pt framework, bundle_pt bundle, framework_listener_pt listener);
+
+FRAMEWORK_EXPORT void fw_serviceChanged(framework_pt framework, service_event_type_e eventType, service_registration_pt registration, properties_pt oldprops);
+
+FRAMEWORK_EXPORT celix_status_t fw_isServiceAssignable(framework_pt fw, bundle_pt requester, service_reference_pt reference, bool* assignable);
+
+//bundle_archive_t fw_createArchive(long id, char * location);
+//void revise(bundle_archive_t archive, char * location);
+FRAMEWORK_EXPORT celix_status_t getManifest(bundle_archive_pt archive, manifest_pt *manifest);
+
+FRAMEWORK_EXPORT bundle_pt findBundle(bundle_context_pt context);
+FRAMEWORK_EXPORT service_registration_pt findRegistration(service_reference_pt reference);
+
+FRAMEWORK_EXPORT service_reference_pt listToArray(array_list_pt list);
+FRAMEWORK_EXPORT celix_status_t framework_markResolvedModules(framework_pt framework, linked_list_pt wires);
+
+FRAMEWORK_EXPORT array_list_pt framework_getBundles(framework_pt framework);
+FRAMEWORK_EXPORT bundle_pt framework_getBundle(framework_pt framework, const char* location);
+FRAMEWORK_EXPORT bundle_pt framework_getBundleById(framework_pt framework, long id);
+
+#endif /* FRAMEWORK_PRIVATE_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/ioapi.c
----------------------------------------------------------------------
diff --git a/framework/src/ioapi.c b/framework/src/ioapi.c
new file mode 100644
index 0000000..49958f6
--- /dev/null
+++ b/framework/src/ioapi.c
@@ -0,0 +1,235 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+*/
+
+#if (defined(_WIN32))
+        #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "ioapi.h"
+
+voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
+{
+    if (pfilefunc->zfile_func64.zopen64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
+    else
+    {
+        return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
+    }
+}
+
+long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
+{
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
+    else
+    {
+        uLong offsetTruncated = (uLong)offset;
+        if (offsetTruncated != offset)
+            return -1;
+        else
+            return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
+    }
+}
+
+ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
+{
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
+    else
+    {
+        uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
+        if ((tell_uLong) == ((uLong)-1))
+            return (ZPOS64_T)-1;
+        else
+            return tell_uLong;
+    }
+}
+
+void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
+{
+    p_filefunc64_32->zfile_func64.zopen64_file = NULL;
+    p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
+    p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
+    p_filefunc64_32->zfile_func64.ztell64_file = NULL;
+    p_filefunc64_32->zfile_func64.zseek64_file = NULL;
+    p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
+    p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
+    p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
+}
+
+
+
+static voidpf  ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
+static uLong   ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+static uLong   ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
+static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
+static long    ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+static int     ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
+static int     ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
+
+static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
+{
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen(filename, mode_fopen);
+    return file;
+}
+
+static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
+{
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen64((const char*)filename, mode_fopen);
+    return file;
+}
+
+
+static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
+{
+    uLong ret;
+    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
+{
+    uLong ret;
+    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
+{
+    long ret;
+    ret = ftell((FILE *)stream);
+    return ret;
+}
+
+
+static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
+{
+    ZPOS64_T ret;
+    ret = ftello64((FILE *)stream);
+    return ret;
+}
+
+static long ZCALLBACK fseek_file_func (voidpf  opaque, voidpf stream, uLong offset, int origin)
+{
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+    if (fseek((FILE *)stream, offset, fseek_origin) != 0)
+        ret = -1;
+    return ret;
+}
+
+static long ZCALLBACK fseek64_file_func (voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
+{
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+
+    if(fseeko64((FILE *)stream, offset, fseek_origin) != 0)
+                        ret = -1;
+
+    return ret;
+}
+
+
+static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
+{
+    int ret;
+    ret = fclose((FILE *)stream);
+    return ret;
+}
+
+static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
+{
+    int ret;
+    ret = ferror((FILE *)stream);
+    return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell_file = ftell_file_func;
+    pzlib_filefunc_def->zseek_file = fseek_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+void fill_fopen64_filefunc (zlib_filefunc64_def*  pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = fopen64_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell64_file = ftell64_file_func;
+    pzlib_filefunc_def->zseek64_file = fseek64_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/ioapi.h
----------------------------------------------------------------------
diff --git a/framework/src/ioapi.h b/framework/src/ioapi.h
new file mode 100644
index 0000000..8309c4c
--- /dev/null
+++ b/framework/src/ioapi.h
@@ -0,0 +1,200 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         Changes
+
+    Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
+    Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
+               More if/def section may be needed to support other platforms
+    Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
+                          (but you should use iowin32.c for windows instead)
+
+*/
+
+#ifndef _ZLIBIOAPI64_H
+#define _ZLIBIOAPI64_H
+
+#if (!defined(_WIN32)) && (!defined(WIN32))
+
+  // Linux needs this to support file operation on files larger then 4+GB
+  // But might need better if/def to select just the platforms that needs them.
+
+        #ifndef __USE_FILE_OFFSET64
+                #define __USE_FILE_OFFSET64
+        #endif
+        #ifndef __USE_LARGEFILE64
+                #define __USE_LARGEFILE64
+        #endif
+        #ifndef _LARGEFILE64_SOURCE
+                #define _LARGEFILE64_SOURCE
+        #endif
+        #ifndef _FILE_OFFSET_BIT
+                #define _FILE_OFFSET_BIT 64
+        #endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "zlib.h"
+
+#if defined(USE_FILE32API)
+#define fopen64 fopen
+#define ftello64 ftell
+#define fseeko64 fseek
+#else
+#ifdef _MSC_VER
+ #define fopen64 fopen
+ #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
+  #define ftello64 _ftelli64
+  #define fseeko64 _fseeki64
+ #else // old MSC
+  #define ftello64 ftell
+  #define fseeko64 fseek
+ #endif
+#endif
+#endif
+
+/*
+#ifndef ZPOS64_T
+  #ifdef _WIN32
+                #define ZPOS64_T fpos_t
+  #else
+    #include <stdint.h>
+    #define ZPOS64_T uint64_t
+  #endif
+#endif
+*/
+
+#ifdef HAVE_MINIZIP64_CONF_H
+#include "mz64conf.h"
+#endif
+
+/* a type choosen by DEFINE */
+#ifdef HAVE_64BIT_INT_CUSTOM
+typedef  64BIT_INT_CUSTOM_TYPE ZPOS64_T;
+#else
+#ifdef HAS_STDINT_H
+#include "stdint.h"
+typedef uint64_t ZPOS64_T;
+#else
+
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef unsigned __int64 ZPOS64_T;
+#else
+typedef unsigned long long int ZPOS64_T;
+#endif
+#endif
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ      (1)
+#define ZLIB_FILEFUNC_MODE_WRITE     (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
+
+#define ZLIB_FILEFUNC_MODE_EXISTING (4)
+#define ZLIB_FILEFUNC_MODE_CREATE   (8)
+
+
+#ifndef ZCALLBACK
+ #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+   #define ZCALLBACK CALLBACK
+ #else
+   #define ZCALLBACK
+ #endif
+#endif
+
+
+
+
+typedef voidpf   (ZCALLBACK *open_file_func)      OF((voidpf opaque, const char* filename, int mode));
+typedef uLong    (ZCALLBACK *read_file_func)      OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+typedef uLong    (ZCALLBACK *write_file_func)     OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+typedef int      (ZCALLBACK *close_file_func)     OF((voidpf opaque, voidpf stream));
+typedef int      (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+typedef long     (ZCALLBACK *tell_file_func)      OF((voidpf opaque, voidpf stream));
+typedef long     (ZCALLBACK *seek_file_func)      OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+
+
+/* here is the "old" 32 bits structure structure */
+typedef struct zlib_filefunc_def_s
+{
+    open_file_func      zopen_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell_file_func      ztell_file;
+    seek_file_func      zseek_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc_def;
+
+typedef ZPOS64_T (ZCALLBACK *tell64_file_func)    OF((voidpf opaque, voidpf stream));
+typedef long     (ZCALLBACK *seek64_file_func)    OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+typedef voidpf   (ZCALLBACK *open64_file_func)    OF((voidpf opaque, const void* filename, int mode));
+
+typedef struct zlib_filefunc64_def_s
+{
+    open64_file_func    zopen64_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell64_file_func    ztell64_file;
+    seek64_file_func    zseek64_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc64_def;
+
+void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+
+/* now internal definition, only for zip.c and unzip.h */
+typedef struct zlib_filefunc64_32_def_s
+{
+    zlib_filefunc64_def zfile_func64;
+    open_file_func      zopen32_file;
+    tell_file_func      ztell32_file;
+    seek_file_func      zseek32_file;
+} zlib_filefunc64_32_def;
+
+
+#define ZREAD64(filefunc,filestream,buf,size)     ((*((filefunc).zfile_func64.zread_file))   ((filefunc).zfile_func64.opaque,filestream,buf,size))
+#define ZWRITE64(filefunc,filestream,buf,size)    ((*((filefunc).zfile_func64.zwrite_file))  ((filefunc).zfile_func64.opaque,filestream,buf,size))
+//#define ZTELL64(filefunc,filestream)            ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
+//#define ZSEEK64(filefunc,filestream,pos,mode)   ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
+#define ZCLOSE64(filefunc,filestream)             ((*((filefunc).zfile_func64.zclose_file))  ((filefunc).zfile_func64.opaque,filestream))
+#define ZERROR64(filefunc,filestream)             ((*((filefunc).zfile_func64.zerror_file))  ((filefunc).zfile_func64.opaque,filestream))
+
+voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
+long    call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
+ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
+
+void    fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
+
+#define ZOPEN64(filefunc,filename,mode)         (call_zopen64((&(filefunc)),(filename),(mode)))
+#define ZTELL64(filefunc,filestream)            (call_ztell64((&(filefunc)),(filestream)))
+#define ZSEEK64(filefunc,filestream,pos,mode)   (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/iowin32.c
----------------------------------------------------------------------
diff --git a/framework/src/iowin32.c b/framework/src/iowin32.c
new file mode 100644
index 0000000..6a2a883
--- /dev/null
+++ b/framework/src/iowin32.c
@@ -0,0 +1,389 @@
+/* iowin32.c -- IO base function header for compress/uncompress .zip
+     Version 1.1, February 14h, 2010
+     part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+     For more info read MiniZip_info.txt
+
+*/
+
+#include <stdlib.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+#include "iowin32.h"
+
+#ifndef INVALID_HANDLE_VALUE
+#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
+#endif
+
+#ifndef INVALID_SET_FILE_POINTER
+#define INVALID_SET_FILE_POINTER ((DWORD)-1)
+#endif
+
+voidpf  ZCALLBACK win32_open_file_func  OF((voidpf opaque, const char* filename, int mode));
+uLong   ZCALLBACK win32_read_file_func  OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+uLong   ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+ZPOS64_T ZCALLBACK win32_tell64_file_func  OF((voidpf opaque, voidpf stream));
+long    ZCALLBACK win32_seek64_file_func  OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+int     ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream));
+int     ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream));
+
+typedef struct
+{
+    HANDLE hf;
+    int error;
+} WIN32FILE_IOWIN;
+
+
+static void win32_translate_open_mode(int mode,
+                                      DWORD* lpdwDesiredAccess,
+                                      DWORD* lpdwCreationDisposition,
+                                      DWORD* lpdwShareMode,
+                                      DWORD* lpdwFlagsAndAttributes)
+{
+    *lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0;
+
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+    {
+        *lpdwDesiredAccess = GENERIC_READ;
+        *lpdwCreationDisposition = OPEN_EXISTING;
+        *lpdwShareMode = FILE_SHARE_READ;
+    }
+    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+    {
+        *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+        *lpdwCreationDisposition = OPEN_EXISTING;
+    }
+    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+    {
+        *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+        *lpdwCreationDisposition = CREATE_ALWAYS;
+    }
+}
+
+static voidpf win32_build_iowin(HANDLE hFile)
+{
+    voidpf ret=NULL;
+
+    if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
+    {
+        WIN32FILE_IOWIN w32fiow;
+        w32fiow.hf = hFile;
+        w32fiow.error = 0;
+        ret = malloc(sizeof(WIN32FILE_IOWIN));
+
+        if (ret==NULL)
+            CloseHandle(hFile);
+        else
+            *((WIN32FILE_IOWIN*)ret) = w32fiow;
+    }
+    return ret;
+}
+
+voidpf ZCALLBACK win32_open64_file_func (voidpf opaque,const void* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+
+    return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+
+    return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+
+    return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+
+    return win32_build_iowin(hFile);
+}
+
+
+uLong ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf,uLong size)
+{
+    uLong ret=0;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+
+    if (hFile != NULL)
+    {
+        if (!ReadFile(hFile, buf, size, &ret, NULL))
+        {
+            DWORD dwErr = GetLastError();
+            if (dwErr == ERROR_HANDLE_EOF)
+                dwErr = 0;
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+        }
+    }
+
+    return ret;
+}
+
+
+uLong ZCALLBACK win32_write_file_func (voidpf opaque,voidpf stream,const void* buf,uLong size)
+{
+    uLong ret=0;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+
+    if (hFile != NULL)
+    {
+        if (!WriteFile(hFile, buf, size, &ret, NULL))
+        {
+            DWORD dwErr = GetLastError();
+            if (dwErr == ERROR_HANDLE_EOF)
+                dwErr = 0;
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+        }
+    }
+
+    return ret;
+}
+
+long ZCALLBACK win32_tell_file_func (voidpf opaque,voidpf stream)
+{
+    long ret=-1;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+    if (hFile != NULL)
+    {
+        DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
+        if (dwSet == INVALID_SET_FILE_POINTER)
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = -1;
+        }
+        else
+            ret=(long)dwSet;
+    }
+    return ret;
+}
+
+ZPOS64_T ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream)
+{
+    ZPOS64_T ret= (ZPOS64_T)-1;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream)->hf;
+
+    if (hFile)
+    {
+        LARGE_INTEGER li;
+        li.QuadPart = 0;
+        li.u.LowPart = SetFilePointer(hFile, li.u.LowPart, &li.u.HighPart, FILE_CURRENT);
+        if ( (li.LowPart == 0xFFFFFFFF) && (GetLastError() != NO_ERROR))
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = (ZPOS64_T)-1;
+        }
+        else
+            ret=li.QuadPart;
+    }
+    return ret;
+}
+
+
+long ZCALLBACK win32_seek_file_func (voidpf opaque,voidpf stream,uLong offset,int origin)
+{
+    DWORD dwMoveMethod=0xFFFFFFFF;
+    HANDLE hFile = NULL;
+
+    long ret=-1;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        dwMoveMethod = FILE_CURRENT;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        dwMoveMethod = FILE_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        dwMoveMethod = FILE_BEGIN;
+        break;
+    default: return -1;
+    }
+
+    if (hFile != NULL)
+    {
+        DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
+        if (dwSet == INVALID_SET_FILE_POINTER)
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = -1;
+        }
+        else
+            ret=0;
+    }
+    return ret;
+}
+
+long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream,ZPOS64_T offset,int origin)
+{
+    DWORD dwMoveMethod=0xFFFFFFFF;
+    HANDLE hFile = NULL;
+    long ret=-1;
+
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream)->hf;
+
+    switch (origin)
+    {
+        case ZLIB_FILEFUNC_SEEK_CUR :
+            dwMoveMethod = FILE_CURRENT;
+            break;
+        case ZLIB_FILEFUNC_SEEK_END :
+            dwMoveMethod = FILE_END;
+            break;
+        case ZLIB_FILEFUNC_SEEK_SET :
+            dwMoveMethod = FILE_BEGIN;
+            break;
+        default: return -1;
+    }
+
+    if (hFile)
+    {
+        LARGE_INTEGER* li = (LARGE_INTEGER*)&offset;
+        DWORD dwSet = SetFilePointer(hFile, li->u.LowPart, &li->u.HighPart, dwMoveMethod);
+        if (dwSet == INVALID_SET_FILE_POINTER)
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = -1;
+        }
+        else
+            ret=0;
+    }
+    return ret;
+}
+
+int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream)
+{
+    int ret=-1;
+
+    if (stream!=NULL)
+    {
+        HANDLE hFile;
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+        if (hFile != NULL)
+        {
+            CloseHandle(hFile);
+            ret=0;
+        }
+        free(stream);
+    }
+    return ret;
+}
+
+int ZCALLBACK win32_error_file_func (voidpf opaque,voidpf stream)
+{
+    int ret=-1;
+    if (stream!=NULL)
+    {
+        ret = ((WIN32FILE_IOWIN*)stream) -> error;
+    }
+    return ret;
+}
+
+void fill_win32_filefunc (zlib_filefunc_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen_file = win32_open_file_func;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell_file = win32_tell_file_func;
+    pzlib_filefunc_def->zseek_file = win32_seek_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+
+void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+
+void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/iowin32.h
----------------------------------------------------------------------
diff --git a/framework/src/iowin32.h b/framework/src/iowin32.h
new file mode 100644
index 0000000..0ca0969
--- /dev/null
+++ b/framework/src/iowin32.h
@@ -0,0 +1,28 @@
+/* iowin32.h -- IO base function header for compress/uncompress .zip
+     Version 1.1, February 14h, 2010
+     part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+*/
+
+#include <windows.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+void fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def));
+
+#ifdef __cplusplus
+}
+#endif

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/listener_hook_info_impl.h
----------------------------------------------------------------------
diff --git a/framework/src/listener_hook_info_impl.h b/framework/src/listener_hook_info_impl.h
new file mode 100644
index 0000000..4b45710
--- /dev/null
+++ b/framework/src/listener_hook_info_impl.h
@@ -0,0 +1,34 @@
+/**
+ *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.
+ */
+/*
+ * listener_hook_info_impl.h
+ *
+ *  \date       Oct 28, 2011
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#ifndef LISTENER_HOOK_INFO_IMPL_H_
+#define LISTENER_HOOK_INFO_IMPL_H_
+
+#include "celix_errno.h"
+
+celix_status_t listenerHookInfo_create();
+
+#endif /* LISTENER_HOOK_INFO_IMPL_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/manifest.c
----------------------------------------------------------------------
diff --git a/framework/src/manifest.c b/framework/src/manifest.c
new file mode 100644
index 0000000..29b155a
--- /dev/null
+++ b/framework/src/manifest.c
@@ -0,0 +1,271 @@
+/**
+ *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.
+ */
+/*
+ * manifest.c
+ *
+ *  \date       Jul 5, 2010
+ *  \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 "manifest.h"
+#include "utils.h"
+#include "celix_log.h"
+
+int fpeek(FILE *stream);
+celix_status_t manifest_readAttributes(manifest_pt manifest, properties_pt properties, FILE *file);
+
+celix_status_t manifest_create(manifest_pt *manifest) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	*manifest = malloc(sizeof(**manifest));
+	if (!*manifest) {
+		status = CELIX_ENOMEM;
+	} else {
+		(*manifest)->mainAttributes = properties_create();
+		(*manifest)->attributes = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
+	}
+
+	framework_logIfError(logger, status, NULL, "Cannot create manifest");
+
+	return status;
+}
+
+celix_status_t manifest_destroy(manifest_pt manifest) {
+	if (manifest != NULL) {
+	    properties_destroy(manifest->mainAttributes);
+		hashMap_destroy(manifest->attributes, true, false);
+		manifest->mainAttributes = NULL;
+		manifest->attributes = NULL;
+		free(manifest);
+		manifest = NULL;
+	}
+	return CELIX_SUCCESS;
+}
+
+celix_status_t manifest_createFromFile(const char *filename, manifest_pt *manifest) {
+	celix_status_t status;
+
+	status = manifest_create(manifest);
+
+	if (status == CELIX_SUCCESS) {
+		manifest_read(*manifest, filename);
+	}
+
+	framework_logIfError(logger, status, NULL, "Cannot create manifest from file");
+
+	return status;
+}
+
+void manifest_clear(manifest_pt manifest) {
+
+}
+
+properties_pt manifest_getMainAttributes(manifest_pt manifest) {
+	return manifest->mainAttributes;
+}
+
+celix_status_t manifest_getEntries(manifest_pt manifest, hash_map_pt *map) {
+	*map = manifest->attributes;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t manifest_read(manifest_pt manifest, const char *filename) {
+    celix_status_t status = CELIX_SUCCESS;
+
+	FILE *file = fopen ( filename, "r" );
+	if (file != NULL) {
+		char lbuf[512];
+		char name[512];
+		bool skipEmptyLines = true;
+		char lastline[512];
+		memset(lbuf,0,512);
+		memset(name,0,512);
+		memset(lastline,0,512);
+
+		manifest_readAttributes(manifest, manifest->mainAttributes, file);
+		
+		while (status==CELIX_SUCCESS && fgets(lbuf, sizeof(lbuf), file) != NULL) {
+			properties_pt attributes;
+			int len = strlen(lbuf);
+
+			if (lbuf[--len] != '\n') {
+				status = CELIX_FILE_IO_EXCEPTION;
+				framework_logIfError(logger, status, NULL, "Manifest '%s' line too long", filename);
+				break;
+			}
+			if (len > 0 && lbuf[len - 1] == '\r') {
+				--len;
+			}
+			if (len == 0 && skipEmptyLines) {
+				continue;
+			}
+			skipEmptyLines = false;
+
+			if (strlen(name) == 0) {
+				
+				if ((tolower(lbuf[0]) == 'n') && (tolower(lbuf[1]) == 'a') &&
+					(tolower(lbuf[2]) == 'm') && (tolower(lbuf[3]) == 'e') &&
+					(lbuf[4] == ':') && (lbuf[5] == ' ')) {
+					name[0] = '\0';
+					strncpy(name, lbuf+6, len - 6);
+					name[len - 6] = '\0';
+				} else {
+					status = CELIX_FILE_IO_EXCEPTION;
+					framework_logIfError(logger, status, NULL, "Manifest '%s' invalid format", filename);
+					break;
+				}
+
+				if (fpeek(file) == ' ') {
+					int newlen = len - 6;
+					lastline[0] = '\0';
+					strncpy(lastline, lbuf+6, len - 6);
+					lastline[newlen] = '\0';
+					continue;
+				}
+			} else {
+				int newlen = strlen(lastline) + len;
+				char buf[512];
+				buf[0] = '\0';
+				strcpy(buf, lastline);
+				strncat(buf, lbuf+1, len - 1);
+				buf[newlen] = '\0';
+
+				if (fpeek(file) == ' ') {
+//					lastline = realloc(lastline, strlen(buf) + 1);
+					lastline[0] = '\0';
+					strcpy(lastline, buf);
+					continue;
+				}
+				name[0] = '\0';
+				strcpy(name, buf);
+				name[strlen(buf)] = '\0';
+			}
+
+			attributes = hashMap_get(manifest->attributes, name);
+			if (attributes == NULL) {
+				attributes = properties_create();
+				hashMap_put(manifest->attributes, strdup(name), attributes);
+			}
+			manifest_readAttributes(manifest, attributes, file);
+
+			name[0] = '\0';
+			skipEmptyLines = true;
+		}
+		fclose(file);
+	} else {
+		status = CELIX_FILE_IO_EXCEPTION;
+	}
+
+	framework_logIfError(logger, status, NULL, "Cannot read manifest");
+
+	return status;
+}
+
+void manifest_write(manifest_pt manifest, const char * filename) {
+
+}
+
+const char* manifest_getValue(manifest_pt manifest, const char* name) {
+	const char* val = properties_get(manifest->mainAttributes, name);
+	bool isEmpty = utils_isStringEmptyOrNull(val);
+	return isEmpty ? NULL : val;
+}
+
+int fpeek(FILE *stream) {
+	int c;
+	c = fgetc(stream);
+	ungetc(c, stream);
+	return c;
+}
+
+celix_status_t manifest_readAttributes(manifest_pt manifest, properties_pt properties, FILE *file) {
+	char name[512]; memset(name,0,512);
+	char value[512]; memset(value,0,512);
+	char lastLine[512]; memset(lastLine,0,512);
+	char lbuf[512]; memset(lbuf,0,512);
+
+
+	while (fgets(lbuf, sizeof(lbuf), file ) != NULL ) {
+		int len = strlen(lbuf);
+
+		if (lbuf[--len] != '\n') {
+			printf("MANIFEST: Line too long\n");
+			return CELIX_FILE_IO_EXCEPTION;
+		}
+		if (len > 0 && lbuf[len - 1] == '\r') {
+			--len;
+		}
+		if (len == 0) {
+			break;
+		}
+		
+		if (lbuf[0] == ' ') {
+			char buf[512];
+			buf[0] = '\0';
+
+			// Line continued
+			strcat(buf, lastLine);
+			strncat(buf, lbuf+1, len - 1);
+
+			if (fpeek(file) == ' ') {
+//				lastLine = realloc(lastLine, strlen(buf) + 1);
+				lastLine[0] = '\0';
+				strcpy(lastLine, buf);
+				continue;
+			}
+			value[0] = '\0';
+			strcpy(value, buf);
+		} else {
+	        int i = 0;
+			while (lbuf[i++] != ':') {
+				if (i >= len) {
+					printf("MANIFEST: Invalid header\n");
+					return CELIX_FILE_IO_EXCEPTION;
+				}
+			}
+			if (lbuf[i++] != ' ') {
+				printf("MANIFEST: Invalid header\n");
+				return CELIX_FILE_IO_EXCEPTION;
+			}
+			name[0] = '\0';
+			strncpy(name, lbuf, i - 2);
+			name[i - 2] = '\0';
+			if (fpeek(file) == ' ') {
+				int newlen = len - i;
+				lastLine[0] = '\0';
+				strncpy(lastLine, lbuf+i, len -i);
+				lastLine[newlen] = '\0';
+				continue;
+			}
+			value[0] = '\0';
+			strncpy(value, lbuf+i, len - i);
+			value[len - i] = '\0';
+		}
+
+		properties_set(properties, name, value);
+	}
+
+	return CELIX_SUCCESS;
+}
+

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/manifest_parser.c
----------------------------------------------------------------------
diff --git a/framework/src/manifest_parser.c b/framework/src/manifest_parser.c
new file mode 100644
index 0000000..07b40a8
--- /dev/null
+++ b/framework/src/manifest_parser.c
@@ -0,0 +1,490 @@
+/**
+ *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.
+ */
+/*
+ * manifest_parser.c
+ *
+ *  \date       Jul 12, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "utils.h"
+#include "constants.h"
+#include "manifest_parser.h"
+#include "capability.h"
+#include "requirement.h"
+#include "attribute.h"
+#include "hash_map.h"
+#include "celix_errno.h"
+#include "linked_list_iterator.h"
+#include "celix_log.h"
+
+//FIXME the manifest parser has no destroy function and as result contains memory leaks.
+
+struct manifestParser {
+	module_pt owner;
+	manifest_pt manifest;
+
+	version_pt bundleVersion;
+	char * bundleSymbolicName;
+	linked_list_pt capabilities;
+	linked_list_pt requirements;
+};
+
+static linked_list_pt manifestParser_parseImportHeader(const char* header);
+static linked_list_pt manifestParser_parseExportHeader(module_pt module, const char* header);
+static linked_list_pt manifestParser_parseDelimitedString(const char* value, const char* delim);
+static linked_list_pt manifestParser_parseStandardHeaderClause(const char* clauseString);
+static linked_list_pt manifestParser_parseStandardHeader(const char* header);
+
+celix_status_t manifestParser_create(module_pt owner, manifest_pt manifest, manifest_parser_pt *manifest_parser) {
+	celix_status_t status;
+	manifest_parser_pt parser;
+
+	status = CELIX_SUCCESS;
+	parser = (manifest_parser_pt) malloc(sizeof(*parser));
+	if (parser) {
+		const char * bundleVersion = NULL;
+		const char * bundleSymbolicName = NULL;
+		parser->manifest = manifest;
+		parser->owner = owner;
+
+		bundleVersion = manifest_getValue(manifest, OSGI_FRAMEWORK_BUNDLE_VERSION);
+		if (bundleVersion != NULL) {
+			parser->bundleVersion = NULL;
+			version_createVersionFromString(bundleVersion, &parser->bundleVersion);
+		} else {
+			parser->bundleVersion = NULL;
+			version_createEmptyVersion(&parser->bundleVersion);
+		}
+		bundleSymbolicName = manifest_getValue(manifest, OSGI_FRAMEWORK_BUNDLE_SYMBOLICNAME);
+		if (bundleSymbolicName != NULL) {
+			parser->bundleSymbolicName = (char*)bundleSymbolicName;
+		}
+
+		parser->capabilities = manifestParser_parseExportHeader(owner, manifest_getValue(manifest, OSGI_FRAMEWORK_EXPORT_LIBRARY));
+		parser->requirements = manifestParser_parseImportHeader(manifest_getValue(manifest, OSGI_FRAMEWORK_IMPORT_LIBRARY));
+
+		*manifest_parser = parser;
+
+		status = CELIX_SUCCESS;
+	} else {
+		status = CELIX_ENOMEM;
+	}
+
+	framework_logIfError(logger, status, NULL, "Cannot create manifest parser");
+
+	return status;
+}
+
+celix_status_t manifestParser_destroy(manifest_parser_pt mp) {
+	linkedList_destroy(mp->capabilities);
+	mp->capabilities = NULL;
+	linkedList_destroy(mp->requirements);
+	mp->requirements = NULL;
+	mp->bundleSymbolicName = NULL;
+	version_destroy(mp->bundleVersion);
+	mp->bundleVersion = NULL;
+	mp->manifest = NULL;
+	mp->owner = NULL;
+
+	free(mp);
+
+	return CELIX_SUCCESS;
+}
+
+static linked_list_pt manifestParser_parseDelimitedString(const char * value, const char * delim) {
+	linked_list_pt list;
+
+	if (linkedList_create(&list) == CELIX_SUCCESS) {
+		if (value != NULL) {
+			int CHAR = 1;
+			int DELIMITER = 2;
+			int STARTQUOTE = 4;
+			int ENDQUOTE = 8;
+
+			char buffer[512];
+			int expecting = (CHAR | DELIMITER | STARTQUOTE);
+			unsigned int i;
+
+			buffer[0] = '\0';
+
+			for (i = 0; i < strlen(value); i++) {
+				char c = value[i];
+
+				bool isDelimiter = (strchr(delim, c) != NULL);
+				bool isQuote = (c == '"');
+
+				if (isDelimiter && ((expecting & DELIMITER) > 0)) {
+					linkedList_addElement(list, strdup(buffer));
+					buffer[0] = '\0';
+					expecting = (CHAR | DELIMITER | STARTQUOTE);
+				} else if (isQuote && ((expecting & STARTQUOTE) > 0)) {
+					char tmp[2];
+					tmp[0] = c;
+					tmp[1] = '\0';
+					strcat(buffer, tmp);
+					expecting = CHAR | ENDQUOTE;
+				} else if (isQuote && ((expecting & ENDQUOTE) > 0)) {
+					char tmp[2];
+					tmp[0] = c;
+					tmp[1] = '\0';
+					strcat(buffer, tmp);
+					expecting = (CHAR | STARTQUOTE | DELIMITER);
+				} else if ((expecting & CHAR) > 0) {
+					char tmp[2];
+					tmp[0] = c;
+					tmp[1] = '\0';
+					strcat(buffer, tmp);
+				} else {
+					linkedList_destroy(list);
+					return NULL;
+				}
+			}
+
+			if (strlen(buffer) > 0) {
+				linkedList_addElement(list, strdup(utils_stringTrim(buffer)));
+			}
+		}
+	}
+
+	return list;
+}
+
+static linked_list_pt manifestParser_parseStandardHeaderClause(const char * clauseString) {
+	linked_list_pt paths = NULL;
+	linked_list_pt clause = NULL;
+	linked_list_pt pieces = NULL;
+
+	if(linkedList_create(&paths) != CELIX_SUCCESS){
+		return NULL;
+	}
+
+	pieces = manifestParser_parseDelimitedString(clauseString, ";");
+
+	if (pieces != NULL) {
+		int pathCount = 0;
+		int pieceIdx;
+		hash_map_pt dirsMap = NULL;
+		hash_map_pt attrsMap = NULL;
+		char * sep;
+
+		for (pieceIdx = 0; pieceIdx < linkedList_size(pieces); pieceIdx++) {
+			char * piece = linkedList_get(pieces, pieceIdx);
+			if (strchr(piece, '=') != NULL) {
+				break;
+			} else {
+				linkedList_addElement(paths, strdup(piece));
+				pathCount++;
+			}
+		}
+
+		if (pathCount != 0) {
+
+			dirsMap = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
+			attrsMap = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
+
+			bool failure = false;
+			char *key = NULL;
+			char *value = NULL;
+
+			for (pieceIdx = pathCount; pieceIdx < linkedList_size(pieces) && !failure ; pieceIdx++) {
+				char * sepPtr;
+				char * DIRECTIVE_SEP = ":=";
+				char * ATTRIBUTE_SEP = "=";
+				char * piece = linkedList_get(pieces, pieceIdx);
+				if ((sepPtr = strstr(piece, DIRECTIVE_SEP)) != NULL) {
+					sep = DIRECTIVE_SEP;
+				} else if ((sepPtr = strstr(piece, ATTRIBUTE_SEP)) != NULL) {
+					sep = ATTRIBUTE_SEP;
+				} else {
+					failure=true;
+					break;
+				}
+
+				if (strcmp(sep, DIRECTIVE_SEP) == 0) {
+					// Not implemented
+				}
+				else {
+
+					key = string_ndup(piece, sepPtr - piece);
+					value = strdup(sepPtr+strlen(sep));
+
+					if (value[0] == '"' && value[strlen(value) -1] == '"') {
+						char * oldV = strdup(value);
+						int len = strlen(oldV) - 2;
+						value = (char *) realloc(value, (sizeof(char) * len+1));
+						value[0] = '\0';
+						value = strncpy(value, oldV+1, strlen(oldV) - 2);
+						value[len] = '\0';
+						//check if correct
+						free(oldV);
+					}
+
+					attribute_pt attr = NULL;
+					if (hashMap_containsKey(attrsMap, key)) {
+						failure=true;
+						break;
+					}
+
+					if (attribute_create(key, value, &attr) == CELIX_SUCCESS) {
+						hashMap_put(attrsMap, key, attr);
+					}
+				}
+			}
+
+			if(linkedList_create(&clause) != CELIX_SUCCESS){
+				failure=true;
+			}
+
+			if(failure){
+				hashMap_destroy(dirsMap,false,false);
+
+				hash_map_iterator_pt attrIter = hashMapIterator_create(attrsMap);
+				while(hashMapIterator_hasNext(attrIter)){
+					hash_map_entry_pt entry = hashMapIterator_nextEntry(attrIter);
+					char *mkey = (char*)hashMapEntry_getKey(entry);
+					attribute_pt mattr = (attribute_pt)hashMapEntry_getValue(entry);
+					free(mkey);
+					attribute_destroy(mattr);
+				}
+				hashMapIterator_destroy(attrIter);
+				hashMap_destroy(attrsMap,false,false);
+
+				if(key!=NULL){
+					free(key);
+				}
+				if(value!=NULL){
+					free(value);
+				}
+
+				linked_list_iterator_pt piter = linkedListIterator_create(paths,0);
+				while(linkedListIterator_hasNext(piter)){
+					free(linkedListIterator_next(piter));
+				}
+				linkedListIterator_destroy(piter);
+				linkedList_destroy(paths);
+
+				if(clause!=NULL){
+					linkedList_destroy(clause);
+					clause = NULL;
+				}
+			}
+			else{
+				linkedList_addElement(clause, paths);
+				linkedList_addElement(clause, dirsMap);
+				linkedList_addElement(clause, attrsMap);
+			}
+
+		}
+		else{
+			linkedList_destroy(paths);
+		}
+
+		for(int listIdx = 0; listIdx < linkedList_size(pieces); listIdx++){
+			void * element = linkedList_get(pieces, listIdx);
+			free(element);
+		}
+		linkedList_destroy(pieces);
+	}
+	else{
+		linkedList_destroy(paths);
+	}
+
+	return clause;
+}
+
+static linked_list_pt manifestParser_parseStandardHeader(const char * header) {
+	linked_list_pt clauseStrings = NULL;
+	linked_list_pt completeList = NULL;
+
+	if(header != NULL && strlen(header)==0){
+		return NULL;
+	}
+
+	if (linkedList_create(&completeList) == CELIX_SUCCESS) {
+		if(header!=NULL){
+			char *hdr = strdup(header);
+			clauseStrings = manifestParser_parseDelimitedString(hdr, ",");
+			free(hdr);
+			if (clauseStrings != NULL) {
+				int i;
+				for (i = 0; i < linkedList_size(clauseStrings); i++) {
+					char *clauseString = (char *) linkedList_get(clauseStrings, i);
+					linkedList_addElement(completeList, manifestParser_parseStandardHeaderClause(clauseString));
+					free(clauseString);
+				}
+				linkedList_destroy(clauseStrings);
+			}
+		}
+
+	}
+
+	return completeList;
+}
+
+static linked_list_pt manifestParser_parseImportHeader(const char * header) {
+	linked_list_pt clauses = NULL;
+	linked_list_pt requirements = NULL;
+	bool failure = false;
+
+	int clauseIdx;
+	linked_list_iterator_pt iter;
+	clauses = manifestParser_parseStandardHeader(header);
+	linkedList_create(&requirements);
+
+	for (clauseIdx = 0; clauseIdx < linkedList_size(clauses) && !failure ; clauseIdx++) {
+		linked_list_pt clause = linkedList_get(clauses, clauseIdx);
+
+		linked_list_pt paths = linkedList_get(clause, 0);
+		hash_map_pt directives = linkedList_get(clause, 1);
+		hash_map_pt attributes = linkedList_get(clause, 2);
+
+		int pathIdx;
+		for (pathIdx = 0; pathIdx < linkedList_size(paths) && !failure ; pathIdx++) {
+			attribute_pt name = NULL;
+			requirement_pt req = NULL;
+			char * path = (char *) linkedList_get(paths, pathIdx);
+			if (strlen(path) == 0) {
+				failure = true;
+				break;
+			}
+
+			if (attribute_create(strdup("service"), path, &name) == CELIX_SUCCESS) {
+				char *key = NULL;
+				attribute_getKey(name, &key);
+				hashMap_put(attributes, key, name);
+			}
+
+			requirement_create(directives, attributes, &req);
+			linkedList_addElement(requirements, req);
+		}
+	}
+
+	if(!failure){
+		iter = linkedListIterator_create(clauses, 0);
+		while(linkedListIterator_hasNext(iter)) {
+			linked_list_pt clause = linkedListIterator_next(iter);
+
+			linked_list_pt paths = linkedList_get(clause, 0);
+			linkedList_destroy(paths);
+
+			linkedListIterator_remove(iter);
+			linkedList_destroy(clause);
+		}
+		linkedListIterator_destroy(iter);
+	}
+
+	linkedList_destroy(clauses);
+
+	if(failure){
+		linkedList_destroy(requirements);
+		requirements = NULL;
+	}
+
+	return requirements;
+}
+
+static linked_list_pt manifestParser_parseExportHeader(module_pt module, const char * header) {
+	linked_list_pt clauses = NULL;
+	linked_list_pt capabilities = NULL;
+	int clauseIdx;
+	linked_list_iterator_pt iter;
+	bool failure = false;
+
+	clauses = manifestParser_parseStandardHeader(header);
+	linkedList_create(&capabilities);
+
+	for (clauseIdx = 0; clauseIdx < linkedList_size(clauses) && !failure ; clauseIdx++) {
+		linked_list_pt clause = linkedList_get(clauses, clauseIdx);
+
+		linked_list_pt paths = linkedList_get(clause, 0);
+		hash_map_pt directives = linkedList_get(clause, 1);
+		hash_map_pt attributes = linkedList_get(clause, 2);
+
+		int pathIdx;
+		for (pathIdx = 0; pathIdx < linkedList_size(paths) && !failure ; pathIdx++) {
+			char * path = (char *) linkedList_get(paths, pathIdx);
+			attribute_pt name = NULL;
+			capability_pt cap = NULL;
+			if (strlen(path) == 0) {
+				failure=true;
+				break;
+			}
+
+			if (attribute_create(strdup("service"), path, &name) == CELIX_SUCCESS) {
+				char *key = NULL;
+				attribute_getKey(name, &key);
+				hashMap_put(attributes, key, name);
+			}
+
+			capability_create(module, directives, attributes, &cap);
+			linkedList_addElement(capabilities, cap);
+		}
+	}
+
+	if(!failure){
+		iter = linkedListIterator_create(clauses, 0);
+		while(linkedListIterator_hasNext(iter)) {
+			linked_list_pt clause = linkedListIterator_next(iter);
+
+			linked_list_pt paths = linkedList_get(clause, 0);
+			linkedList_destroy(paths);
+
+			linkedListIterator_remove(iter);
+			linkedList_destroy(clause);
+		}
+		linkedListIterator_destroy(iter);
+	}
+
+	linkedList_destroy(clauses);
+	if(failure){
+		linkedList_destroy(capabilities);
+		capabilities = NULL;
+	}
+
+	return capabilities;
+}
+
+celix_status_t manifestParser_getAndDuplicateSymbolicName(manifest_parser_pt parser, char **symbolicName) {
+	*symbolicName = strndup(parser->bundleSymbolicName, 1024*10);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t manifestParser_getBundleVersion(manifest_parser_pt parser, version_pt *version) {
+	return version_clone(parser->bundleVersion, version);
+}
+
+celix_status_t manifestParser_getCapabilities(manifest_parser_pt parser, linked_list_pt *capabilities) {
+	celix_status_t status;
+
+	status = linkedList_clone(parser->capabilities, capabilities);
+
+	return status;
+}
+
+celix_status_t manifestParser_getRequirements(manifest_parser_pt parser, linked_list_pt *requirements) {
+	celix_status_t status;
+
+	status = linkedList_clone(parser->requirements, requirements);
+
+	return status;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/manifest_parser.h
----------------------------------------------------------------------
diff --git a/framework/src/manifest_parser.h b/framework/src/manifest_parser.h
new file mode 100644
index 0000000..d6b062b
--- /dev/null
+++ b/framework/src/manifest_parser.h
@@ -0,0 +1,45 @@
+/**
+ *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.
+ */
+/*
+ * manifest_parser.h
+ *
+ *  \date       Jul 13, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#ifndef MANIFEST_PARSER_H_
+#define MANIFEST_PARSER_H_
+
+#include "module.h"
+#include "version.h"
+#include "manifest.h"
+#include "linked_list.h"
+
+typedef struct manifestParser * manifest_parser_pt;
+
+celix_status_t manifestParser_create(module_pt owner, manifest_pt manifest, manifest_parser_pt *manifest_parser);
+celix_status_t manifestParser_destroy(manifest_parser_pt mp);
+
+celix_status_t manifestParser_getAndDuplicateSymbolicName(manifest_parser_pt parser, char **symbolicName);
+celix_status_t manifestParser_getBundleVersion(manifest_parser_pt parser, version_pt *version);
+celix_status_t manifestParser_getCapabilities(manifest_parser_pt parser, linked_list_pt *capabilities);
+celix_status_t manifestParser_getRequirements(manifest_parser_pt parser, linked_list_pt *requirements);
+
+#endif /* MANIFEST_PARSER_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/miniunz.c
----------------------------------------------------------------------
diff --git a/framework/src/miniunz.c b/framework/src/miniunz.c
new file mode 100644
index 0000000..c3a9bd1
--- /dev/null
+++ b/framework/src/miniunz.c
@@ -0,0 +1,382 @@
+/*
+   miniunz.c
+   Version 1.1, February 14h, 2010
+   sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications of Unzip for Zip64
+         Copyright (C) 2007-2008 Even Rouault
+
+         Modifications for Zip64 support on both zip and unzip
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+*/
+
+#ifndef _WIN32
+        #ifndef __USE_FILE_OFFSET64
+                #define __USE_FILE_OFFSET64
+        #endif
+        #ifndef __USE_LARGEFILE64
+                #define __USE_LARGEFILE64
+        #endif
+        #ifndef _LARGEFILE64_SOURCE
+                #define _LARGEFILE64_SOURCE
+        #endif
+        #ifndef _FILE_OFFSET_BIT
+                #define _FILE_OFFSET_BIT 64
+        #endif
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#ifdef _WIN32
+#include <sys/utime.h>
+#else
+#include <utime.h>
+#endif
+#include <sys/stat.h>
+
+#include "unzip.h"
+#include "archive.h"
+
+#define CASESENSITIVITY (0)
+#define WRITEBUFFERSIZE (8192)
+#define MAXFILENAME (256)
+
+#ifdef _WIN32
+#define USEWIN32IOAPI
+#include "iowin32.h"
+#include <direct.h>
+#endif
+/*
+  mini unzip, demo of unzip package
+
+  usage :
+  Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir]
+
+  list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
+    if it exists
+*/
+
+
+/* change_file_date : change the date/time of a file
+    filename : the filename of the file where date/time must be modified
+    dosdate : the new date at the MSDos format (4 bytes)
+    tmu_date : the SAME new date at the tm_unz format */
+void change_file_date(const char *filename, uLong dosdate, tm_unz tmu_date)
+{
+#ifdef _WIN32
+  HANDLE hFile;
+  FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
+
+  hFile = CreateFileA(filename,GENERIC_READ | GENERIC_WRITE,
+                      0,NULL,OPEN_EXISTING,0,NULL);
+  GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
+  DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
+  LocalFileTimeToFileTime(&ftLocal,&ftm);
+  SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
+  CloseHandle(hFile);
+#else
+#if defined(unix) || defined(__APPLE__)
+  struct utimbuf ut;
+  struct tm newdate;
+  newdate.tm_sec = tmu_date.tm_sec;
+  newdate.tm_min=tmu_date.tm_min;
+  newdate.tm_hour=tmu_date.tm_hour;
+  newdate.tm_mday=tmu_date.tm_mday;
+  newdate.tm_mon=tmu_date.tm_mon;
+  if (tmu_date.tm_year > 1900)
+      newdate.tm_year=tmu_date.tm_year - 1900;
+  else
+      newdate.tm_year=tmu_date.tm_year ;
+  newdate.tm_isdst=-1;
+
+  ut.actime=ut.modtime=mktime(&newdate);
+  utime(filename,&ut);
+#endif
+#endif
+}
+
+
+/* mymkdir and change_file_date are not 100 % portable
+   As I don't know well Unix, I wait feedback for the unix portion */
+
+int mymkdir(const char *dirname)
+{
+    int ret=0;
+#ifdef _WIN32
+    ret = _mkdir(dirname);
+#else
+#if defined unix || defined __APPLE__
+    ret = mkdir(dirname,0775);
+#endif
+#endif
+    return ret;
+}
+
+int makedir (char *newdir)
+{
+  char *buffer ;
+  char *p;
+  int  len = (int)strlen(newdir);
+
+  if (len <= 0)
+    return 0;
+
+  buffer = (char*)malloc(len+1);
+        if (buffer==NULL)
+        {
+                printf("Error allocating memory\n");
+                return UNZ_INTERNALERROR;
+        }
+  strcpy(buffer,newdir);
+
+  if (buffer[len-1] == '/') {
+    buffer[len-1] = '\0';
+  }
+  if (mymkdir(buffer) == 0)
+    {
+      free(buffer);
+      return 1;
+    }
+
+  p = buffer+1;
+  while (1)
+    {
+      char hold;
+
+      while(*p && *p != '\\' && *p != '/')
+        p++;
+      hold = *p;
+      *p = 0;
+      if ((mymkdir(buffer) == -1) && (errno == ENOENT))
+        {
+          printf("couldn't create directory %s\n",buffer);
+          free(buffer);
+          return 0;
+        }
+      if (hold == 0)
+        break;
+      *p++ = hold;
+    }
+  free(buffer);
+  return 1;
+}
+
+int do_extract_currentfile(unzFile uf, char * revisionRoot) {
+    char filename_inzip[256];
+    char* filename_withoutpath;
+    char* p;
+    int err=UNZ_OK;
+    FILE *fout=NULL;
+    void* buf;
+    uInt size_buf;
+
+    unz_file_info64 file_info;
+    err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
+
+    if (err!=UNZ_OK)
+    {
+        printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
+        return err;
+    }
+
+    size_buf = WRITEBUFFERSIZE;
+    buf = (void*)malloc(size_buf);
+    if (buf==NULL)
+    {
+        printf("Error allocating memory\n");
+        return UNZ_INTERNALERROR;
+    }
+
+    p = filename_withoutpath = filename_inzip;
+    while ((*p) != '\0')
+    {
+        if (((*p)=='/') || ((*p)=='\\'))
+            filename_withoutpath = p+1;
+        p++;
+    }
+
+    if ((*filename_withoutpath)=='\0') {
+		char * dir;
+		dir = (char *)malloc(strlen(revisionRoot) + strlen(filename_inzip) + 2);
+		strcpy(dir, revisionRoot);
+		strcat(dir, "/");
+		strcat(dir, filename_inzip);
+		mymkdir(dir);
+		free(dir);
+    }
+    else
+    {
+        const char* write_filename;
+        int skip=0;
+		int length;
+		char * fWFN;
+        write_filename = filename_inzip;
+
+        length = strlen(write_filename) + strlen(revisionRoot) + 2;
+        fWFN = (char *)malloc(length);
+        strcpy(fWFN, revisionRoot);
+        strcat(fWFN, "/");
+        strcat(fWFN, write_filename);
+
+        err = unzOpenCurrentFile(uf);
+        if (err!=UNZ_OK)
+        {
+            printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
+        }
+
+        if ((skip==0) && (err==UNZ_OK))
+        {
+            fout=fopen64(fWFN,"wb");
+
+            /* some zipfile don't contain directory alone before file */
+            if ((fout==NULL) && (filename_withoutpath!=(char*)filename_inzip))
+            {
+				char * dir;
+				int length;
+                char c=*(filename_withoutpath-1);
+                *(filename_withoutpath-1)='\0';
+                length = strlen(write_filename) + strlen(revisionRoot) + 2;
+                dir = (char *)malloc(length);
+				strcpy(dir, revisionRoot);
+				strcat(dir, "/");
+				strcat(dir, write_filename);
+                makedir(dir);
+                *(filename_withoutpath-1)=c;
+				free(dir);
+                fout=fopen64(fWFN,"wb");
+            }
+
+            if (fout==NULL)
+            {
+                printf("error opening %s\n",write_filename);
+            }
+        }
+
+        if (fout!=NULL)
+        {
+            do
+            {
+                err = unzReadCurrentFile(uf,buf,size_buf);
+                if (err<0)
+                {
+                    printf("error %d with zipfile in unzReadCurrentFile\n",err);
+                    break;
+                }
+                if (err>0)
+                    if (fwrite(buf,err,1,fout)!=1)
+                    {
+                        printf("error in writing extracted file\n");
+                        err=UNZ_ERRNO;
+                        break;
+                    }
+            }
+            while (err>0);
+            if (fout)
+                    fclose(fout);
+
+            if (err==0)
+                change_file_date(fWFN,file_info.dosDate,
+                                 file_info.tmu_date);
+        }
+
+        if (err==UNZ_OK)
+        {
+            err = unzCloseCurrentFile (uf);
+            if (err!=UNZ_OK)
+            {
+                printf("error %d with zipfile in unzCloseCurrentFile\n",err);
+            }
+        }
+        else
+            unzCloseCurrentFile(uf); /* don't lose the error */
+
+		free(fWFN);
+    }
+
+    free(buf);
+    return err;
+}
+
+
+int do_extract(unzFile uf, char * revisionRoot) {
+    uLong i;
+    unz_global_info64 gi;
+    int err;
+
+    err = unzGetGlobalInfo64(uf,&gi);
+    if (err!=UNZ_OK)
+        printf("error %d with zipfile in unzGetGlobalInfo \n",err);
+
+    for (i=0;i<gi.number_entry;i++)
+    {
+        if (do_extract_currentfile(uf, revisionRoot) != UNZ_OK)
+            break;
+
+        if ((i+1)<gi.number_entry)
+        {
+            err = unzGoToNextFile(uf);
+            if (err!=UNZ_OK)
+            {
+                printf("error %d with zipfile in unzGoToNextFile\n",err);
+                break;
+            }
+        }
+    }
+
+    return 0;
+}
+
+celix_status_t extractBundle(const char* bundleName, const char* revisionRoot) {
+    celix_status_t status = CELIX_SUCCESS;
+    char filename_try[MAXFILENAME+16] = "";
+    unzFile uf=NULL;
+
+    if (bundleName!=NULL)
+    {
+
+#        ifdef USEWIN32IOAPI
+        zlib_filefunc64_def ffunc;
+#        endif
+
+        strncpy(filename_try, bundleName,MAXFILENAME-1);
+        /* strncpy doesnt append the trailing NULL, of the string is too long. */
+        filename_try[ MAXFILENAME ] = '\0';
+
+#        ifdef USEWIN32IOAPI
+        fill_win32_filefunc64A(&ffunc);
+        uf = unzOpen2_64(bundleName,&ffunc);
+#        else
+        uf = unzOpen64(bundleName);
+#        endif
+        if (uf==NULL)
+        {
+            strcat(filename_try,".zip");
+#            ifdef USEWIN32IOAPI
+            uf = unzOpen2_64(filename_try,&ffunc);
+#            else
+            uf = unzOpen64(filename_try);
+#            endif
+        }
+    }
+
+    if (uf==NULL)
+    {
+        printf("Cannot open %s or %s.zip\n",bundleName,bundleName);
+        status = CELIX_FILE_IO_EXCEPTION;
+    } else {
+        if (do_extract(uf, (char*)revisionRoot) != 0) {
+            status = CELIX_FILE_IO_EXCEPTION;
+        }
+
+        unzClose(uf);
+    }
+
+    return status;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/module.c
----------------------------------------------------------------------
diff --git a/framework/src/module.c b/framework/src/module.c
new file mode 100644
index 0000000..e81a1ee
--- /dev/null
+++ b/framework/src/module.c
@@ -0,0 +1,281 @@
+/**
+ *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.
+ */
+/*
+ * module.c
+ *
+ *  \date       Jul 19, 2010
+ *  \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 "module.h"
+#include "manifest_parser.h"
+#include "linked_list_iterator.h"
+
+struct module {
+	linked_list_pt capabilities;
+	linked_list_pt requirements;
+	linked_list_pt wires;
+
+	array_list_pt dependentImporters;
+
+	version_pt version;
+	char * symbolicName;
+	bool resolved;
+
+	manifest_pt headerMap;
+	char * id;
+
+	struct bundle * bundle;
+};
+
+module_pt module_create(manifest_pt headerMap, const char * moduleId, bundle_pt bundle) {
+    module_pt module = NULL;
+    manifest_parser_pt mp;
+
+    if (headerMap != NULL) {
+        module = (module_pt) malloc(sizeof(*module));
+        module->headerMap = headerMap;
+        module->id = strdup(moduleId);
+        module->bundle = bundle;
+        module->resolved = false;
+
+        module->dependentImporters = NULL;
+        arrayList_create(&module->dependentImporters);
+
+        if (manifestParser_create(module, headerMap, &mp) == CELIX_SUCCESS) {
+            module->symbolicName = NULL;
+            manifestParser_getAndDuplicateSymbolicName(mp, &module->symbolicName);
+
+            module->version = NULL;
+            manifestParser_getBundleVersion(mp, &module->version);
+
+            module->capabilities = NULL;
+            manifestParser_getCapabilities(mp, &module->capabilities);
+
+            module->requirements = NULL;
+            manifestParser_getRequirements(mp, &module->requirements);
+
+            module->wires = NULL;
+
+            manifestParser_destroy(mp);
+        }
+    }
+
+    return module;
+}
+
+module_pt module_createFrameworkModule(bundle_pt bundle) {
+    module_pt module;
+
+	module = (module_pt) malloc(sizeof(*module));
+	if (module) {
+        module->id = strdup("0");
+        module->symbolicName = strdup("framework");
+        module->version = NULL;
+        version_createVersion(1, 0, 0, "", &module->version);
+
+        linkedList_create(&module->capabilities);
+        linkedList_create(&module->requirements);
+        module->dependentImporters = NULL;
+        arrayList_create(&module->dependentImporters);
+        module->wires = NULL;
+        module->headerMap = NULL;
+        module->resolved = false;
+        module->bundle = bundle;
+	}
+	return module;
+}
+
+void module_destroy(module_pt module) {
+	arrayList_destroy(module->dependentImporters);
+
+	version_destroy(module->version);
+
+	if (module->wires != NULL) {
+        linked_list_iterator_pt iter = linkedListIterator_create(module->wires, 0);
+        while (linkedListIterator_hasNext(iter)) {
+            wire_pt next = linkedListIterator_next(iter);
+            linkedListIterator_remove(iter);
+            wire_destroy(next);
+        }
+        linkedListIterator_destroy(iter);
+        linkedList_destroy(module->wires);
+	}
+
+	if (module->requirements != NULL) {
+	    linked_list_iterator_pt iter = linkedListIterator_create(module->requirements, 0);
+        while (linkedListIterator_hasNext(iter)) {
+            requirement_pt next = linkedListIterator_next(iter);
+            linkedListIterator_remove(iter);
+            requirement_destroy(next);
+        }
+        linkedListIterator_destroy(iter);
+        linkedList_destroy(module->requirements);
+	}
+
+	if (module->capabilities != NULL) {
+	    linked_list_iterator_pt iter = linkedListIterator_create(module->capabilities, 0);
+        while (linkedListIterator_hasNext(iter)) {
+            capability_pt next = linkedListIterator_next(iter);
+            linkedListIterator_remove(iter);
+            capability_destroy(next);
+        }
+        linkedListIterator_destroy(iter);
+        linkedList_destroy(module->capabilities);
+    }
+
+	module->headerMap = NULL;
+
+	free(module->id);
+	free(module->symbolicName);
+	free(module);
+}
+
+wire_pt module_getWire(module_pt module, const char * serviceName) {
+	wire_pt wire = NULL;
+	if (module->wires != NULL) {
+		linked_list_iterator_pt iterator = linkedListIterator_create(module->wires, 0);
+		while (linkedListIterator_hasNext(iterator)) {
+			const char* name;
+			wire_pt next = linkedListIterator_next(iterator);
+			capability_pt cap = NULL;
+			wire_getCapability(next, &cap);
+			capability_getServiceName(cap, &name);
+			if (strcasecmp(name, serviceName) == 0) {
+				wire = next;
+			}
+		}
+		linkedListIterator_destroy(iterator);
+	}
+	return wire;
+}
+
+version_pt module_getVersion(module_pt module) {
+	return module->version;
+}
+
+celix_status_t module_getSymbolicName(module_pt module, const char **symbolicName) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (module == NULL) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	} else {
+		*symbolicName = module->symbolicName;
+	}
+
+	return status;
+}
+
+char * module_getId(module_pt module) {
+	return module->id;
+}
+
+linked_list_pt module_getWires(module_pt module) {
+	return module->wires;
+}
+
+void module_setWires(module_pt module, linked_list_pt wires) {
+    int i = 0;
+    for (i = 0; (module->wires != NULL) && (i < linkedList_size(module->wires)); i++) {
+        wire_pt wire = (wire_pt) linkedList_get(module->wires, i);
+        module_pt exporter = NULL;
+        wire_getExporter(wire, &exporter);
+        module_removeDependentImporter(exporter, module);
+    }
+
+    if (module->wires != NULL) {
+		linked_list_iterator_pt iter = linkedListIterator_create(module->wires, 0);
+		while (linkedListIterator_hasNext(iter)) {
+			wire_pt next = linkedListIterator_next(iter);
+			linkedListIterator_remove(iter);
+			wire_destroy(next);
+		}
+		linkedListIterator_destroy(iter);
+		linkedList_destroy(module->wires);
+	}
+
+	module->wires = wires;
+
+	for (i = 0; (module->wires != NULL) && (i < linkedList_size(module->wires)); i++) {
+        wire_pt wire = (wire_pt) linkedList_get(module->wires, i);
+        module_pt exporter = NULL;
+        wire_getExporter(wire, &exporter);
+        module_addDependentImporter(exporter, module);
+    }
+}
+
+bool module_isResolved(module_pt module) {
+	return module->resolved;
+}
+
+void module_setResolved(module_pt module) {
+	module->resolved = true;
+}
+
+bundle_pt module_getBundle(module_pt module) {
+	return module->bundle;
+}
+
+linked_list_pt module_getRequirements(module_pt module) {
+	return module->requirements;
+}
+
+linked_list_pt module_getCapabilities(module_pt module) {
+	return module->capabilities;
+}
+
+array_list_pt module_getDependentImporters(module_pt module) {
+    return module->dependentImporters;
+}
+
+void module_addDependentImporter(module_pt module, module_pt importer) {
+    if (!arrayList_contains(module->dependentImporters, importer)) {
+        arrayList_add(module->dependentImporters, importer);
+    }
+}
+
+void module_removeDependentImporter(module_pt module, module_pt importer) {
+    arrayList_removeElement(module->dependentImporters, importer);
+}
+
+//----------------------------------------------------
+//TODO add implementation (functions not implemented but already exported)
+array_list_pt module_getDependentRequirers(module_pt module) {
+	return NULL;
+}
+
+void module_addDependentRequirer(module_pt module, module_pt requirer) {
+}
+
+void module_removeDependentRequirer(module_pt module, module_pt requirer) {
+}
+//----------------------------------------------------
+
+array_list_pt module_getDependents(module_pt module) {
+    array_list_pt dependents = NULL;
+    arrayList_create(&dependents);
+
+    arrayList_addAll(dependents, module->dependentImporters);
+
+    return dependents;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/registry_callback_private.h
----------------------------------------------------------------------
diff --git a/framework/src/registry_callback_private.h b/framework/src/registry_callback_private.h
new file mode 100644
index 0000000..146a1d1
--- /dev/null
+++ b/framework/src/registry_callback_private.h
@@ -0,0 +1,42 @@
+/**
+ *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.
+ */
+/*
+ * service_reference_private.h
+ *
+ *  \date       Nov 16, 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+
+#ifndef REGISTRY_CALLBACK_H_
+#define REGISTRY_CALLBACK_H_
+
+#include "celix_errno.h"
+#include "service_reference.h"
+#include "service_registration.h"
+
+typedef struct registry_callback_struct {
+	void *handle;
+    celix_status_t (*getUsingBundles)(void *handle, service_registration_pt reg, array_list_pt *bundles);
+	celix_status_t (*unregister)(void *handle, bundle_pt bundle, service_registration_pt reg);
+	celix_status_t (*modified)(void *handle, service_registration_pt registration, properties_pt oldProperties);
+} registry_callback_t;
+
+#endif /* REGISTRY_CALLBACK_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/requirement.c
----------------------------------------------------------------------
diff --git a/framework/src/requirement.c b/framework/src/requirement.c
new file mode 100644
index 0000000..7ce585c
--- /dev/null
+++ b/framework/src/requirement.c
@@ -0,0 +1,114 @@
+/**
+ *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.
+ */
+/*
+ * requirement.c
+ *
+ *  \date       Jul 12, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+#include <stdlib.h>
+
+#include "requirement_private.h"
+#include "version_range.h"
+#include "attribute.h"
+#include "celix_log.h"
+
+celix_status_t requirement_create(hash_map_pt directives, hash_map_pt attributes, requirement_pt *requirement) {
+	celix_status_t status;
+
+	*requirement = (requirement_pt) malloc(sizeof(**requirement));
+	if (!*requirement) {
+		status = CELIX_ENOMEM;
+	} else {
+		attribute_pt serviceAttribute = NULL;
+		attribute_pt versionAttribute = NULL;
+
+		(*requirement)->attributes = attributes;
+		(*requirement)->directives = directives;
+		(*requirement)->versionRange = NULL;
+
+		serviceAttribute = (attribute_pt) hashMap_get(attributes, "service");
+		status = attribute_getValue(serviceAttribute, &(*requirement)->targetName);
+		if (status == CELIX_SUCCESS) {
+			versionAttribute = (attribute_pt) hashMap_get(attributes, "version");
+			if (versionAttribute != NULL) {
+				char *versionStr = NULL;
+				attribute_getValue(versionAttribute, &versionStr);
+				status = versionRange_parse(versionStr, &(*requirement)->versionRange);
+			} else {
+				status = versionRange_createInfiniteVersionRange(&(*requirement)->versionRange);
+			}
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Cannot create requirement");
+
+	return status;
+}
+
+celix_status_t requirement_destroy(requirement_pt requirement) {
+	hash_map_iterator_pt attrIter = hashMapIterator_create(requirement->attributes);
+	while (hashMapIterator_hasNext(attrIter)) {
+		attribute_pt attr = hashMapIterator_nextValue(attrIter);
+		hashMapIterator_remove(attrIter);
+		attribute_destroy(attr);
+	}
+	hashMapIterator_destroy(attrIter);
+	hashMap_destroy(requirement->attributes, false, false);
+	hashMap_destroy(requirement->directives, false, false);
+
+	requirement->attributes = NULL;
+	requirement->directives = NULL;
+
+	versionRange_destroy(requirement->versionRange);
+	requirement->versionRange = NULL;
+
+	free(requirement);
+
+	return CELIX_SUCCESS;
+}
+
+celix_status_t requirement_getVersionRange(requirement_pt requirement, version_range_pt *range) {
+	*range = requirement->versionRange;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t requirement_getTargetName(requirement_pt requirement, const char **targetName) {
+	*targetName = requirement->targetName;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t requirement_isSatisfied(requirement_pt requirement, capability_pt capability, bool *inRange) {
+	celix_status_t status;
+	version_pt version = NULL;
+	version_range_pt range = NULL;
+
+	status = capability_getVersion(capability, &version);
+	if (status == CELIX_SUCCESS) {
+		status = requirement_getVersionRange(requirement, &range);
+		if (status == CELIX_SUCCESS) {
+			status = versionRange_isInRange(range, version, inRange);
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Cannot check if requirement is satisfied");
+
+	return status;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/framework/src/requirement_private.h
----------------------------------------------------------------------
diff --git a/framework/src/requirement_private.h b/framework/src/requirement_private.h
new file mode 100644
index 0000000..7510110
--- /dev/null
+++ b/framework/src/requirement_private.h
@@ -0,0 +1,40 @@
+/**
+ *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.
+ */
+/*
+ * requirement_private.h
+ *
+ *  \date       Feb 11, 2013
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+
+#ifndef REQUIREMENT_PRIVATE_H_
+#define REQUIREMENT_PRIVATE_H_
+
+#include "requirement.h"
+
+struct requirement {
+	char * targetName;
+	version_range_pt versionRange;
+	hash_map_pt attributes;
+	hash_map_pt directives;
+};
+
+#endif /* REQUIREMENT_PRIVATE_H_ */


Mime
View raw message