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:[email protected]";>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:[email protected]";>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:[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 "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:[email protected]";>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:[email protected]";>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:[email protected]";>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:[email protected]";>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:[email protected]";>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:[email protected]";>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_ */
