Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-02-03 14:01
📄 apc.h /* +----------------------------------------------------------------------+ \| APC \| +----------------------------------------------------------------------+ \| Copyright (c) 2006-2011 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Authors: Daniel Cowgill <dcowgill@communityconnect.com> \| \| George Schlossnagle <george@omniti.com> \| \| Rasmus Lerdorf <rasmus@php.net> \| \| Arun C. Murthy <arunc@yahoo-inc.com> \| \| Gopal Vijayaraghavan <gopalv@yahoo-inc.com> \| +----------------------------------------------------------------------+ This software was contributed to PHP by Community Connect Inc. in 2002 and revised in 2005 by Yahoo! Inc. to add support for PHP 5.1. Future revisions and derivatives of this source code must acknowledge Community Connect Inc. as the original contributor of this module by leaving this note intact in the source code. All other licensing and usage conditions are those of the PHP Group. / / $Id: apc.h 328292 2012-11-09 07:05:17Z laruence $ / #ifndef APC_H #define APC_H / * This module defines utilities and helper functions used elsewhere in APC. / #ifdef PHP_WIN32 # define PHP_APCU_API __declspec(dllexport) #elif defined(__GNUC__) && __GNUC__ >= 4 # define PHP_APCU_API __attribute__ ((visibility("default"))) #else # define PHP_APCU_API #endif / Commonly needed C library headers. / #include <assert.h> #include <errno.h> #include <stdarg.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> / UNIX headers (needed for struct stat) / #include <sys/types.h> #include <sys/stat.h> #ifndef PHP_WIN32 #include <unistd.h> #endif #ifdef HAVE_CONFIG_H #include <config.h> #endif #include "php.h" #include "main/php_streams.h" / typedefs for extensible memory allocators / typedef void (apc_malloc_t)(size_t TSRMLS_DC); typedef void (apc_free_t) (void * TSRMLS_DC); /* wrappers for memory allocation routines / PHP_APCU_API void apc_emalloc(size_t n TSRMLS_DC); PHP_APCU_API void* apc_erealloc(void* p, size_t n TSRMLS_DC); PHP_APCU_API void* apc_php_malloc(size_t n TSRMLS_DC); PHP_APCU_API void apc_php_free(void* p TSRMLS_DC); PHP_APCU_API void apc_efree(void* p TSRMLS_DC); PHP_APCU_API char* apc_estrdup(const char* s TSRMLS_DC); PHP_APCU_API void* apc_xstrdup(const char* s, apc_malloc_t f TSRMLS_DC); PHP_APCU_API void* apc_xmemcpy(const void* p, size_t n, apc_malloc_t f TSRMLS_DC); /* console display functions / PHP_APCU_API void apc_error(const char format TSRMLS_DC, ...); PHP_APCU_API void apc_warning(const char format TSRMLS_DC, ...); PHP_APCU_API void apc_notice(const char format TSRMLS_DC, ...); PHP_APCU_API void apc_debug(const char format TSRMLS_DC, ...); / string and text manipulation / PHP_APCU_API char apc_append(const char* s, const char* t TSRMLS_DC); PHP_APCU_API char* apc_substr(const char* s, int start, int length TSRMLS_DC); PHP_APCU_API char** apc_tokenize(const char* s, char delim TSRMLS_DC); /* apc_crc32: returns the CRC-32 checksum of the first len bytes in buf / PHP_APCU_API unsigned int apc_crc32(const unsigned char buf, unsigned int len); /* apc_flip_hash flips keys and values for faster searching / PHP_APCU_API HashTable apc_flip_hash(HashTable hash); #define APC_NEGATIVE_MATCH 1 #define APC_POSITIVE_MATCH 2 #define apc_time() \ (APCG(use_request_time) ? (time_t) sapi_get_request_time(TSRMLS_C) : time(0)); #if defined(__GNUC__) # define APC_UNUSED __attribute__((unused)) # define APC_USED __attribute__((used)) # define APC_ALLOC __attribute__((malloc)) # if __GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ > 2) # define APC_HOTSPOT __attribute__((hot)) # else # define APC_HOTSPOT # endif #else # define APC_UNUSED # define APC_USED # define APC_ALLOC # define APC_HOTSPOT #endif / * Serializer API / #define APC_SERIALIZER_ABI "0" #define APC_SERIALIZER_CONSTANT "\000apc_register_serializer-" APC_SERIALIZER_ABI #define APC_SERIALIZER_NAME(module) module##_apc_serializer #define APC_UNSERIALIZER_NAME(module) module##_apc_unserializer #define APC_SERIALIZER_ARGS unsigned char buf, size_t buf_len, const zval value, void config TSRMLS_DC #define APC_UNSERIALIZER_ARGS zval *value, unsigned char buf, size_t buf_len, void config TSRMLS_DC typedef int (apc_serialize_t)(APC_SERIALIZER_ARGS); typedef int (apc_unserialize_t)(APC_UNSERIALIZER_ARGS); / {{{ struct definition: apc_serializer_t / typedef struct apc_serializer_t { const char name; apc_serialize_t serialize; apc_unserialize_t unserialize; void* config; } apc_serializer_t; /* }}} / / {{{ _apc_register_serializer registers the serializer using the given name and paramters / PHP_APCU_API int _apc_register_serializer(const char name, apc_serialize_t serialize, apc_unserialize_t unserialize, void config TSRMLS_DC); / }}} / / {{{ apc_get_serializers fetches the list of serializers / PHP_APCU_API apc_serializer_t apc_get_serializers(TSRMLS_D); /* }}} / / {{{ apc_find_serializer finds a previously registered serializer by name / PHP_APCU_API apc_serializer_t apc_find_serializer(const char* name TSRMLS_DC); /* }}} / / {{{ default serializers / PHP_APCU_API int APC_SERIALIZER_NAME(php) (APC_SERIALIZER_ARGS); PHP_APCU_API int APC_UNSERIALIZER_NAME(php) (APC_UNSERIALIZER_ARGS); / }}} / / {{{ eval serializers / PHP_APCU_API int APC_SERIALIZER_NAME(eval) (APC_SERIALIZER_ARGS); PHP_APCU_API int APC_UNSERIALIZER_NAME(eval) (APC_UNSERIALIZER_ARGS); / }}} / #endif / * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: expandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: expandtab sw=4 ts=4 sts=4 */	6.58 KB	2024-08-04 15:31
📄 apc_api.h /* +----------------------------------------------------------------------+ \| APCu \| +----------------------------------------------------------------------+ \| Copyright (c) 2013 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Joe Watkins <joe.watkins@live.co.uk> \| +----------------------------------------------------------------------+ */ #ifndef APC_API_H #define APC_API_H #include "apc.h" #include "apc_lock_api.h" #include "apc_pool_api.h" #include "apc_sma_api.h" #include "apc_cache_api.h" #include "apc_bin_api.h" #endif	1.29 KB	2024-08-04 15:31
📄 apc_bin_api.h /* +----------------------------------------------------------------------+ \| APC \| +----------------------------------------------------------------------+ \| Copyright (c) 2006-2011 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Authors: Brian Shire <shire@php.net> \| +----------------------------------------------------------------------+ / / $Id: apc_bin_api.h 328743 2012-12-12 07:58:32Z ab $ / #ifndef APC_BIN_API_H #define APC_BIN_API_H #include "ext/standard/basic_functions.h" / APC binload flags / #define APC_BIN_VERIFY_MD5 1 << 0 #define APC_BIN_VERIFY_CRC32 1 << 1 typedef struct _apc_bd_entry_t { unsigned char type; uint num_functions; uint num_classes; struct { char str; uint len; } key; apc_cache_entry_t val; } apc_bd_entry_t; typedef struct _apc_bd_t { unsigned int size; int swizzled; unsigned char md5[16]; php_uint32 crc; unsigned int num_entries; apc_bd_entry_t entries; int num_swizzled_ptrs; void *swizzled_ptrs; } apc_bd_t; PHP_APCU_API apc_bd_t apc_bin_dump(apc_cache_t* cache, HashTable user_vars TSRMLS_DC); PHP_APCU_API int apc_bin_load(apc_cache_t cache, apc_bd_t bd, int flags TSRMLS_DC); #endif / * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim600: expandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: expandtab sw=4 ts=4 sts=4 */	2.11 KB	2024-08-04 15:31
📄 apc_cache_api.h /* +----------------------------------------------------------------------+ \| APC \| +----------------------------------------------------------------------+ \| Copyright (c) 2006-2011 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt. \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Authors: Daniel Cowgill <dcowgill@communityconnect.com> \| \| Rasmus Lerdorf <rasmus@php.net> \| +----------------------------------------------------------------------+ This software was contributed to PHP by Community Connect Inc. in 2002 and revised in 2005 by Yahoo! Inc. to add support for PHP 5.1. Future revisions and derivatives of this source code must acknowledge Community Connect Inc. as the original contributor of this module by leaving this note intact in the source code. All other licensing and usage conditions are those of the PHP Group. / / $Id: apc_cache.h 328172 2012-10-28 21:44:47Z rasmus $ / #ifndef APC_CACHE_API_H #define APC_CACHE_API_H / {{{ used for slam defense to determine the context which created any key / #ifdef ZTS typedef void** apc_cache_owner_t; #else typedef pid_t apc_cache_owner_t; #endif /* }}} / / {{{ struct definition: apc_cache_key_t / typedef struct apc_cache_key_t apc_cache_key_t; struct apc_cache_key_t { const char str; /* pointer to constant string key / zend_uint len; / length of data at str / zend_ulong h; / pre-computed hash of key / time_t mtime; / the mtime of this cached entry / apc_cache_owner_t owner; / the context that created this key / }; / }}} / / {{{ struct definition: apc_cache_entry_t / typedef struct apc_cache_entry_t apc_cache_entry_t; struct apc_cache_entry_t { zval val; /* the zval copied at store time / zend_uint ttl; / the ttl on this specific entry / int ref_count; / the reference count of this entry / size_t mem_size; / memory used / apc_pool pool; /* pool which allocated the value / }; / }}} / / {{{ struct definition: apc_cache_slot_t / typedef struct apc_cache_slot_t apc_cache_slot_t; struct apc_cache_slot_t { apc_cache_key_t key; / slot key / apc_cache_entry_t value; /* slot value / apc_cache_slot_t next; /* next slot in linked list / zend_ulong nhits; / number of hits to this slot / time_t ctime; / time slot was initialized / time_t dtime; / time slot was removed from cache / time_t atime; / time slot was last accessed / }; / }}} / / {{{ state constants / #define APC_CACHE_ST_NONE 0 #define APC_CACHE_ST_BUSY 0x00000001 / }}} / / {{{ struct definition: apc_cache_header_t Any values that must be shared among processes should go in here. / typedef struct _apc_cache_header_t { apc_lock_t lock; / header lock / zend_ulong nhits; / hit count / zend_ulong nmisses; / miss count / zend_ulong ninserts; / insert count / zend_ulong nexpunges; / expunge count / zend_ulong nentries; / entry count / zend_ulong mem_size; / used / time_t stime; / start time / zend_ushort state; / cache state / apc_cache_key_t lastkey; / last key inserted (not necessarily without error) / apc_cache_slot_t gc; /* gc list / } apc_cache_header_t; / }}} / / {{{ struct definition: apc_cache_t / typedef struct _apc_cache_t { void shmaddr; /* process (local) address of shared cache / apc_cache_header_t header; /* cache header (stored in SHM) / apc_cache_slot_t* slots; /* array of cache slots (stored in SHM) / apc_sma_t sma; /* shared memory allocator / apc_serializer_t serializer; /* serializer / zend_ulong nslots; / number of slots in cache / zend_ulong gc_ttl; / maximum time on GC list for a slot / zend_ulong ttl; / if slot is needed and entry's access time is older than this ttl, remove it / zend_ulong smart; / smart parameter for gc / zend_bool defend; / defense parameter for runtime / } apc_cache_t; / }}} / / {{{ typedef: apc_cache_updater_t / typedef zend_bool (apc_cache_updater_t)(apc_cache_t, apc_cache_entry_t, void* data); /* }}} / / * apc_cache_create creates the shared memory cache. * * This function should be called once per process per cache * * serializer for APCu is set by globals on MINIT and ensured with apc_cache_serializer * during execution. Using apc_cache_serializer avoids race conditions between MINIT/RINIT of * APCU and the third party serializer. API users can choose to leave this null to use default * PHP serializers, or search the list of serializers for the preferred serializer * * size_hint is a "hint" at the total number entries that will be expected. * It determines the physical size of the hash table. Passing 0 for * this argument will use a reasonable default value * * gc_ttl is the maximum time a cache entry may speed on the garbage * collection list. This is basically a work around for the inherent * unreliability of our reference counting mechanism (see apc_cache_release). * * ttl is the maximum time a cache entry can idle in a slot in case the slot * is needed. This helps in cleaning up the cache and ensuring that entries * hit frequently stay cached and ones not hit very often eventually disappear. * * for an explanation of smart, see apc_cache_default_expunge * * defend enables/disables slam defense for this particular cache / PHP_APCU_API apc_cache_t apc_cache_create(apc_sma_t* sma, apc_serializer_t* serializer, int size_hint, int gc_ttl, int ttl, long smart, zend_bool defend TSRMLS_DC); /* * apc_cache_preload preloads the data at path into the specified cache / PHP_APCU_API zend_bool apc_cache_preload(apc_cache_t cache, const char* path TSRMLS_DC); /* * apc_cache_destroy releases any OS resources associated with a cache object. * Under apache, this function can be safely called by the child processes * when they exit. / PHP_APCU_API void apc_cache_destroy(apc_cache_t cache TSRMLS_DC); /* * apc_cache_clear empties a cache. This can safely be called at any time. / PHP_APCU_API void apc_cache_clear(apc_cache_t cache TSRMLS_DC); /* * apc_cache_make_context initializes a context with an appropriate pool and options provided * * Some of the APC API requires a context in which to operate * * The type of context required depends on the operation being performed, for example * an insert should happen in a shared context, a fetch should happen in a nonshared context / PHP_APCU_API zend_bool apc_cache_make_context(apc_cache_t cache, apc_context_t* context, apc_context_type context_type, apc_pool_type pool_type, apc_copy_type copy_type, uint force_update TSRMLS_DC); /* * apc_cache_make_context_ex is an advanced/external version of make_context / PHP_APCU_API zend_bool apc_cache_make_context_ex(apc_context_t context, apc_serializer_t* serializer, apc_malloc_t _malloc, apc_free_t _free, apc_protect_t _protect, apc_unprotect_t _unprotect, apc_pool_type pool_type, apc_copy_type copy_type, uint force_update TSRMLS_DC); /* * apc_context_destroy should be called when a context is finished being used / PHP_APCU_API zend_bool apc_cache_destroy_context(apc_context_t context TSRMLS_DC); /* * apc_cache_insert adds an entry to the cache. * Returns true if the entry was successfully inserted, false otherwise. * If false is returned, the caller must free the cache entry by calling * apc_cache_free_entry (see below). * * key is the value created by apc_cache_make_key * * value is a cache entry returned by apc_cache_make_entry (see below). * * an easier API exists in the form of apc_cache_store / PHP_APCU_API zend_bool apc_cache_insert(apc_cache_t cache, apc_cache_key_t key, apc_cache_entry_t* value, apc_context_t* ctxt, time_t t, zend_bool exclusive TSRMLS_DC); /* * apc_cache_store creates key, entry and context in which to make an insertion of val into the specified cache / PHP_APCU_API zend_bool apc_cache_store(apc_cache_t cache, char strkey, zend_uint keylen, const zval val, const zend_uint ttl, const zend_bool exclusive TSRMLS_DC); /* * apc_cache_update updates an entry in place, this is used for rfc1867 and inc/dec/cas / PHP_APCU_API zend_bool apc_cache_update(apc_cache_t cache, char strkey, zend_uint keylen, apc_cache_updater_t updater, void data TSRMLS_DC); /* * apc_cache_find searches for a cache entry by its hashed identifier, * and returns a pointer to the entry if found, NULL otherwise. * / PHP_APCU_API apc_cache_entry_t apc_cache_find(apc_cache_t* cache, char* strkey, zend_uint keylen, time_t t TSRMLS_DC); /* * apc_cache_fetch fetches an entry from the cache directly into dst * / PHP_APCU_API zend_bool apc_cache_fetch(apc_cache_t cache, char* strkey, zend_uint keylen, time_t t, zval *dst TSRMLS_DC); / * apc_cache_exists searches for a cache entry by its hashed identifier, * and returns a pointer to the entry if found, NULL otherwise. This is a * quick non-locking version of apc_cache_find that does not modify the * shared memory segment in any way. * / PHP_APCU_API apc_cache_entry_t apc_cache_exists(apc_cache_t* cache, char* strkey, zend_uint keylen, time_t t TSRMLS_DC); /* * apc_cache_delete and apc_cache_delete finds an entry in the cache and deletes it. / PHP_APCU_API zend_bool apc_cache_delete(apc_cache_t cache, char strkey, zend_uint keylen TSRMLS_DC); / apc_cach_fetch_zval takes a zval in the cache and reconstructs a runtime * zval from it. * / PHP_APCU_API zval apc_cache_fetch_zval(apc_context_t* ctxt, zval* dst, const zval* src TSRMLS_DC); /* * apc_cache_release decrements the reference count associated with a cache * entry. Calling apc_cache_find automatically increments the reference count, * and this function must be called post-execution to return the count to its * original value. Failing to do so will prevent the entry from being * garbage-collected. * * entry is the cache entry whose ref count you want to decrement. / PHP_APCU_API void apc_cache_release(apc_cache_t cache, apc_cache_entry_t* entry TSRMLS_DC); /* * apc_cache_make_key creates an apc_cache_key_t from an identifier, it's length and the current time / PHP_APCU_API zend_bool apc_cache_make_key(apc_cache_key_t key, char* str, zend_ulong len TSRMLS_DC); /* * apc_cache_make_entry creates an apc_cache_entry_t given a zval, context and ttl / PHP_APCU_API apc_cache_entry_t apc_cache_make_entry(apc_context_t* ctxt, apc_cache_key_t* key, const zval val, const zend_uint ttl TSRMLS_DC); / fetches information about the cache provided for userland status functions / PHP_APCU_API zval apc_cache_info(apc_cache_t* cache, zend_bool limited TSRMLS_DC); /* fetches information about the key provided / PHP_APCU_API zval apc_cache_stat(apc_cache_t* cache, char strkey, zend_uint keylen TSRMLS_DC); / * apc_cache_busy returns true while the cache is busy * * a cache is considered busy when any of the following occur: * a) the cache becomes busy when the allocator beneath it is running out of resources * b) a clear of the cache was requested * c) garbage collection is in progress * * Note: garbage collection can be invoked by the SMA and is invoked on insert / PHP_APCU_API zend_bool apc_cache_busy(apc_cache_t cache TSRMLS_DC); /* * apc_cache_defense: guard against slamming a key * will return true if the following conditions are met: * the key provided has a matching hash and length to the last key inserted into cache * the last key has a different owner * in ZTS mode, TSRM determines owner * in non-ZTS mode, PID determines owner * Note: this function sets the owner of key during execution / PHP_APCU_API zend_bool apc_cache_defense(apc_cache_t cache, apc_cache_key_t* key TSRMLS_DC); /* * apc_cache_serializer * sets the serializer for a cache, and by proxy contexts created for the cache * Note: this avoids race conditions between third party serializers and APCu / PHP_APCU_API void apc_cache_serializer(apc_cache_t cache, const char* name TSRMLS_DC); /* * The remaining functions allow a third party to reimplement expunge * * Look at the source of apc_cache_default_expunge for what is expected of this function * * The default behaviour of expunge is explained below, should no combination of those options * be suitable, you will need to reimplement apc_cache_default_expunge and pass it to your * call to apc_sma_api_impl, this will replace the default functionality. * The functions below you can use during your own implementation of expunge to gain more * control over how the expunge process works ... * * Note: beware of locking (copy it exactly), setting states is also important / / {{{ apc_cache_default_expunge * Where smart is not set: * Where no ttl is set on cache: * 1) Perform cleanup of stale entries * 2) Expunge if available memory is less than sma->size/2 * Where ttl is set on cache: * 1) Perform cleanup of stale entries * 2) If available memory if less than the size requested, run full expunge * * Where smart is set: * Where no ttl is set on cache: * 1) Perform cleanup of stale entries * 2) Expunge is available memory is less than size * smart * Where ttl is set on cache: * 1) Perform cleanup of stale entries * 2) If available memory if less than the size requested, run full expunge * * The TTL of an entry takes precedence over the TTL of a cache / PHP_APCU_API void apc_cache_default_expunge(apc_cache_t cache, size_t size TSRMLS_DC); /* * The remaining functions are used during the APCu implementation of expunge / / * apc_cache_real_expunge: trashes the whole cache * * Note: it is assumed you have a write lock on the header when you enter real expunge / PHP_APCU_API void apc_cache_real_expunge(apc_cache_t cache TSRMLS_DC); /* * apc_cache_gc: runs garbage collection on cache * * Note: it is assumed you have a write lock on the header when you enter gc / PHP_APCU_API void apc_cache_gc(apc_cache_t cache TSRMLS_DC); /* * apc_cache_remove_slot: removes slot * * if no references remain, the slot is free'd immediately * if there are references remaining, the slot is trashed * * Note: it is assumed you have a write lock on the header when you remove slots / PHP_APCU_API void apc_cache_remove_slot(apc_cache_t cache, apc_cache_slot_t** slot TSRMLS_DC); #endif /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: expandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: expandtab sw=4 ts=4 sts=4 */	17.77 KB	2024-08-04 15:31
📄 apc_lock_api.h /* +----------------------------------------------------------------------+ \| APCu \| +----------------------------------------------------------------------+ \| Copyright (c) 2013 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Joe Watkins <joe.watkins@live.co.uk> \| +----------------------------------------------------------------------+ / #ifndef APC_LOCK_API_H #define APC_LOCK_API_H / APCu works most efficiently where there is access to native read/write locks If the current system has native rwlocks present they will be used, if they are not present, APCu will emulate their behavior with standard mutex. While APCu is emulating read/write locks, reads and writes are exclusive, additionally the write lock prefers readers, as is the default behaviour of the majority of Posix rwlock implementations / #ifndef PHP_WIN32 # ifndef __USE_UNIX98 # define __USE_UNIX98 # endif # include "pthread.h" # ifndef APC_SPIN_LOCK # ifndef APC_FCNTL_LOCK # if defined(APC_NATIVE_RWLOCK) && defined(HAVE_ATOMIC_OPERATIONS) typedef pthread_rwlock_t apc_lock_t; # define APC_LOCK_SHARED # else typedef pthread_mutex_t apc_lock_t; # define APC_LOCK_RECURSIVE # endif # else typedef int apc_lock_t; # define APC_LOCK_FILE # endif # else # define APC_LOCK_NICE 1 typedef struct { unsigned long state; } apc_lock_t; PHP_APCU_API int apc_lock_init(apc_lock_t lock); PHP_APCU_API int apc_lock_try(apc_lock_t* lock); PHP_APCU_API int apc_lock_get(apc_lock_t* lock); PHP_APCU_API int apc_lock_release(apc_lock_t* lock); # endif #else /* XXX kernel lock mode only for now, compatible through all the wins, add more ifdefs for others / # include "apc_windows_srwlock_kernel.h" typedef apc_windows_cs_rwlock_t apc_lock_t; # define APC_LOCK_SHARED #endif / {{{ functions / / The following functions should be called once per process: apc_lock_init initializes attributes suitable for all locks apc_lock_cleanup destroys those attributes This saves us from having to create and destroy attributes for every lock we use at runtime / PHP_APCU_API zend_bool apc_lock_init(); PHP_APCU_API void apc_lock_cleanup(); / The following functions should be self explanitory: / PHP_APCU_API zend_bool apc_lock_create(apc_lock_t lock); PHP_APCU_API zend_bool apc_lock_rlock(apc_lock_t lock); PHP_APCU_API zend_bool apc_lock_wlock(apc_lock_t lock); PHP_APCU_API zend_bool apc_lock_runlock(apc_lock_t lock); PHP_APCU_API zend_bool apc_lock_wunlock(apc_lock_t lock); PHP_APCU_API void apc_lock_destroy(apc_lock_t lock); / }}} / / {{{ generic locking macros / #define CREATE_LOCK(lock) apc_lock_create(lock) #define DESTROY_LOCK(lock) apc_lock_destroy(lock) #define WLOCK(lock) { HANDLE_BLOCK_INTERRUPTIONS(); apc_lock_wlock(lock); } #define WUNLOCK(lock) { apc_lock_wunlock(lock); HANDLE_UNBLOCK_INTERRUPTIONS(); } #define RLOCK(lock) { HANDLE_BLOCK_INTERRUPTIONS(); apc_lock_rlock(lock); } #define RUNLOCK(lock) { apc_lock_runlock(lock); HANDLE_UNBLOCK_INTERRUPTIONS(); } #define LOCK WLOCK #define UNLOCK WUNLOCK / }}} / / {{{ object locking macros / #define APC_WLOCK(o) WLOCK(&(o)->lock) #define APC_LOCK APC_WLOCK #define APC_WUNLOCK(o) WUNLOCK(&(o)->lock) #define APC_UNLOCK APC_WUNLOCK #define APC_RLOCK(o) RLOCK(&(o)->lock) #define APC_RUNLOCK(o) RUNLOCK(&(o)->lock) / }}} / / atomic operations */ #if defined(APC_LOCK_SHARED) # ifdef PHP_WIN32 # define ATOMIC_INC(c, a) InterlockedIncrement(&a) # define ATOMIC_DEC(c, a) InterlockedDecrement(&a) # else # define ATOMIC_INC(c, a) __sync_add_and_fetch(&a, 1) # define ATOMIC_DEC(c, a) __sync_sub_and_fetch(&a, 1) # endif #elif defined(APC_LOCK_RECURSIVE) # define ATOMIC_INC(c, a) do { \ if (apc_lock_wlock(&(c)->header->lock)) { \ (a)++; \ apc_lock_wunlock(&(c)->header->lock); \ } \ } while(0) # define ATOMIC_DEC(c, a) do { \ if (apc_lock_wlock(&(c)->header->lock)) { \ (a)--; \ apc_lock_wunlock(&(c)->header->lock); \ } \ } while(0) #else # define ATOMIC_INC(c, a) (a)++ # define ATOMIC_DEC(c, a) (a)-- #endif #endif	4.87 KB	2024-08-04 15:31
📄 apc_pool_api.h /* +----------------------------------------------------------------------+ \| APC \| +----------------------------------------------------------------------+ \| Copyright (c) 2006-2011 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt. \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Authors: Gopal Vijayaraghavan <gopalv@yahoo-inc.com> \| +----------------------------------------------------------------------+ This software was contributed to PHP by Yahoo! Inc. in 2008. Future revisions and derivatives of this source code must acknowledge Yahoo! Inc. as the original contributor of this module by leaving this note intact in the source code. All other licensing and usage conditions are those of the PHP Group. / / $Id: apc_pool.h 307048 2011-01-03 23:53:17Z kalle $ / #ifndef APC_POOL_API_H #define APC_POOL_API_H #if APC_POOL_DEBUG #define APC_POOL_HAS_SIZEINFO(pool) ((pool->type & APC_POOL_SIZEINFO)!=0) #define APC_POOL_HAS_REDZONES(pool) ((pool->type & APC_POOL_REDZONES)!=0) #else / let gcc optimize away the optional features / #define APC_POOL_HAS_SIZEINFO(pool) (0) #define APC_POOL_HAS_REDZONES(pool) (0) #endif / {{{ / typedef struct _apc_pool apc_pool; / }}} / / {{{ functions / typedef void (apc_pcleanup_t)(apc_pool pool TSRMLS_DC); typedef void (apc_palloc_t)(apc_pool pool, size_t size TSRMLS_DC); typedef void (apc_pfree_t) (apc_pool pool, void* p TSRMLS_DC); typedef void* (apc_protect_t) (void p); typedef void* (apc_unprotect_t)(void p); /* }}} / / {{{ enum definition: apc_pool_type / typedef enum { APC_UNPOOL = 0x0, APC_SMALL_POOL = 0x1, APC_MEDIUM_POOL = 0x2, APC_LARGE_POOL = 0x3, APC_POOL_SIZE_MASK = 0x7, / waste a bit / #if APC_POOL_DEBUG APC_POOL_REDZONES = 0x08, APC_POOL_SIZEINFO = 0x10, APC_POOL_OPT_MASK = 0x18 #endif } apc_pool_type; / }}} / / {{{ structure definition: apc_pool / struct _apc_pool { / denotes the size and debug flags for a pool / apc_pool_type type; / handler functions / apc_malloc_t allocate; apc_free_t deallocate; apc_palloc_t palloc; apc_pfree_t pfree; apc_protect_t protect; apc_unprotect_t unprotect; apc_pcleanup_t cleanup; / total / size_t size; / remaining / size_t used; / apc_realpool and apc_unpool add more here / }; / }}} / / {{{ enum definition: apc_copy_type / / APC_COPY_IN should be used when copying into APC APC_COPY_OUT should be used when copying out of APC / typedef enum _apc_copy_type { APC_NO_COPY = 0, APC_COPY_IN, APC_COPY_OUT, APC_COPY_OTHER } apc_copy_type; / }}} / / {{{ enum definition: apc_context_type APC_CONTEXT_SHARE should be used to create contexts using shared memory APC_CONTEXT_NOSHARE should be used to create contexts using standard allocators / typedef enum _apc_context_type { APC_CONTEXT_NONE = 0, APC_CONTEXT_SHARE, APC_CONTEXT_NOSHARE } apc_context_type; / }}} / / {{{ struct definition: apc_context_t / typedef struct _apc_context_t { apc_pool pool; /* pool of memory for context / apc_copy_type copy; / copying type for context / unsigned int force_update:1; / flag to force updates / HashTable copied; / copied zvals for recursion support / apc_serializer_t serializer; /* serializer / void key; /* set before serializer API is invoked / } apc_context_t; / }}} / / apc_pool_create creates a pool of the specified type, setting the handlers passed on the pool, returns apc_pool* / PHP_APCU_API apc_pool apc_pool_create(apc_pool_type pool_type, apc_malloc_t allocate, apc_free_t deallocate, apc_protect_t protect, apc_unprotect_t unprotect TSRMLS_DC); /* apc_pool_destroy first calls apc_cleanup_t set during apc_pool_create, then apc_free_t / PHP_APCU_API void apc_pool_destroy(apc_pool pool TSRMLS_DC); /* apc_pmemcpy performs memcpy using resources provided by pool / PHP_APCU_API void apc_pmemcpy(const void* p, size_t n, apc_pool* pool TSRMLS_DC); /* apc_pstrdup performs strdup using resources provided by pool / PHP_APCU_API void apc_pstrdup(const char* s, apc_pool* pool TSRMLS_DC); #endif	5.16 KB	2024-08-04 15:31
📄 apc_serializer.h /* +----------------------------------------------------------------------+ \| APC \| +----------------------------------------------------------------------+ \| Copyright (c) 2006-2011 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt. \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Authors: Gopal Vijayaraghavan <gopalv@php.net> \| +----------------------------------------------------------------------+ / / $Id: $ / #ifndef APC_SERIALIZER_H #define APC_SERIALIZER_H / this is a shipped .h file, do not include any other header in this file / #define APC_SERIALIZER_NAME(module) module##_apc_serializer #define APC_UNSERIALIZER_NAME(module) module##_apc_unserializer #define APC_SERIALIZER_ARGS unsigned char buf, size_t buf_len, const zval value, void config TSRMLS_DC #define APC_UNSERIALIZER_ARGS zval *value, unsigned char buf, size_t buf_len, void config TSRMLS_DC typedef int (apc_serialize_t)(APC_SERIALIZER_ARGS); typedef int (apc_unserialize_t)(APC_UNSERIALIZER_ARGS); typedef int (apc_register_serializer_t)(const char* name, apc_serialize_t serialize, apc_unserialize_t unserialize, void config TSRMLS_DC); / * ABI version for constant hooks. Increment this any time you make any changes * to any function in this file. / #define APC_SERIALIZER_ABI "0" #define APC_SERIALIZER_CONSTANT "\000apc_register_serializer-" APC_SERIALIZER_ABI #if !defined(APC_UNUSED) # if defined(__GNUC__) # define APC_UNUSED __attribute__((unused)) # else # define APC_UNUSED # endif #endif static APC_UNUSED int apc_register_serializer(const char name, apc_serialize_t serialize, apc_unserialize_t unserialize, void config TSRMLS_DC) { zval apc_magic_constant; int retval = 0; / zend_get_constant will return 1 on success, otherwise apc_magic_constant wouldn't be touched at all / if (zend_get_constant(APC_SERIALIZER_CONSTANT, sizeof(APC_SERIALIZER_CONSTANT)-1, &apc_magic_constant TSRMLS_CC)) { #if defined(PHP_WIN32) && defined(_WIN64) apc_register_serializer_t register_func = (apc_register_serializer_t)_atoi64(Z_STRVAL(apc_magic_constant)); #else apc_register_serializer_t register_func = (apc_register_serializer_t)(Z_LVAL(apc_magic_constant)); #endif if(register_func) { retval = register_func(name, serialize, unserialize, NULL TSRMLS_CC); } zval_dtor(&apc_magic_constant); } return retval; } #endif / * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: expandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: expandtab sw=4 ts=4 sts=4 */	3.45 KB	2024-08-04 15:31
📄 apc_sma_api.h /* +----------------------------------------------------------------------+ \| APCu \| +----------------------------------------------------------------------+ \| Copyright (c) 2013 The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| http://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Joe Watkins <joe.watkins@live.co.uk> \| +----------------------------------------------------------------------+ This software was contributed to PHP by Community Connect Inc. in 2002 and revised in 2005 by Yahoo! Inc. to add support for PHP 5.1. Future revisions and derivatives of this source code must acknowledge Community Connect Inc. as the original contributor of this module by leaving this note intact in the source code. All other licensing and usage conditions are those of the PHP Group. / #ifndef HAVE_APC_SMA_API_H #define HAVE_APC_SMA_API_H / {{{ SMA API APC SMA API provides support for shared memory allocators to external libraries ( and to APC ) Skip to the bottom macros for error free usage of the SMA API / / {{{ struct definition: apc_segment_t / typedef struct _apc_segment_t { size_t size; / size of this segment / void shmaddr; /* address of shared memory / #ifdef APC_MEMPROTECT void roaddr; /* read only (mprotect'd) address / #endif } apc_segment_t; / }}} / / {{{ struct definition: apc_sma_link_t / typedef struct apc_sma_link_t apc_sma_link_t; struct apc_sma_link_t { long size; / size of this free block / long offset; / offset in segment of this block / apc_sma_link_t next; /* link to next free block / }; / }}} / / {{{ struct definition: apc_sma_info_t / typedef struct apc_sma_info_t apc_sma_info_t; struct apc_sma_info_t { int num_seg; / number of segments / size_t seg_size; / segment size / apc_sma_link_t* list; /* one list per segment of links / }; / }}} / / {{{ function definitions for SMA API objects / typedef void (apc_sma_init_f) (zend_uint num, zend_ulong size, char mask TSRMLS_DC); typedef void (apc_sma_cleanup_f) (TSRMLS_D); typedef void* (apc_sma_malloc_f) (zend_ulong size TSRMLS_DC); typedef void (apc_sma_malloc_ex_f) (zend_ulong size, zend_ulong fragment, zend_ulong allocated TSRMLS_DC); typedef void* (apc_sma_realloc_f) (void p, zend_ulong size TSRMLS_DC); typedef char* (apc_sma_strdup_f) (const char str TSRMLS_DC); typedef void (apc_sma_free_f) (void p TSRMLS_DC); typedef void* (apc_sma_protect_f) (void p); typedef void* (apc_sma_unprotect_f) (void p); typedef apc_sma_info_t* (apc_sma_info_f) (zend_bool limited TSRMLS_DC); typedef void (apc_sma_free_info_f) (apc_sma_info_t info TSRMLS_DC); typedef zend_ulong (apc_sma_get_avail_mem_f) (void); typedef zend_bool (apc_sma_get_avail_size_f) (zend_ulong size); typedef void (apc_sma_check_integrity_f) (void); typedef void (apc_sma_expunge_f)(void pointer, zend_ulong size TSRMLS_DC); /* }}} / / {{{ struct definition: apc_sma_t / typedef struct _apc_sma_t { zend_bool initialized; / flag to indicate this sma has been intialized / / functions / apc_sma_init_f init; / init / apc_sma_cleanup_f cleanup; / cleanup / apc_sma_malloc_f smalloc; / malloc / apc_sma_malloc_ex_f malloc_ex; / malloc_ex / apc_sma_realloc_f realloc; / realloc / apc_sma_strdup_f strdup; / strdup / apc_sma_free_f sfree; / free / apc_sma_protect_f protect; / protect / apc_sma_unprotect_f unprotect; / unprotect / apc_sma_info_f info; / info / apc_sma_free_info_f free_info; / free info / apc_sma_get_avail_mem_f get_avail_mem; / get avail mem / apc_sma_get_avail_size_f get_avail_size; / get avail size / apc_sma_check_integrity_f check_integrity; / check integrity / / callback / apc_sma_expunge_f expunge; / expunge / void* data; /* data / / info / zend_uint num; / number of segments / zend_ulong size; / segment size / zend_uint last; / last segment / / segments / apc_segment_t segs; /* segments / } apc_sma_t; / }}} / / * apc_sma_api_init will initialize a shared memory allocator with num segments of the given size * * should be called once per allocator per process / PHP_APCU_API void apc_sma_api_init(apc_sma_t sma, void** data, apc_sma_expunge_f expunge, zend_uint num, zend_ulong size, char mask TSRMLS_DC); / * apc_sma_api_cleanup will free the sma allocator / PHP_APCU_API void apc_sma_api_cleanup(apc_sma_t sma TSRMLS_DC); /* * apc_smap_api_malloc will allocate a block from the sma of the given size / PHP_APCU_API void apc_sma_api_malloc(apc_sma_t* sma, zend_ulong size TSRMLS_DC); /* * apc_sma_api_malloc_ex will allocate a block from the sma of the given size / PHP_APCU_API void apc_sma_api_malloc_ex(apc_sma_t* sma, zend_ulong size, zend_ulong fragment, zend_ulong* allocated TSRMLS_DC); /* * apc_sma_api_realloc will reallocate p using a new block from sma (freeing the original p) / PHP_APCU_API void apc_sma_api_realloc(apc_sma_t* sma, void* p, zend_ulong size TSRMLS_DC); /* * apc_sma_api_strdup will duplicate the given string into a block from sma / PHP_APCU_API char apc_sma_api_strdup(apc_sma_t* sma, const char* s TSRMLS_DC); /* * apc_sma_api_free will free p (which should be a pointer to a block allocated from sma) / PHP_APCU_API void apc_sma_api_free(apc_sma_t sma, void* p TSRMLS_DC); /* * apc_sma_api_protect will protect p (which should be a pointer to a block allocated from sma) / PHP_APCU_API void apc_sma_api_protect(apc_sma_t* sma, void* p); /* * apc_sma_api_protect will uprotect p (which should be a pointer to a block allocated from sma) / PHP_APCU_API void apc_sma_api_unprotect(apc_sma_t* sma, void p); / * apc_sma_api_info returns information about the allocator / PHP_APCU_API apc_sma_info_t apc_sma_api_info(apc_sma_t* sma, zend_bool limited TSRMLS_DC); /* * apc_sma_api_info_free_info is for freeing apc_sma_info_t* returned by apc_sma_api_info / PHP_APCU_API void apc_sma_api_free_info(apc_sma_t sma, apc_sma_info_t* info TSRMLS_DC); /* * apc_sma_api_get_avail_mem will return the amount of memory available left to sma / PHP_APCU_API zend_ulong apc_sma_api_get_avail_mem(apc_sma_t sma); /* * apc_sma_api_get_avail_size will return true if at least size bytes are available to the sma / PHP_APCU_API zend_bool apc_sma_api_get_avail_size(apc_sma_t sma, size_t size); /* * apc_sma_api_check_integrity will check the integrity of sma / PHP_APCU_API void apc_sma_api_check_integrity(apc_sma_t sma); /* }}} / / {{{ ALIGNWORD: pad up x, aligned to the system's word boundary / typedef union { void p; int i; long l; double d; void (f)(void); } apc_word_t; #define ALIGNSIZE(x, size) ((size) (1 + (((x)-1)/(size)))) #define ALIGNWORD(x) ALIGNSIZE(x, sizeof(apc_word_t)) /* }}} / / * The following macros help to implement APC SMA in a few easy steps: * 1) call apc_sma_api_decl(name) to intialize an APC SMA by the given name in a global project header * 2) call apc_sma_api_impl(name) to implement the APC SMA in a compilation unit * 3) call apc_sma_api_extern(name) in any compilation unit without direct access to your SMA * * you can now call name.malloc, name.free etc from anywhere in your application, and there is no margin for error * your extension should call name.init during MINIT and name.cleanup during MSHUTDOWN / / {{{ Implementor macros / #define apc_sma_api_name(name) name #define apc_sma_api_ptr(name) &apc_sma_api_name(name) #define apc_sma_api_func(name, func) name##_##func / {{{ Call in a header somewhere to extern all sma functions / #define apc_sma_api_decl(name) \ PHP_APCU_API void apc_sma_api_func(name, init)(zend_uint num, zend_ulong size, char mask TSRMLS_DC); \ PHP_APCU_API void apc_sma_api_func(name, cleanup)(TSRMLS_D); \ PHP_APCU_API void* apc_sma_api_func(name, malloc)(zend_ulong size TSRMLS_DC); \ PHP_APCU_API void* apc_sma_api_func(name, malloc_ex)(zend_ulong size, zend_ulong fragment, zend_ulong* allocated TSRMLS_DC); \ PHP_APCU_API void* apc_sma_api_func(name, realloc)(void* p, zend_ulong size TSRMLS_DC); \ PHP_APCU_API char* apc_sma_api_func(name, strdup)(const char* s TSRMLS_DC); \ PHP_APCU_API void apc_sma_api_func(name, free)(void* p TSRMLS_DC); \ PHP_APCU_API void* apc_sma_api_func(name, protect)(void* p); \ PHP_APCU_API void* apc_sma_api_func(name, unprotect)(void* p); \ PHP_APCU_API apc_sma_info_t* apc_sma_api_func(name, info)(zend_bool limited TSRMLS_DC); \ PHP_APCU_API void apc_sma_api_func(name, free_info)(apc_sma_info_t* info TSRMLS_DC); \ PHP_APCU_API zend_ulong apc_sma_api_func(name, get_avail_mem)(void); \ PHP_APCU_API zend_bool apc_sma_api_func(name, get_avail_size)(zend_ulong size); \ PHP_APCU_API void apc_sma_api_func(name, check_integrity)(void); /* }}} / / {{{ Call in a compilation unit / #define apc_sma_api_impl(name, data, expunge) \ apc_sma_t apc_sma_api_name(name) = {0, \ &apc_sma_api_func(name, init), \ &apc_sma_api_func(name, cleanup), \ &apc_sma_api_func(name, malloc), \ &apc_sma_api_func(name, malloc_ex), \ &apc_sma_api_func(name, realloc), \ &apc_sma_api_func(name, strdup), \ &apc_sma_api_func(name, free), \ &apc_sma_api_func(name, protect), \ &apc_sma_api_func(name, unprotect), \ &apc_sma_api_func(name, info), \ &apc_sma_api_func(name, free_info), \ &apc_sma_api_func(name, get_avail_mem), \ &apc_sma_api_func(name, get_avail_size), \ &apc_sma_api_func(name, check_integrity), \ }; \ PHP_APCU_API void apc_sma_api_func(name, init)(zend_uint num, zend_ulong size, char mask TSRMLS_DC) \ { apc_sma_api_init(apc_sma_api_ptr(name), (void*) data, (apc_sma_expunge_f) expunge, num, size, mask TSRMLS_CC); } \ PHP_APCU_API void apc_sma_api_func(name, cleanup)(TSRMLS_D) \ { apc_sma_api_cleanup(apc_sma_api_ptr(name) TSRMLS_CC); } \ PHP_APCU_API void apc_sma_api_func(name, malloc)(zend_ulong size TSRMLS_DC) \ { return apc_sma_api_malloc(apc_sma_api_ptr(name), size TSRMLS_CC); } \ PHP_APCU_API void* apc_sma_api_func(name, malloc_ex)(zend_ulong size, zend_ulong fragment, zend_ulong* allocated TSRMLS_DC) \ { return apc_sma_api_malloc_ex(apc_sma_api_ptr(name), size, fragment, allocated TSRMLS_CC); } \ PHP_APCU_API void* apc_sma_api_func(name, realloc)(void* p, zend_ulong size TSRMLS_DC) \ { return apc_sma_api_realloc(apc_sma_api_ptr(name), p, size TSRMLS_CC); } \ PHP_APCU_API char* apc_sma_api_func(name, strdup)(const char* s TSRMLS_DC) \ { return apc_sma_api_strdup(apc_sma_api_ptr(name), s TSRMLS_CC); } \ PHP_APCU_API void apc_sma_api_func(name, free)(void* p TSRMLS_DC) \ { apc_sma_api_free(apc_sma_api_ptr(name), p TSRMLS_CC); } \ PHP_APCU_API void* apc_sma_api_func(name, protect)(void* p) \ { return apc_sma_api_protect(apc_sma_api_ptr(name), p); } \ PHP_APCU_API void* apc_sma_api_func(name, unprotect)(void* p) \ { return apc_sma_api_unprotect(apc_sma_api_ptr(name), p); } \ PHP_APCU_API apc_sma_info_t* apc_sma_api_func(name, info)(zend_bool limited TSRMLS_DC) \ { return apc_sma_api_info(apc_sma_api_ptr(name), limited TSRMLS_CC); } \ PHP_APCU_API void apc_sma_api_func(name, free_info)(apc_sma_info_t* info TSRMLS_DC) \ { apc_sma_api_free_info(apc_sma_api_ptr(name), info TSRMLS_CC); } \ PHP_APCU_API zend_ulong apc_sma_api_func(name, get_avail_mem)() \ { return apc_sma_api_get_avail_mem(apc_sma_api_ptr(name)); } \ PHP_APCU_API zend_bool apc_sma_api_func(name, get_avail_size)(zend_ulong size) \ { return apc_sma_api_get_avail_size(apc_sma_api_ptr(name), size); } \ PHP_APCU_API void apc_sma_api_func(name, check_integrity)() \ { apc_sma_api_check_integrity(apc_sma_api_ptr(name)); } /* }}} / / {{{ Call wherever access to the SMA object is required / #define apc_sma_api_extern(name) extern apc_sma_t apc_sma_api_name(name) / }}} / / }}} */ #endif	13.69 KB	2024-08-04 15:31

Terminal