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
📁 ..	-	2025-05-25 12:37
📄 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. / #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" / console display functions / PHP_APCU_API void apc_error(const char format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 1, 2); PHP_APCU_API void apc_warning(const char format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 1, 2); PHP_APCU_API void apc_notice(const char format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 1, 2); PHP_APCU_API void apc_debug(const char format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 1, 2); / apc_flip_hash flips keys and values for faster searching / PHP_APCU_API HashTable apc_flip_hash(HashTable hash); #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 #define APC_UNSERIALIZER_ARGS zval value, unsigned char buf, size_t buf_len, void config 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 parameters / PHP_APCU_API int _apc_register_serializer( const char name, apc_serialize_t serialize, apc_unserialize_t unserialize, void config); / }}} / / {{{ apc_get_serializers fetches the list of serializers / PHP_APCU_API apc_serializer_t apc_get_serializers(void); /* }}} / / {{{ apc_find_serializer finds a previously registered serializer by name / PHP_APCU_API apc_serializer_t apc_find_serializer(const char* name); /* }}} / / {{{ default serializers / PHP_APCU_API int APC_SERIALIZER_NAME(php) (APC_SERIALIZER_ARGS); PHP_APCU_API int APC_UNSERIALIZER_NAME(php) (APC_UNSERIALIZER_ARGS); / }}} / #define php_apc_try \ { \ JMP_BUF zb = EG(bailout); \ JMP_BUF ab; \ zend_bool _bailout = 0; \ \ EG(bailout) = &ab; \ if (SETJMP(ab) == SUCCESS) { #define php_apc_finally \ } else { \ _bailout = 1; \ } #define php_apc_end_try() \ EG(bailout) = zb; \ if (_bailout) { \ zend_bailout(); \ } \ } #define php_apc_try_finish() (EG(bailout) = zb) #endif /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: noexpandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: noexpandtab sw=4 ts=4 sts=4 */	5.75 KB	2024-08-04 15:54
📄 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.h" #include "apc_sma.h" #include "apc_cache.h" #endif	1.23 KB	2024-08-04 15:54
📄 apc_arginfo.h #if PHP_VERSION_ID < 80000 # include "php_apc_legacy_arginfo.h" #else # error Not supported on PHP >= 8.0 #endif	113 B	2024-08-04 15:54
📄 apc_cache.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. / #ifndef APC_CACHE_H #define APC_CACHE_H #include "apc.h" #include "apc_sma.h" #include "apc_lock.h" #include "apc_globals.h" #include "TSRM.h" typedef struct apc_cache_slam_key_t apc_cache_slam_key_t; struct apc_cache_slam_key_t { zend_ulong hash; / hash of the key / size_t len; / length of the key / time_t mtime; / creation time of this key / pid_t owner_pid; / the pid that created this key / #ifdef ZTS void *owner_thread; / TSRMLS cache of thread that created this key / #endif }; / {{{ struct definition: apc_cache_entry_t / typedef struct apc_cache_entry_t apc_cache_entry_t; struct apc_cache_entry_t { zend_string key; /* entry key / zval val; / the zval copied at store time / apc_cache_entry_t next; /* next entry in linked list / zend_long ttl; / the ttl on this specific entry / zend_long ref_count; / the reference count of this entry / zend_long nhits; / number of hits to this entry / time_t ctime; / time entry was initialized / time_t mtime; / the mtime of this cached entry / time_t dtime; / time entry was removed from cache / time_t atime; / time entry was last accessed / zend_long mem_size; / memory used / }; / }}} / / {{{ 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_long nhits; / hit count / zend_long nmisses; / miss count / zend_long ninserts; / insert count / zend_long nexpunges; / expunge count / zend_long nentries; / entry count / zend_long mem_size; / used / time_t stime; / start time / unsigned short state; / cache state / apc_cache_slam_key_t lastkey; / last key inserted (not necessarily without error) / apc_cache_entry_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_entry_t* slots; /* array of cache slots (stored in SHM) / apc_sma_t sma; /* shared memory allocator / apc_serializer_t serializer; /* serializer / size_t nslots; / number of slots in cache / zend_long gc_ttl; / maximum time on GC list for a entry / zend_long ttl; / if slot is needed and entry's access time is older than this ttl, remove it / zend_long 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); /* }}} / / {{{ typedef: apc_cache_atomic_updater_t / typedef zend_bool (apc_cache_atomic_updater_t)(apc_cache_t, zend_long, 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, zend_long size_hint, zend_long gc_ttl, zend_long ttl, zend_long smart, zend_bool defend); /* * 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); /* * apc_cache_detach detaches from the shared memory cache and cleans up * local allocations. Under apache, this function can be safely called by * the child processes when they exit. / PHP_APCU_API void apc_cache_detach(apc_cache_t cache); /* * 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); /* * 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, zend_string key, const zval val, const int32_t ttl, const zend_bool exclusive); /* * apc_cache_update updates an entry in place. The updater function must not bailout. * The update is performed under write-lock and doesn't have to be atomic. / PHP_APCU_API zend_bool apc_cache_update( apc_cache_t cache, zend_string key, apc_cache_updater_t updater, void data, zend_bool insert_if_not_found, zend_long ttl); /* * apc_cache_atomic_update_long updates an integer entry in place. The updater function must * perform the update atomically, as the update is performed under read-lock. / PHP_APCU_API zend_bool apc_cache_atomic_update_long( apc_cache_t cache, zend_string key, apc_cache_atomic_updater_t updater, void data, zend_bool insert_if_not_found, zend_long ttl); /* * 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, zend_string key, time_t t); / * apc_cache_fetch fetches an entry from the cache directly into dst * / PHP_APCU_API zend_bool apc_cache_fetch(apc_cache_t cache, zend_string key, time_t t, zval dst); /* * apc_cache_exists searches for a cache entry by its hashed identifier, * and returns whether the entry exists. / PHP_APCU_API zend_bool apc_cache_exists(apc_cache_t cache, zend_string key, time_t t); / * 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, zend_string key); / apc_cache_fetch_zval copies a cache entry value to be usable at runtime. / PHP_APCU_API zend_bool apc_cache_entry_fetch_zval( apc_cache_t cache, apc_cache_entry_t entry, zval dst); /* * apc_cache_entry_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_entry_release(apc_cache_t cache, apc_cache_entry_t entry); / fetches information about the cache provided for userland status functions / PHP_APCU_API zend_bool apc_cache_info(zval info, apc_cache_t cache, zend_bool limited); / fetches information about the key provided / PHP_APCU_API void apc_cache_stat(apc_cache_t cache, zend_string key, zval stat); /* * 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, zend_string key, time_t t); / * 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); /* * 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); /* * apc_cache_entry: generate and create or fetch an entry * * @see https://github.com/krakjoe/apcu/issues/142 / PHP_APCU_API void apc_cache_entry(apc_cache_t cache, zend_string key, zend_fcall_info fci, zend_fcall_info_cache fcc, zend_long ttl, zend_long now, zval return_value); /* apcu_entry() holds a write lock on the cache while executing user code. * That code may call other apcu_* functions, which also try to acquire a * read or write lock, which would deadlock. As such, don't try to acquire a * lock if the current thread is inside apcu_entry(). * * Whether the current thread is inside apcu_entry() is tracked by APCG(entry_level). * This breaks the self-contained apc_cache_t abstraction, but is currently * necessary because the entry_level needs to be tracked per-thread, while * apc_cache_t is a per-process structure. / static inline zend_bool apc_cache_wlock(apc_cache_t cache) { if (!APCG(entry_level)) { return WLOCK(&cache->header->lock); } return 1; } static inline void apc_cache_wunlock(apc_cache_t cache) { if (!APCG(entry_level)) { WUNLOCK(&cache->header->lock); } } static inline zend_bool apc_cache_rlock(apc_cache_t cache) { if (!APCG(entry_level)) { return RLOCK(&cache->header->lock); } return 1; } static inline void apc_cache_runlock(apc_cache_t cache) { if (!APCG(entry_level)) { RUNLOCK(&cache->header->lock); } } #endif / * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: noexpandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: noexpandtab sw=4 ts=4 sts=4 */	13.03 KB	2024-08-04 15:54
📄 apc_globals.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. / #ifndef APC_GLOBALS_H #define APC_GLOBALS_H #include "apc.h" ZEND_BEGIN_MODULE_GLOBALS(apcu) / configuration parameters / zend_bool enabled; / if true, apc is enabled (defaults to true) / zend_long shm_segments; / number of shared memory segments to use / zend_long shm_size; / size of each shared memory segment (in MB) / zend_long entries_hint; / hint at the number of entries expected / zend_long gc_ttl; / parameter to apc_cache_create / zend_long ttl; / parameter to apc_cache_create / zend_long smart; / smart value / #if APC_MMAP char mmap_file_mask; /* mktemp-style file-mask to pass to mmap / #endif / module variables / zend_bool initialized; / true if module was initialized / zend_bool enable_cli; / Flag to override turning APC off for CLI / zend_bool slam_defense; / true for user cache slam defense / char preload_path; /* preload path / zend_bool coredump_unmap; / trap signals that coredump and unmap shared memory / zend_bool use_request_time; / use the SAPI request start time for TTL / time_t request_time; / cached request time / char serializer_name; /* the serializer config option / / Nesting level of apcu_entry calls. / unsigned int entry_level; ZEND_END_MODULE_GLOBALS(apcu) / (the following is defined in php_apc.c) / ZEND_EXTERN_MODULE_GLOBALS(apcu) #ifdef ZTS # define APCG(v) TSRMG(apcu_globals_id, zend_apcu_globals , v) #else # define APCG(v) (apcu_globals.v) #endif extern struct _apc_cache_t* apc_user_cache; #endif /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: noexpandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: noexpandtab sw=4 ts=4 sts=4 */	3.55 KB	2024-08-04 15:54
📄 apc_iterator.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> \| +----------------------------------------------------------------------+ / #ifndef APC_ITERATOR_H #define APC_ITERATOR_H #include "apc.h" #include "apc_stack.h" #include "ext/pcre/php_pcre.h" #include "zend_smart_str.h" #define APC_DEFAULT_CHUNK_SIZE 100 #define APC_LIST_ACTIVE 0x1 #define APC_LIST_DELETED 0x2 #define APC_ITER_TYPE (1 << 0) #define APC_ITER_KEY (1 << 1) #define APC_ITER_VALUE (1 << 2) #define APC_ITER_NUM_HITS (1 << 3) #define APC_ITER_MTIME (1 << 4) #define APC_ITER_CTIME (1 << 5) #define APC_ITER_DTIME (1 << 6) #define APC_ITER_ATIME (1 << 7) #define APC_ITER_REFCOUNT (1 << 8) #define APC_ITER_MEM_SIZE (1 << 9) #define APC_ITER_TTL (1 << 10) #define APC_ITER_NONE 0 #define APC_ITER_ALL (0xffffffffL) / {{{ apc_iterator_t / typedef struct _apc_iterator_t { short int initialized; / sanity check in case __construct failed / zend_long format; / format bitmask of the return values ie: key, value, info / size_t (fetch)(struct _apc_iterator_t iterator); / fetch callback to fetch items from cache slots or lists / size_t slot_idx; / index to the slot array or linked list / size_t chunk_size; / number of entries to pull down per fetch / apc_stack_t stack; /* stack of entries pulled from cache / int stack_idx; / index into the current stack / pcre_cache_entry pce; /* regex filter on entry identifiers / #if PHP_VERSION_ID >= 70300 pcre2_match_data re_match_data; /* match data for regex / #endif zend_string regex; HashTable search_hash; / hash of keys to iterate over / zend_long key_idx; / incrementing index for numerical keys / short int totals_flag; / flag if totals have been calculated / zend_long hits; / hit total / size_t size; / size total / zend_long count; / count total / zend_object obj; } apc_iterator_t; / }}} / #define apc_iterator_fetch_from(o) ((apc_iterator_t)((char)o - XtOffsetOf(apc_iterator_t, obj))) #define apc_iterator_fetch(z) apc_iterator_fetch_from(Z_OBJ_P(z)) / {{{ apc_iterator_item / typedef struct _apc_iterator_item_t { zend_string key; zval value; } apc_iterator_item_t; /* }}} / PHP_APCU_API void apc_iterator_obj_init( apc_iterator_t iterator, zval search, zend_long format, size_t chunk_size, zend_long list); PHP_APCU_API zend_class_entry apc_iterator_get_ce(void); PHP_APCU_API int apc_iterator_init(int module_number); PHP_APCU_API int apc_iterator_shutdown(int module_number); extern int apc_iterator_delete(zval key); #endif / * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: noexpandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: noexpandtab sw=4 ts=4 sts=4 */	3.79 KB	2024-08-04 15:54
📄 apc_lock.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_H #define APC_LOCK_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 / #ifdef HAVE_CONFIG_H # include <config.h> #endif #include "apc.h" #ifndef PHP_WIN32 # ifndef __USE_UNIX98 # define __USE_UNIX98 # endif # include "pthread.h" # ifndef APC_SPIN_LOCK # ifndef APC_FCNTL_LOCK # ifdef APC_NATIVE_RWLOCK 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; # 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(void); PHP_APCU_API void apc_lock_cleanup(void); / 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) apc_lock_wlock(lock) #define WUNLOCK(lock) { apc_lock_wunlock(lock); HANDLE_UNBLOCK_INTERRUPTIONS(); } #define RLOCK(lock) apc_lock_rlock(lock) #define RUNLOCK(lock) { apc_lock_runlock(lock); HANDLE_UNBLOCK_INTERRUPTIONS(); } / }}} / / atomic operations */ #ifdef PHP_WIN32 # ifdef _WIN64 # define ATOMIC_INC(a) InterlockedIncrement64(&a) # define ATOMIC_DEC(a) InterlockedDecrement64(&a) # define ATOMIC_ADD(a, b) (InterlockedExchangeAdd64(&a, b) + b) # define ATOMIC_CAS(a, old, new) (InterlockedCompareExchange64(&a, new, old) == old) # else # define ATOMIC_INC(a) InterlockedIncrement(&a) # define ATOMIC_DEC(a) InterlockedDecrement(&a) # define ATOMIC_ADD(a, b) (InterlockedExchangeAdd(&a, b) + b) # define ATOMIC_CAS(a, old, new) (InterlockedCompareExchange(&a, new, old) == old) # endif #else # define ATOMIC_INC(a) __sync_add_and_fetch(&a, 1) # define ATOMIC_DEC(a) __sync_sub_and_fetch(&a, 1) # define ATOMIC_ADD(a, b) __sync_add_and_fetch(&a, b) # define ATOMIC_CAS(a, old, new) __sync_bool_compare_and_swap(&a, old, new) #endif #endif	4.33 KB	2024-08-04 15:54
📄 apc_mutex.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_MUTEX_H #define APC_MUTEX_H #include "apc.h" #ifdef APC_HAS_PTHREAD_MUTEX #include "pthread.h" typedef pthread_mutex_t apc_mutex_t; PHP_APCU_API zend_bool apc_mutex_init(void); PHP_APCU_API void apc_mutex_cleanup(void); PHP_APCU_API zend_bool apc_mutex_create(apc_mutex_t lock); PHP_APCU_API zend_bool apc_mutex_lock(apc_mutex_t lock); PHP_APCU_API zend_bool apc_mutex_unlock(apc_mutex_t lock); PHP_APCU_API void apc_mutex_destroy(apc_mutex_t *lock); #define APC_MUTEX_INIT() apc_mutex_init() #define APC_MUTEX_CLEANUP() apc_mutex_cleanup() #define APC_CREATE_MUTEX(lock) apc_mutex_create(lock) #define APC_DESTROY_MUTEX(lock) apc_mutex_destroy(lock) #define APC_MUTEX_LOCK(lock) apc_mutex_lock(lock) #define APC_MUTEX_UNLOCK(lock) apc_mutex_unlock(lock) #else #include "apc_lock.h" typedef apc_lock_t apc_mutex_t; // Fallback to normal locks #define APC_MUTEX_INIT() #define APC_MUTEX_CLEANUP() #define APC_CREATE_MUTEX(lock) CREATE_LOCK(lock) #define APC_DESTROY_MUTEX(lock) DESTROY_LOCK(lock) #define APC_MUTEX_LOCK(lock) WLOCK(lock) #define APC_MUTEX_UNLOCK(lock) WUNLOCK(lock) #endif #endif	2.24 KB	2024-08-04 15:54
📄 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> \| +----------------------------------------------------------------------+ / #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 #define APC_UNSERIALIZER_ARGS zval value, unsigned char buf, size_t buf_len, void config 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); / * 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) { int retval = 0; zend_string lookup = zend_string_init( APC_SERIALIZER_CONSTANT, sizeof(APC_SERIALIZER_CONSTANT)-1, 0); zval magic = zend_get_constant(lookup); / zend_get_constant will return 1 on success, otherwise apc_magic_constant wouldn't be touched at all / if (magic) { apc_register_serializer_t register_func = (apc_register_serializer_t)(Z_LVAL_P(magic)); if(register_func) { retval = register_func(name, serialize, unserialize, NULL); } } zend_string_release(lookup); return retval; } #endif / * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: noexpandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: noexpandtab sw=4 ts=4 sts=4 */	2.96 KB	2024-08-04 15:54
📄 apc_sma.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> \| +----------------------------------------------------------------------+ 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 APC_SMA_H #define APC_SMA_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 / #include "apc.h" / {{{ 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 { zend_long size; / size of this free block / zend_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 / }; / }}} / typedef void (apc_sma_expunge_f)(void pointer, size_t size); / }}} / / {{{ struct definition: apc_sma_t / typedef struct _apc_sma_t { zend_bool initialized; / flag to indicate this sma has been initialized / / callback / apc_sma_expunge_f expunge; / expunge / void* data; /* expunge data / / info / int32_t num; / number of segments / size_t size; / segment size / int32_t 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_init( apc_sma_t sma, void** data, apc_sma_expunge_f expunge, int32_t num, size_t size, char mask); / * apc_sma_detach will detach from shared memory and cleanup local allocations. / PHP_APCU_API void apc_sma_detach(apc_sma_t sma); /* * apc_smap_api_malloc will allocate a block from the sma of the given size / PHP_APCU_API void apc_sma_malloc(apc_sma_t* sma, size_t size); /* * apc_sma_api_malloc_ex will allocate a block from the sma of the given size and * provide the size of the actual allocation. / PHP_APCU_API void apc_sma_malloc_ex( apc_sma_t sma, size_t size, size_t allocated); /* * apc_sma_api_free will free p (which should be a pointer to a block allocated from sma) / PHP_APCU_API void apc_sma_free(apc_sma_t sma, void* p); /* * apc_sma_api_protect will protect p (which should be a pointer to a block allocated from sma) / PHP_APCU_API void apc_sma_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_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_info(apc_sma_t* sma, zend_bool limited); /* * 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_free_info(apc_sma_t sma, apc_sma_info_t* info); /* * apc_sma_api_get_avail_mem will return the amount of memory available left to sma / PHP_APCU_API size_t apc_sma_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_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_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)) /* }}} */ #endif	5.48 KB	2024-08-04 15:54
📄 apc_stack.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> \| +----------------------------------------------------------------------+ 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 APC_STACK_H #define APC_STACK_H / Basic stack datatype / #define T apc_stack_t typedef struct apc_stack_t apc_stack_t; /* opaque stack type / extern T apc_stack_create(size_t size_hint); extern void apc_stack_destroy(T stack); extern void apc_stack_clear(T stack); extern void apc_stack_push(T stack, void item); extern void* apc_stack_pop(T stack); extern void* apc_stack_top(T stack); extern void* apc_stack_get(T stack, size_t n); extern int apc_stack_size(T stack); #undef T #endif /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: noexpandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: noexpandtab sw=4 ts=4 sts=4 */	2.23 KB	2024-08-04 15:54
📄 php_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> \| +----------------------------------------------------------------------+ 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 PHP_APCU_H #define PHP_APCU_H #include "apc.h" #include "apc_globals.h" #define PHP_APCU_VERSION "5.1.23" #define PHP_APCU_EXTNAME "apcu" PHP_APCU_API zend_bool apc_is_enabled(void); extern zend_module_entry apcu_module_entry; #define apcu_module_ptr &apcu_module_entry #define phpext_apcu_ptr apcu_module_ptr #if defined(ZTS) && defined(COMPILE_DL_APCU) ZEND_TSRMLS_CACHE_EXTERN(); #endif #endif / PHP_APC_H / / * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim>600: noexpandtab sw=4 ts=4 sts=4 fdm=marker * vim<600: noexpandtab sw=4 ts=4 sts=4 */	2.23 KB	2024-08-04 15:54
📄 php_apc_legacy_arginfo.h /* This is a generated file, edit the .stub.php file instead. * Stub hash: 5282d856fd334278d5799581ad251977a3c6b18e */ ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_clear_cache, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_cache_info, 0, 0, 0) ZEND_ARG_INFO(0, limited) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_key_info, 0, 0, 1) ZEND_ARG_INFO(0, key) ZEND_END_ARG_INFO() #define arginfo_apcu_sma_info arginfo_apcu_cache_info #define arginfo_apcu_enabled arginfo_apcu_clear_cache ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_store, 0, 0, 1) ZEND_ARG_INFO(0, key) ZEND_ARG_INFO(0, value) ZEND_ARG_INFO(0, ttl) ZEND_END_ARG_INFO() #define arginfo_apcu_add arginfo_apcu_store ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_inc, 0, 0, 1) ZEND_ARG_INFO(0, key) ZEND_ARG_INFO(0, step) ZEND_ARG_INFO(1, success) ZEND_ARG_INFO(0, ttl) ZEND_END_ARG_INFO() #define arginfo_apcu_dec arginfo_apcu_inc ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_cas, 0, 0, 3) ZEND_ARG_INFO(0, key) ZEND_ARG_INFO(0, old) ZEND_ARG_INFO(0, new) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_fetch, 0, 0, 1) ZEND_ARG_INFO(0, key) ZEND_ARG_INFO(1, success) ZEND_END_ARG_INFO() #define arginfo_apcu_exists arginfo_apcu_key_info #define arginfo_apcu_delete arginfo_apcu_key_info ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_entry, 0, 0, 2) ZEND_ARG_INFO(0, key) ZEND_ARG_INFO(0, callback) ZEND_ARG_INFO(0, ttl) ZEND_END_ARG_INFO() #if defined(APC_DEBUG) ZEND_BEGIN_ARG_INFO_EX(arginfo_apcu_inc_request_time, 0, 0, 0) ZEND_ARG_INFO(0, by) ZEND_END_ARG_INFO() #endif PHP_APCU_API ZEND_FUNCTION(apcu_clear_cache); PHP_APCU_API ZEND_FUNCTION(apcu_cache_info); PHP_APCU_API ZEND_FUNCTION(apcu_key_info); PHP_APCU_API ZEND_FUNCTION(apcu_sma_info); PHP_APCU_API ZEND_FUNCTION(apcu_enabled); PHP_APCU_API ZEND_FUNCTION(apcu_store); PHP_APCU_API ZEND_FUNCTION(apcu_add); PHP_APCU_API ZEND_FUNCTION(apcu_inc); PHP_APCU_API ZEND_FUNCTION(apcu_dec); PHP_APCU_API ZEND_FUNCTION(apcu_cas); PHP_APCU_API ZEND_FUNCTION(apcu_fetch); PHP_APCU_API ZEND_FUNCTION(apcu_exists); PHP_APCU_API ZEND_FUNCTION(apcu_delete); PHP_APCU_API ZEND_FUNCTION(apcu_entry); #if defined(APC_DEBUG) PHP_APCU_API ZEND_FUNCTION(apcu_inc_request_time); #endif static const zend_function_entry ext_functions[] = { ZEND_FE(apcu_clear_cache, arginfo_apcu_clear_cache) ZEND_FE(apcu_cache_info, arginfo_apcu_cache_info) ZEND_FE(apcu_key_info, arginfo_apcu_key_info) ZEND_FE(apcu_sma_info, arginfo_apcu_sma_info) ZEND_FE(apcu_enabled, arginfo_apcu_enabled) ZEND_FE(apcu_store, arginfo_apcu_store) ZEND_FE(apcu_add, arginfo_apcu_add) ZEND_FE(apcu_inc, arginfo_apcu_inc) ZEND_FE(apcu_dec, arginfo_apcu_dec) ZEND_FE(apcu_cas, arginfo_apcu_cas) ZEND_FE(apcu_fetch, arginfo_apcu_fetch) ZEND_FE(apcu_exists, arginfo_apcu_exists) ZEND_FE(apcu_delete, arginfo_apcu_delete) ZEND_FE(apcu_entry, arginfo_apcu_entry) #if defined(APC_DEBUG) ZEND_FE(apcu_inc_request_time, arginfo_apcu_inc_request_time) #endif ZEND_FE_END };	2.91 KB	2024-08-04 15:54

Terminal