Viewing file:  eaccelerator.c (81.88 KB) -rw-rw-r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
+----------------------------------------------------------------------+
| eAccelerator project |
+----------------------------------------------------------------------+
| Copyright (c) 2004 - 2012 eAccelerator |
| http://eaccelerator.net |
+----------------------------------------------------------------------+
| This program is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License |
| as published by the Free Software Foundation; either version 2 |
| of the License, or (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, |
| MA 02111-1307, USA. |
| |
| A copy is availble at http://www.gnu.org/copyleft/gpl.txt |
+----------------------------------------------------------------------+
$Id: eaccelerator.c 426 2010-07-28 09:41:24Z bart $
*/
#include "eaccelerator.h"
#include "eaccelerator_version.h"
#ifdef HAVE_EACCELERATOR
#include "opcodes.h"
#include "zend.h"
#include "zend_API.h"
#include "zend_extensions.h"
#include "debug.h"
#include "ea_store.h"
#include "ea_restore.h"
#include "ea_info.h"
#include "ea_dasm.h"
#include <sys/types.h>
#include <sys/stat.h>
#ifdef ZEND_WIN32
# include "fnmatch.h"
# include "win32/time.h"
# include <time.h>
# include <sys/utime.h>
#else
# include <fnmatch.h>
# include <sys/file.h>
# include <sys/time.h>
# include <utime.h>
#endif
#include <fcntl.h>
#ifndef O_BINARY
# define O_BINARY 0
#endif
#include "php.h"
#include "php_ini.h"
#include "php_logos.h"
#include "main/fopen_wrappers.h"
#include "ext/standard/info.h"
#include "ext/standard/php_incomplete_class.h"
#include "ext/standard/md5.h"
#include "SAPI.h"
#define MAX_DUP_STR_LEN 256
/* Globals (different for each process/thread) */
ZEND_DECLARE_MODULE_GLOBALS(eaccelerator)
/* Globals (common for each process/thread) */
static long ea_shm_size = 0;
static long ea_shm_ttl = 0;
static long ea_shm_prune_period = 0;
extern long ea_debug;
zend_bool ea_scripts_shm_only = 0;
eaccelerator_mm *ea_mm_instance = NULL;
static int ea_is_zend_extension = 0;
static int ea_is_extension = 0;
zend_extension* ZendOptimizer = NULL;
static HashTable ea_global_function_table;
static HashTable ea_global_class_table;
int binary_eaccelerator_version[2];
int binary_php_version[2];
int binary_zend_version[2];
/* pointer to the properties_info hashtable destructor */
extern dtor_func_t properties_info_dtor;
/* saved original functions */
static zend_op_array *(*ea_saved_zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
#ifdef DEBUG
static void (*ea_saved_zend_execute)(zend_op_array *op_array TSRMLS_DC);
#endif
/* external declarations */
PHPAPI void php_stripslashes(char *str, int *len TSRMLS_DC);
ZEND_DLEXPORT zend_op_array* eaccelerator_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC);
/******************************************************************************/
/* hash mm functions */
/******************************************************************************/
/* Find a script entry with the given hash key */
static ea_cache_entry* hash_find_mm(const char *key,
struct stat *buf,
int *nreloads,
time_t ttl TSRMLS_DC)
{
unsigned int hv, slot;
ea_cache_entry *p, *q;
hv = zend_get_hash_value((char *)key, strlen(key));
slot = hv & EA_HASH_MAX;
EACCELERATOR_LOCK_RW();
q = NULL;
p = ea_mm_instance->hash[slot];
while (p != NULL) {
if ((p->hv == hv) && (strcmp(p->realfilename, key) == 0)) {
if (EAG(check_mtime_enabled) && ea_mm_instance->check_mtime_enabled &&
(buf->st_mtime != p->mtime || buf->st_size != p->filesize)) {
/* key is invalid. Remove it. */
*nreloads = p->nreloads+1;
if (q == NULL) {
ea_mm_instance->hash[slot] = p->next;
} else {
q->next = p->next;
}
ea_mm_instance->hash_cnt--;
if (p->use_cnt > 0) {
/* key is used by other process/thread. Schedule it for removal */
p->removed = 1;
p->next = ea_mm_instance->removed;
ea_mm_instance->removed = p;
ea_mm_instance->rem_cnt++;
EACCELERATOR_UNLOCK_RW();
return NULL;
} else {
/* key is unused. Remove it. */
eaccelerator_free_nolock(p);
EACCELERATOR_UNLOCK_RW();
return NULL;
}
} else {
/* key is valid */
p->nhits++;
p->use_cnt++;
p->ttl = ttl;
EACCELERATOR_UNLOCK_RW();
return p;
}
}
q = p;
p = p->next;
}
EACCELERATOR_UNLOCK_RW();
return NULL;
}
/* Add a new entry to the hashtable */
static void hash_add_mm(ea_cache_entry *x)
{
ea_cache_entry *p,*q;
unsigned int slot;
x->hv = zend_get_hash_value(x->realfilename, strlen(x->realfilename));
slot = x->hv & EA_HASH_MAX;
EACCELERATOR_LOCK_RW();
x->next = ea_mm_instance->hash[slot];
ea_mm_instance->hash[slot] = x;
ea_mm_instance->hash_cnt++;
q = x;
p = x->next;
while (p != NULL) {
if ((p->hv == x->hv) &&
(strcmp(p->realfilename, x->realfilename) == 0)) {
q->next = p->next;
ea_mm_instance->hash_cnt--;
ea_mm_instance->hash[slot]->nreloads += p->nreloads;
if (p->use_cnt > 0) {
/* key is used by other process/thread. Shedule it to remove */
p->removed = 1;
p->next = ea_mm_instance->removed;
ea_mm_instance->removed = p;
ea_mm_instance->rem_cnt++;
EACCELERATOR_UNLOCK_RW();
return;
} else {
/* key is unused. Remove it. */
eaccelerator_free_nolock(p);
EACCELERATOR_UNLOCK_RW();
return;
}
}
q = p;
p = p->next;
}
EACCELERATOR_UNLOCK_RW();
}
/* Initialise the shared memory */
static int init_mm(TSRMLS_D)
{
pid_t owner = getpid();
MM *mm;
size_t total;
char mm_path[MAXPATHLEN];
#ifdef ZEND_WIN32
snprintf(mm_path, MAXPATHLEN, "%s.%s", EACCELERATOR_MM_FILE, sapi_module.name);
#else
snprintf(mm_path, MAXPATHLEN, "%s.%s%d", EACCELERATOR_MM_FILE, sapi_module.name, owner);
#endif
/* snprintf(mm_path, MAXPATHLEN, "%s.%s%d", EACCELERATOR_MM_FILE, sapi_module.name, geteuid());*/
if ((ea_mm_instance = (eaccelerator_mm*)mm_attach(ea_shm_size*1024*1024, mm_path)) != NULL) {
#ifdef ZTS
ea_mutex = tsrm_mutex_alloc();
#endif
return SUCCESS;
}
mm = mm_create(ea_shm_size*1024*1024, mm_path);
if (!mm) {
return FAILURE;
}
#ifdef ZEND_WIN32
DBG(ea_debug_printf, (EA_DEBUG, "init_mm [%d]\n", owner));
#else
DBG(ea_debug_printf, (EA_DEBUG, "init_mm [%d,%d]\n", owner, getppid()));
#endif
#ifdef ZTS
ea_mutex = tsrm_mutex_alloc();
#endif
total = mm_available(mm);
ea_mm_instance = mm_malloc_lock(mm, sizeof(eaccelerator_mm));
if (!ea_mm_instance) {
return FAILURE;
}
mm_set_attach(mm, ea_mm_instance);
memset(ea_mm_instance, 0, sizeof(eaccelerator_mm));
ea_mm_instance->owner = owner;
ea_mm_instance->mm = mm;
ea_mm_instance->total = total;
ea_mm_instance->hash_cnt = 0;
ea_mm_instance->rem_cnt = 0;
ea_mm_instance->enabled = 1;
ea_mm_instance->optimizer_enabled = 1;
ea_mm_instance->check_mtime_enabled = 1;
ea_mm_instance->removed = NULL;
ea_mm_instance->cache_dir_uid = 0;
ea_mm_instance->last_prune = time(NULL); /* this time() call is harmless since this is init phase */
return SUCCESS;
}
/* Clean up the shared memory */
static void shutdown_mm(TSRMLS_D)
{
if (ea_mm_instance) {
#ifdef ZEND_WIN32
if (ea_mm_instance->owner == getpid()) {
#else
if (getpgrp() == getpid()) {
#endif
MM *mm = ea_mm_instance->mm;
#ifdef ZEND_WIN32
DBG(ea_debug_printf, (EA_DEBUG, "shutdown_mm [%d]\n", getpid()));
#else
DBG(ea_debug_printf, (EA_DEBUG, "shutdown_mm [%d,%d]\n", getpid(), getppid()));
#endif
#ifdef ZTS
tsrm_mutex_free(ea_mutex);
#endif
if (mm) {
mm_destroy(mm);
}
ea_mm_instance = NULL;
}
}
}
void encode_version(const char *str, int *version, int *extra)
{
unsigned int a = 0;
unsigned int b = 0;
unsigned int c = 0;
unsigned int d = 0;
size_t len;
char s[255];
char buf[255];
len = strlen(str);
memcpy(buf, str, (len > 255) ? 255 : len);
buf[254] = '\0';
memset(s, 0, 255);
sscanf(str, "%u.%u.%u%s", &a, &b, &c, s);
if (s[0] == '.') {
sscanf(s, ".%u-%s", &d, buf);
} else if (s[0] == '-') {
memcpy(buf, &s[1], 254);
} else {
memcpy(buf, s, 255);
}
*version = ((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff);
if (buf[0] == 0) {
a = 0;
b = 0;
} else if (strncasecmp(buf, "rev", 3) == 0) {
a = 1;
sscanf(buf, "rev%u", &b);
} else if (strncasecmp(buf, "rc", 2) == 0) {
a = 2;
sscanf(buf, "rc%u", &b);
} else if (strncasecmp(buf, "beta", 4) == 0) {
a = 3;
sscanf(buf, "beta%u", &b);
} else {
a = 0xf;
// just encode the first 4 bytes
b = ((buf[0] & 0x7f) << 21) | ((buf[1] & 0x7f) << 14) | ((buf[2] & 0x7f) << 7) | (buf[3] & 0x7f);
}
*extra = ((a & 0xf) << 28) | (0x0fffffff & b);
}
#ifdef DEBUG
static void decode_version(int version, int extra, char *str, size_t len)
{
int number;
if ((version & 0xff) == 0) {
number = snprintf(str, len, "%u.%u.%u", (version >> 24), ((version >> 16) & 0xff), ((version >> 8) & 0xff));
} else {
number = snprintf(str, len, "%u.%u.%u.%u", (version >> 24), ((version >> 16) & 0xff), ((version >> 8) & 0xff), (version & 0xff));
}
if (extra != 0) {
unsigned int type = ((extra >> 28) & 0xf);
extra = (extra & 0x0fffffff);
switch (type) {
case 1:
snprintf(&str[number], len, "-rev%u", extra);
break;
case 2:
snprintf(&str[number], len, "-rc%u", extra);
break;
case 3:
snprintf(&str[number], len, "-beta%u", extra);
break;
case 15:
if ((int)len >= number + 5) {
str[number] = '-';
str[number + 1] = (extra >> 21) & 0x7f;
str[number + 2] = (extra >> 14) & 0x7f;
str[number + 3] = (extra >> 7) & 0x7f;
str[number + 4] = extra & 0x7f;
str[number + 5] = '\0';
}
break;
default:
break;
}
}
}
#endif
static char num2hex[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
/* Function to create a hash key when filenames are used */
int eaccelerator_md5(char* s, const char* prefix, const char* key TSRMLS_DC)
{
char md5str[33];
PHP_MD5_CTX context;
unsigned char digest[16];
int i;
int n;
md5str[0] = '\0';
PHP_MD5Init(&context);
PHP_MD5Update(&context, (unsigned char*)key, strlen(key));
PHP_MD5Final(digest, &context);
make_digest(md5str, digest);
snprintf(s, MAXPATHLEN-1, "%s/%d/", EAG(cache_dir), ea_mm_instance->cache_dir_uid);
n = strlen(s);
for (i = 0; i < EACCELERATOR_HASH_LEVEL && n < MAXPATHLEN - 1; i++) {
s[n++] = md5str[i];
s[n++] = '/';
}
s[n] = 0;
snprintf(&s[n], MAXPATHLEN-1-n, "%s%s", prefix, md5str);
return 1;
}
/* Remove expired keys, content and scripts from the memory cache */
void eaccelerator_prune(time_t t)
{
unsigned int i;
EACCELERATOR_LOCK_RW();
ea_mm_instance->last_prune = t;
for (i = 0; i < EA_HASH_SIZE; i++) {
ea_cache_entry **p = &ea_mm_instance->hash[i];
while (*p != NULL) {
struct stat buf;
if (((*p)->ttl != 0 && (*p)->ttl < t && (*p)->use_cnt <= 0) ||
stat((*p)->realfilename,&buf) != 0 ||
(*p)->mtime != buf.st_mtime ||
(*p)->filesize != buf.st_size) {
ea_cache_entry *r = *p;
*p = (*p)->next;
ea_mm_instance->hash_cnt--;
eaccelerator_free_nolock(r);
} else {
p = &(*p)->next;
}
}
}
EACCELERATOR_UNLOCK_RW();
}
/* Allocate a new cache chunk */
void* eaccelerator_malloc2(size_t size TSRMLS_DC)
{
void *p = NULL;
if (ea_shm_prune_period > 0) {
if (EAG(req_start) - ea_mm_instance->last_prune > ea_shm_prune_period) {
eaccelerator_prune(EAG(req_start));
p = eaccelerator_malloc(size);
}
}
return p;
}
#define EACCELERATOR_CRC32(crc, ch) (crc = (crc >> 8) ^ crc32tab[(crc ^ (ch)) & 0xff])
static const unsigned int crc32tab[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
};
unsigned int eaccelerator_crc32(const char *p, size_t n)
{
unsigned int crc = ~0;
for (; n--; ++p) {
EACCELERATOR_CRC32(crc, *p);
}
return ~crc;
}
/******************************************************************************/
/* Cache file functions. */
/******************************************************************************/
/* A function to check if the header of a cache file valid is.
*/
inline int check_header(ea_file_header *hdr)
{
#ifdef DEBUG
char current[255];
char cache[255];
#endif
if (strncmp(hdr->magic, EA_MAGIC, 8) != 0) {
#ifdef DEBUG
ea_debug_printf(EA_DEBUG, "Magic header mismatch.");
#endif
return 0;
}
if (hdr->eaccelerator_version[0] != binary_eaccelerator_version[0]
|| hdr->eaccelerator_version[1] != binary_eaccelerator_version[1]) {
#ifdef DEBUG
decode_version(hdr->eaccelerator_version[0], hdr->eaccelerator_version[1], cache, 255);
decode_version(binary_eaccelerator_version[0], binary_eaccelerator_version[1], current, 255);
ea_debug_printf(EA_DEBUG, "eAccelerator version mismatch, cache file %s and current version %s\n", cache, current);
#endif
return 0;
}
if (hdr->zend_version[0] != binary_zend_version[0]
|| hdr->zend_version[1] != binary_zend_version[1]) {
#ifdef DEBUG
decode_version(hdr->zend_version[0], hdr->zend_version[1], cache, 255);
decode_version(binary_zend_version[0], binary_zend_version[1], current, 255);
ea_debug_printf(EA_DEBUG, "Zend version mismatch, cache file %s and current version %s\n", cache, current);
#endif
return 0;
}
if (hdr->php_version[0] != binary_php_version[0]
|| hdr->php_version[1] != binary_php_version[1]) {
#ifdef DEBUG
decode_version(hdr->php_version[0], hdr->php_version[1], cache, 255);
decode_version(binary_php_version[0], binary_php_version[1], current, 255);
ea_debug_printf(EA_DEBUG, "PHP version mismatch, cache file %s and current version %s\n", cache, current);
#endif
return 0;
}
return 1;
}
/* A function to create the header for a cache file.
*/
inline void init_header(ea_file_header *hdr)
{
strncpy(hdr->magic, EA_MAGIC, 8);
hdr->eaccelerator_version[0] = binary_eaccelerator_version[0];
hdr->eaccelerator_version[1] = binary_eaccelerator_version[1];
hdr->zend_version[0] = binary_zend_version[0];
hdr->zend_version[1] = binary_zend_version[1];
hdr->php_version[0] = binary_php_version[0];
hdr->php_version[1] = binary_php_version[1];
}
/* Retrieve a cache entry from the cache directory */
static ea_cache_entry* hash_find_file(const char *key, struct stat *buf TSRMLS_DC)
{
int f;
char s[MAXPATHLEN];
ea_file_header hdr;
ea_cache_entry *p = NULL;
int use_shm = 1;
if (!eaccelerator_md5(s, "/eaccelerator-", key TSRMLS_CC)) {
return NULL;
}
if ((f = open(s, O_RDONLY | O_BINARY)) > 0) {
EACCELERATOR_FLOCK(f, LOCK_SH);
if (read(f, &hdr, sizeof(hdr)) != sizeof(hdr)) {
EACCELERATOR_FLOCK(f, LOCK_UN);
close(f);
return NULL;
}
if (!check_header(&hdr)) {
EACCELERATOR_FLOCK(f, LOCK_UN);
close(f);
unlink(s);
return NULL;
}
p = eaccelerator_malloc(hdr.size);
if (p == NULL) {
p = eaccelerator_malloc2(hdr.size TSRMLS_CC);
}
if (p == NULL) {
p = emalloc(hdr.size);
use_shm = 0;
}
if (p == NULL) {
EACCELERATOR_FLOCK(f, LOCK_UN);
close(f);
return NULL;
}
if (read(f, p, hdr.size) != hdr.size ||
p->size != hdr.size ||
hdr.crc32 != eaccelerator_crc32((const char*)p,p->size)) {
EACCELERATOR_FLOCK(f, LOCK_UN);
close(f);
unlink(s);
if (use_shm) {
eaccelerator_free(p);
} else {
efree(p);
}
DBG(ea_debug_printf, (EA_DEBUG, "cache file is corrupted\n"));
return NULL;
}
EACCELERATOR_FLOCK(f, LOCK_UN);
close(f);
if (strcmp(key,p->realfilename) != 0) {
if (use_shm) {
eaccelerator_free(p);
} else {
efree(p);
}
return NULL;
}
if ((EAG(check_mtime_enabled) && ea_mm_instance->check_mtime_enabled &&
(buf->st_mtime != p->mtime || buf->st_size != p->filesize))
) {
/* key is invalid. Remove it. */
if (use_shm) {
eaccelerator_free(p);
} else {
efree(p);
}
unlink(s);
return NULL;
}
eaccelerator_fixup(p TSRMLS_CC);
if (use_shm) {
p->nhits = 1;
p->nreloads = 1;
p->use_cnt = 1;
p->removed = 0;
if (ea_shm_ttl > 0) {
p->ttl = EAG(req_start) + ea_shm_ttl;
} else {
p->ttl = 0;
}
p->ts = hdr.ts; /* get cached item creation timestamp from cache file */
hash_add_mm(p);
} else {
p->use_cnt = 0;
p->removed = 1;
}
mm_check_mem(p);
return p;
}
return NULL;
}
/* Add a cache entry to the cache directory */
static int hash_add_file(ea_cache_entry *p TSRMLS_DC)
{
int f;
int ret = 0;
char s[MAXPATHLEN];
ea_file_header hdr;
if (!eaccelerator_md5(s, "/eaccelerator-", p->realfilename TSRMLS_CC)) {
return 0;
}
unlink(s);
f = open(s, O_CREAT | O_WRONLY | O_EXCL | O_BINARY, S_IRUSR | S_IWUSR);
if (f > 0) {
EACCELERATOR_FLOCK(f, LOCK_EX);
init_header(&hdr);
hdr.size = p->size;
hdr.mtime = p->mtime;
hdr.ts = p->ts;
p->next = p;
hdr.crc32 = eaccelerator_crc32((const char*)p,p->size);
ret = (write(f, &hdr, sizeof(hdr)) == sizeof(hdr));
if (ret) {
ret = (write(f, p, p->size) == p->size);
}
EACCELERATOR_FLOCK(f, LOCK_UN);
close(f);
} else {
ea_debug_log("EACCELERATOR: Open for write failed for \"%s\": %s\n", s, strerror(errno));
}
return ret;
}
/* called after succesful compilation, from eaccelerator_compile file */
/* Adds the data from the compilation of the script to the cache */
static int eaccelerator_store(char* key, struct stat *buf, int nreloads,
zend_op_array* op_array,
Bucket* f, Bucket *c TSRMLS_DC)
{
ea_cache_entry *p;
int len = strlen(key);
int use_shm = 1;
int ret = 0;
int size = 0;
void *data = NULL;
zend_try {
size = calc_size(key, op_array, f, c TSRMLS_CC);
} zend_catch {
size = 0;
} zend_end_try();
if (size == 0) {
return 0;
}
EAG(mem) = eaccelerator_malloc(size);
if (EAG(mem) == NULL) {
EAG(mem) = eaccelerator_malloc2(size TSRMLS_CC);
}
if (!EAG(mem) && !ea_scripts_shm_only) {
EAG(mem) = emalloc(size);
use_shm = 0;
}
if (EAG(mem)) {
data = EAG(mem);
memset(EAG(mem), 0, size);
p = (ea_cache_entry *)EAG(mem);
eaccelerator_store_int(p, key, len, op_array, f, c TSRMLS_CC);
p->mtime = buf->st_mtime;
p->ts = EAG(req_start);
p->filesize = buf->st_size;
p->size = size;
p->nreloads = nreloads;
if (use_shm) {
if (ea_shm_ttl > 0) {
p->ttl = EAG(req_start) + ea_shm_ttl;
} else {
p->ttl = 0;
}
if (!ea_scripts_shm_only) {
hash_add_file(p TSRMLS_CC);
}
hash_add_mm(p);
ret = 1;
mm_check_mem(data);
} else {
ret = hash_add_file(p TSRMLS_CC);
efree(p);
}
}
return ret;
}
/* Try to restore a file from the cache. If the file isn't found in memory, the
the disk cache is checked */
static zend_op_array* eaccelerator_restore(char *realname, struct stat *buf,
int *nreloads, time_t compile_time TSRMLS_DC)
{
ea_cache_entry *p;
zend_op_array *op_array = NULL;
*nreloads = 1;
p = hash_find_mm(realname, buf, nreloads, ((ea_shm_ttl > 0)?(compile_time + ea_shm_ttl):0) TSRMLS_CC);
if (p == NULL && !ea_scripts_shm_only) {
p = hash_find_file(realname, buf TSRMLS_CC);
}
if (p != NULL && p->op_array != NULL) {
/* only restore file when open_basedir allows it */
if (PG(open_basedir) && php_check_open_basedir(p->realfilename TSRMLS_CC)) {
return NULL;
}
EAG(class_entry) = NULL;
op_array = restore_op_array(NULL, p->op_array TSRMLS_CC);
if (op_array != NULL) {
ea_fc_entry *e;
ea_used_entry *used = emalloc(sizeof(ea_used_entry));
used->entry = p;
used->next = (ea_used_entry*)EAG(used_entries);
EAG(used_entries) = (void*)used;
EAG(mem) = (char*)op_array->filename;
/* only restore the classes and functions when we restore this script
* for the first time.
*/
if (!zend_hash_exists(&EAG(restored), p->realfilename, strlen(p->realfilename))) {
for (e = p->c_head; e!=NULL; e = e->next) {
restore_class(e TSRMLS_CC);
}
for (e = p->f_head; e!=NULL; e = e->next) {
restore_function(e TSRMLS_CC);
}
zend_hash_add(&EAG(restored), p->realfilename, strlen(p->realfilename), NULL, 0, NULL);
}
EAG(mem) = p->realfilename;
}
#ifdef ZEND_COMPILE_DELAYED_BINDING
zend_do_delayed_early_binding(op_array TSRMLS_CC);
#endif
}
return op_array;
}
/*
* Returns the realpath for given filename according to include path
*/
static char *ea_resolve_path(const char *filename, int filename_length, const char *path TSRMLS_DC)
{
char resolved_path[MAXPATHLEN];
char trypath[MAXPATHLEN];
const char *ptr, *end, *p;
char *actual_path;
php_stream_wrapper *wrapper;
if (!filename) {
return NULL;
}
/* Don't resolve paths which contain protocol (except of file://) */
for (p = filename; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; p++) {
;
}
if ((*p == ':') && (p - filename > 1) && (p[1] == '/') && (p[2] == '/')) {
wrapper = php_stream_locate_url_wrapper(filename, &actual_path, STREAM_OPEN_FOR_INCLUDE TSRMLS_CC);
if (wrapper == &php_plain_files_wrapper) {
if (tsrm_realpath(actual_path, resolved_path TSRMLS_CC)) {
return estrdup(resolved_path);
}
}
return NULL;
}
if ((*filename == '.' &&
(IS_SLASH(filename[1]) ||
((filename[1] == '.') && IS_SLASH(filename[2])))) ||
IS_ABSOLUTE_PATH(filename, filename_length) ||
!path ||
!*path) {
if (tsrm_realpath(filename, resolved_path TSRMLS_CC)) {
return estrdup(resolved_path);
} else {
return NULL;
}
}
ptr = path;
while (ptr && *ptr) {
/* Check for stream wrapper */
int is_stream_wrapper = 0;
for (p = ptr; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; p++) {
;
}
if ((*p == ':') && (p - ptr > 1) && (p[1] == '/') && (p[2] == '/')) {
/* .:// or ..:// is not a stream wrapper */
if (p[-1] != '.' || p[-2] != '.' || p - 2 != ptr) {
p += 3;
is_stream_wrapper = 1;
}
}
end = strchr(p, DEFAULT_DIR_SEPARATOR);
if (end) {
if ((end-ptr) + 1 + filename_length + 1 >= MAXPATHLEN) {
ptr = end + 1;
continue;
}
memcpy(trypath, ptr, end-ptr);
trypath[end-ptr] = '/';
memcpy(trypath+(end-ptr)+1, filename, filename_length+1);
ptr = end+1;
} else {
int len = strlen(ptr);
if (len + 1 + filename_length + 1 >= MAXPATHLEN) {
break;
}
memcpy(trypath, ptr, len);
trypath[len] = '/';
memcpy(trypath+len+1, filename, filename_length+1);
ptr = NULL;
}
actual_path = trypath;
if (is_stream_wrapper) {
wrapper = php_stream_locate_url_wrapper(trypath, &actual_path, STREAM_OPEN_FOR_INCLUDE TSRMLS_CC);
if (!wrapper) {
continue;
} else if (wrapper != &php_plain_files_wrapper) {
if (wrapper->wops->url_stat) {
php_stream_statbuf ssb;
if (SUCCESS == wrapper->wops->url_stat(wrapper, trypath, 0, &ssb, NULL TSRMLS_CC)) {
return estrdup(trypath);
}
}
continue;
}
}
if (tsrm_realpath(actual_path, resolved_path TSRMLS_CC)) {
return estrdup(resolved_path);
}
} /* end provided path */
/* check in calling scripts' current working directory as a fall back case
*/
if (zend_is_executing(TSRMLS_C)) {
#ifdef ZEND_ENGINE_2_4
const char *exec_fname = zend_get_executed_filename(TSRMLS_C);
#else
char *exec_fname = zend_get_executed_filename(TSRMLS_C);
#endif
int exec_fname_length = strlen(exec_fname);
while ((--exec_fname_length >= 0) && !IS_SLASH(exec_fname[exec_fname_length])) {
;
}
if (exec_fname && exec_fname[0] != '[' &&
exec_fname_length > 0 &&
exec_fname_length + 1 + filename_length + 1 < MAXPATHLEN) {
memcpy(trypath, exec_fname, exec_fname_length + 1);
memcpy(trypath+exec_fname_length + 1, filename, filename_length+1);
actual_path = trypath;
/* Check for stream wrapper */
for (p = trypath; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; p++) {
;
}
if ((*p == ':') && (p - trypath > 1) && (p[1] == '/') && (p[2] == '/')) {
wrapper = php_stream_locate_url_wrapper(trypath, &actual_path, STREAM_OPEN_FOR_INCLUDE TSRMLS_CC);
if (!wrapper) {
return NULL;
} else if (wrapper != &php_plain_files_wrapper) {
if (wrapper->wops->url_stat) {
php_stream_statbuf ssb;
if (SUCCESS == wrapper->wops->url_stat(wrapper, trypath, 0, &ssb, NULL TSRMLS_CC)) {
return estrdup(trypath);
}
}
return NULL;
}
}
if (tsrm_realpath(actual_path, resolved_path TSRMLS_CC)) {
return estrdup(resolved_path);
}
}
}
return NULL;
}
/**
* Get the real filename of the file represented by the given file_handle.
* If unable to determine the realfilename this function returns 0, otherwise
* it returns 1.
*
* realfilename should be MAXPATHLEN long.
*/
static int ea_get_realname(zend_file_handle *file_handle, char* realname TSRMLS_DC)
{
// at least one of these should have value
if (file_handle->opened_path == NULL && file_handle->filename == NULL) {
return 0;
}
if (file_handle->opened_path != NULL) {
strcpy(realname, file_handle->opened_path);
return 1;
}
if (PG(include_path) == NULL ||
file_handle->filename[0] == '.' ||
IS_SLASH(file_handle->filename[0]) ||
IS_ABSOLUTE_PATH(file_handle->filename, strlen(file_handle->filename))) {
return VCWD_REALPATH(file_handle->filename, realname) != NULL;
} else {
int filename_len = strlen(file_handle->filename);
char* temp_name = ea_resolve_path(file_handle->filename, filename_len, PG(include_path) TSRMLS_CC);
if (temp_name == NULL) {
return 0;
}
strcpy(realname, temp_name);
efree(temp_name);
return 1;
}
return 0;
}
static int ea_get_phar_name(const char* filename, size_t filename_len, char* phar_name)
{
size_t i = 0;
for (i = sizeof("phar://"); i < filename_len - sizeof(".phar"); ++i) {
if (filename[i] == '.' && filename[i + 1] == 'p' && filename[i + 2] == 'h' &&
filename[i + 3] == 'a' && filename[i + 4] == 'r') {
int copy_len = (i - sizeof("phar://") + sizeof(".phar"));
if (copy_len >= MAXPATHLEN - 1) {
return 0;
}
memcpy(phar_name, &filename[sizeof("phar://") - 1], copy_len);
phar_name[copy_len] = '\0';
return 1;
}
}
return 0;
}
/*
* Stat the file that belongs to file_handle. It puts result of the stat call
* in buf and the real filename in realname.
*
* Returns 0 when the stat failed or if unable to perform a stat call. If successful
* it returns 1
*/
static int eaccelerator_stat(zend_file_handle *file_handle,
char* realname, struct stat* buf TSRMLS_DC)
{
if (!ea_get_realname(file_handle, realname TSRMLS_CC)) {
#ifdef ZEND_ENGINE_2_3
if (strncmp(file_handle->filename, "phar://", sizeof("phar://"))) {
// Determine the name of the phar archive and use this filename to do the
// stat call. Return filename as realname.
char phar_name[MAXPATHLEN];
size_t filename_len = strlen(file_handle->filename);
if (!ea_get_phar_name(file_handle->filename, filename_len, phar_name)) {
return 0;
}
// TODO: resolve this problem
if (filename_len >= MAXPATHLEN) {
return 0;
}
strcpy(realname, file_handle->filename);
return (stat(phar_name, buf) == 0 && S_ISREG(buf->st_mode));
}
#endif
return 0;
}
if (EAG(check_mtime_enabled) && ea_mm_instance->check_mtime_enabled) {
return (stat(realname, buf) == 0 && S_ISREG(buf->st_mode));
}
return 1;
}
static int ea_match(struct ea_pattern_t *list, const char *path)
{
struct ea_pattern_t *p;
char result, positive;
// apply all patterns
// - when not patterns are given, *accept*
// - when a pattern with a ! matches, *reject*
// - when no negative pattern matches and a positive pattern match, *accept*
// - when no negative pattern matches and there are no possitive patterns, *accept*
// - *reject*
if (list == NULL) {
// there are no patterns, accept
return 1;
}
result = 0; // there are patterns, so if no positive pattern matches, reject
positive = 0;
p = list;
while (p != NULL) {
if (p->pattern[0] == '!') {
if ((fnmatch((const char *)(p->pattern + 1), path, 0) == 0)) {
// a negative pattern matches, accept
return 0;
}
} else {
result |= (fnmatch((const char *)p->pattern, path, 0) == 0);
positive = 1;
}
p = p->next;
}
return result | !positive;
}
/* copy of zend_class_add_ref, the linker isn't able to link to it any more
* in php 5.3
* TODO: see if we can steal the pointer
*/
void ea_class_add_ref(zend_class_entry **ce)
{
(*ce)->refcount++;
}
/*
* Intercept compilation of PHP file. If we already have the file in
* our cache, restore it. Otherwise call the original Zend compilation
* function and store the compiled zend_op_array in out cache.
* This function is called again for each PHP file included in the
* main PHP file.
*/
ZEND_DLEXPORT zend_op_array* eaccelerator_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
{
zend_op_array *t;
struct stat buf;
char realname[MAXPATHLEN];
int nreloads;
int stat_result = 0;
#ifdef DEBUG
struct timeval tv_start;
#endif
int ok_to_cache = 0;
#ifdef ZEND_ENGINE_2_3
zend_uint orig_compiler_options;
#endif
DBG(ea_debug_start_time, (&tv_start));
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Enter COMPILE\n",getpid()));
DBG(ea_debug_printf, (EA_DEBUG, "[%d] compile_file: \"%s\"\n",getpid(), file_handle->filename));
#ifdef DEBUG
EAG(xpad)+=2;
#endif
stat_result = eaccelerator_stat(file_handle, realname, &buf TSRMLS_CC);
ok_to_cache = ea_match(EAG(pattern_list), file_handle->filename);
// eAccelerator isn't working, so just compile the file
if (!EAG(enabled) || (ea_mm_instance == NULL) ||
!ea_mm_instance->enabled || file_handle == NULL ||
file_handle->filename == NULL || stat_result == 0 || !ok_to_cache) {
DBG(ea_debug_printf, (EA_DEBUG, "\t[%d] compile_file: compiling\n", getpid()));
t = ea_saved_zend_compile_file(file_handle, type TSRMLS_CC);
DBG(ea_debug_printf, (EA_TEST_PERFORMANCE, "\t[%d] compile_file: end (%ld)\n", getpid(), ea_debug_elapsed_time(&tv_start)));
DBG(ea_debug_printf, (EA_DEBUG, "\t[%d] compile_file: end\n", getpid()));
#ifdef DEBUG
EAG(xpad)-=2;
#endif
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Leave COMPILE\n", getpid()));
return t;
}
if (buf.st_mtime >= EAG(req_start) && ea_debug > 0) {
ea_debug_log("EACCELERATOR: Warning: \"%s\" is cached but it's mtime is in the future.\n", file_handle->filename);
}
t = eaccelerator_restore(realname, &buf, &nreloads, EAG(req_start) TSRMLS_CC);
/* segv74: really cheap work around to auto_global problem.
it makes just in time to every time.
hrak: TODO this is a really lame hack which totally breaks auto_globals_jit
*/
zend_is_auto_global("_GET", sizeof("_GET")-1 TSRMLS_CC);
zend_is_auto_global("_POST", sizeof("_POST")-1 TSRMLS_CC);
zend_is_auto_global("_COOKIE", sizeof("_COOKIE")-1 TSRMLS_CC);
zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
zend_is_auto_global("_ENV", sizeof("_ENV")-1 TSRMLS_CC);
zend_is_auto_global("_REQUEST", sizeof("_REQUEST")-1 TSRMLS_CC);
zend_is_auto_global("_FILES", sizeof("_FILES")-1 TSRMLS_CC);
#ifdef ZEND_ENGINE_2_4
zend_is_auto_global("GLOBALS", sizeof("GLOBALS")-1 TSRMLS_CC);
#endif
if (t != NULL) { // restore from cache
#ifdef DEBUG
ea_debug_log("[%d] EACCELERATOR hit: \"%s\"\n", getpid(), t->filename);
#else
ea_debug_log("EACCELERATOR hit: \"%s\"\n", t->filename);
#endif
zend_llist_add_element(&CG(open_files), file_handle);
if (file_handle->opened_path == NULL && file_handle->type != ZEND_HANDLE_STREAM) {
file_handle->handle.stream.handle = (void*)1;
file_handle->opened_path = EAG(mem); /* EAG(mem) = p->realfilename from eaccelerator_restore here */
}
DBG(ea_debug_printf, (EA_TEST_PERFORMANCE, "\t[%d] compile_file: restored (%ld)\n", getpid(), ea_debug_elapsed_time(&tv_start)));
DBG(ea_debug_printf, (EA_DEBUG, "\t[%d] compile_file: restored\n", getpid()));
#ifdef DEBUG
EAG(xpad)-=2;
#endif
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Leave COMPILE\n", getpid()));
return t;
} else { // not in cache or must be recompiled
Bucket *function_table_tail;
Bucket *class_table_tail;
HashTable* orig_function_table;
HashTable* orig_class_table;
HashTable* orig_eg_class_table = NULL;
HashTable tmp_function_table;
HashTable tmp_class_table;
zend_function tmp_func;
zend_class_entry tmp_class;
int ea_bailout;
zend_hash_init_ex(&tmp_function_table, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
zend_hash_copy(&tmp_function_table, &ea_global_function_table, NULL, &tmp_func, sizeof(zend_function));
orig_function_table = CG(function_table);
CG(function_table) = &tmp_function_table;
zend_hash_init_ex(&tmp_class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
zend_hash_copy(&tmp_class_table, &ea_global_class_table, (copy_ctor_func_t)ea_class_add_ref, &tmp_class, sizeof(zend_class_entry *));
orig_class_table = CG(class_table);;
CG(class_table) = &tmp_class_table;
orig_eg_class_table = EG(class_table);;
EG(class_table) = &tmp_class_table;
/* Storing global pre-compiled functions and classes */
function_table_tail = CG(function_table)->pListTail;
class_table_tail = CG(class_table)->pListTail;
DBG(ea_debug_printf, (EA_TEST_PERFORMANCE, "\t[%d] compile_file: compiling (%ld)\n", getpid(), ea_debug_elapsed_time(&tv_start)));
if (EAG(optimizer_enabled) && ea_mm_instance->optimizer_enabled) {
EAG(compiler) = 1;
}
/* try to compile the script */
ea_bailout = 0;
zend_try {
#ifdef ZEND_ENGINE_2_3
orig_compiler_options = CG(compiler_options);
CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES | ZEND_COMPILE_DELAYED_BINDING;
#endif
t = ea_saved_zend_compile_file(file_handle, type TSRMLS_CC);
#ifdef ZEND_ENGINE_2_3
CG(compiler_options) = orig_compiler_options;
#endif
} zend_catch {
CG(function_table) = orig_function_table;
CG(class_table) = orig_class_table;
EG(class_table) = orig_eg_class_table;
ea_bailout = 1;
} zend_end_try();
if (ea_bailout) {
zend_bailout();
}
DBG(ea_debug_log_hashkeys, ("class_table\n", CG(class_table)));
EAG(compiler) = 0;
if (t != NULL && file_handle->opened_path != NULL && ((EAG(check_mtime_enabled) && ea_mm_instance->check_mtime_enabled) ||
((stat(file_handle->opened_path, &buf) == 0) && S_ISREG(buf.st_mode)))) {
DBG(ea_debug_printf, (EA_TEST_PERFORMANCE, "\t[%d] compile_file: storing in cache (%ld)\n", getpid(), ea_debug_elapsed_time(&tv_start)));
DBG(ea_debug_printf, (EA_DEBUG, "\t[%d] compile_file: storing in cache\n", getpid()));
function_table_tail = function_table_tail ? function_table_tail->pListNext : CG(function_table)->pListHead;
class_table_tail = class_table_tail ? class_table_tail->pListNext : CG(class_table)->pListHead;
if (eaccelerator_store(file_handle->opened_path, &buf, nreloads, t, function_table_tail, class_table_tail TSRMLS_CC)) {
#ifdef DEBUG
ea_debug_log("[%d] EACCELERATOR %s: \"%s\"\n", getpid(), (nreloads == 1) ? "cached" : "re-cached", file_handle->opened_path);
#else
ea_debug_log("EACCELERATOR %s: \"%s\"\n", (nreloads == 1) ? "cached" : "re-cached", file_handle->opened_path);
#endif
} else {
#ifdef DEBUG
ea_debug_log("[%d] EACCELERATOR can't cache: \"%s\"\n", getpid(), file_handle->opened_path);
#else
ea_debug_log("EACCELERATOR can't cache: \"%s\"\n", file_handle->opened_path);
#endif
}
} else {
function_table_tail = function_table_tail ? function_table_tail->pListNext : CG(function_table)->pListHead;
class_table_tail = class_table_tail ? class_table_tail->pListNext : CG(class_table)->pListHead;
}
CG(function_table) = orig_function_table;
CG(class_table) = orig_class_table;
EG(class_table) = orig_eg_class_table;
while (function_table_tail != NULL) {
zend_op_array *op_array = (zend_op_array*)function_table_tail->pData;
if (op_array->type == ZEND_USER_FUNCTION) {
if (zend_hash_add(CG(function_table), function_table_tail->arKey, function_table_tail->nKeyLength, op_array,
sizeof(zend_op_array), NULL) == FAILURE && function_table_tail->arKey[0] != '\000') {
CG(in_compilation) = 1;
CG(compiled_filename) = file_handle->opened_path;
CG(zend_lineno) = op_array->line_start;
zend_error(E_ERROR, "Cannot redeclare %s()", function_table_tail->arKey);
}
}
function_table_tail = function_table_tail->pListNext;
}
while (class_table_tail != NULL) {
zend_class_entry **ce = (zend_class_entry**)class_table_tail->pData;
if ((*ce)->type == ZEND_USER_CLASS) {
if (zend_hash_add(CG(class_table), class_table_tail->arKey, class_table_tail->nKeyLength,
ce, sizeof(zend_class_entry*), NULL) == FAILURE && class_table_tail->arKey[0] != '\000') {
CG(in_compilation) = 1;
CG(compiled_filename) = file_handle->opened_path;
#ifdef ZEND_ENGINE_2_4
CG(zend_lineno) = (*ce)->info.user.line_start;
#else
CG(zend_lineno) = (*ce)->line_start;
#endif
zend_error(E_ERROR, "Cannot redeclare class %s", class_table_tail->arKey);
}
}
class_table_tail = class_table_tail->pListNext;
}
tmp_function_table.pDestructor = NULL;
tmp_class_table.pDestructor = NULL;
zend_hash_destroy(&tmp_function_table);
zend_hash_destroy(&tmp_class_table);
}
DBG(ea_debug_printf, (EA_TEST_PERFORMANCE, "\t[%d] compile_file: end (%ld)\n", getpid(), ea_debug_elapsed_time(&tv_start)));
DBG(ea_debug_printf, (EA_DEBUG, "\t[%d] compile_file: end\n", getpid()));
#ifdef DEBUG
EAG(xpad)-=2;
#endif
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Leave COMPILE\n", getpid()));
#ifdef ZEND_COMPILE_DELAYED_BINDING
zend_do_delayed_early_binding(t TSRMLS_CC);
#endif
return t;
}
#ifdef DEBUG
static void profile_execute(zend_op_array *op_array TSRMLS_DC)
{
int i;
struct timeval tv_start;
long usec;
for (i=0; i<EAG(profile_level); i++) {
DBG(ea_debug_put, (EA_PROFILE_OPCODES, " "));
}
ea_debug_printf(EA_PROFILE_OPCODES, "enter profile_execute: %s:%s\n", op_array->filename, op_array->function_name);
ea_debug_start_time(&tv_start);
EAG(self_time)[EAG(profile_level)] = 0;
EAG(profile_level)++;
ea_debug_printf(EA_PROFILE_OPCODES, "About to enter zend_execute...\n");
ea_saved_zend_execute(op_array TSRMLS_CC);
ea_debug_printf(EA_PROFILE_OPCODES, "Finished zend_execute...\n");
usec = ea_debug_elapsed_time(&tv_start);
EAG(profile_level)--;
if (EAG(profile_level) > 0) {
EAG(self_time)[EAG(profile_level)-1] += usec;
}
for (i=0; i<EAG(profile_level); i++) {
DBG(ea_debug_put, (EA_PROFILE_OPCODES, " "));
}
ea_debug_printf(EA_PROFILE_OPCODES, "leave profile_execute: %s:%s (%ld,%ld)\n", op_array->filename, op_array->function_name, usec, usec-EAG(self_time)[EAG(profile_level)]);
}
ZEND_DLEXPORT zend_op_array* profile_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
{
zend_op_array *t;
int i;
struct timeval tv_start;
long usec;
ea_debug_start_time(&tv_start);
EAG(self_time)[EAG(profile_level)] = 0;
t = eaccelerator_compile_file(file_handle, type TSRMLS_CC);
usec = ea_debug_elapsed_time(&tv_start);
if (EAG(profile_level) > 0) {
EAG(self_time)[EAG(profile_level)-1] += usec;
}
for (i=0; i<EAG(profile_level); i++) {
DBG(ea_debug_put, (EA_PROFILE_OPCODES, " "));
}
return t;
}
#endif /* DEBUG */
/* Format Bytes */
void format_size(char* s, unsigned int size, int legend)
{
unsigned int i = 0;
unsigned int n = 0;
char ch;
do {
if ((n != 0) && (n % 3 == 0)) {
s[i++] = ',';
}
s[i++] = (char)((int)'0' + (size % 10));
n++;
size = size / 10;
} while (size != 0);
s[i] = '\0';
n = 0;
i--;
while (n < i) {
ch = s[n];
s[n] = s[i];
s[i] = ch;
n++, i--;
}
if (legend) {
strcat(s, " Bytes");
}
}
/* eAccelerator entry for phpinfo() */
PHP_MINFO_FUNCTION(eaccelerator)
{
char s[32];
php_info_print_table_start();
php_info_print_table_header(2, "eAccelerator support", "enabled");
php_info_print_table_row(2, "Version", EACCELERATOR_VERSION);
php_info_print_table_row(2, "Caching Enabled", (EAG(enabled) && (ea_mm_instance != NULL) &&
ea_mm_instance->enabled)?"true":"false");
php_info_print_table_row(2, "Optimizer Enabled", (EAG(optimizer_enabled) &&
(ea_mm_instance != NULL) && ea_mm_instance->optimizer_enabled)?"true":"false");
php_info_print_table_row(2, "Check mtime Enabled", (EAG(check_mtime_enabled) &&
(ea_mm_instance != NULL) && ea_mm_instance->check_mtime_enabled)?"true":"false");
if (ea_mm_instance != NULL) {
size_t available;
available = mm_available(ea_mm_instance->mm);
EACCELERATOR_LOCK_RD();
format_size(s, ea_mm_instance->total, 1);
php_info_print_table_row(2, "Memory Size", s);
format_size(s, available, 1);
php_info_print_table_row(2, "Memory Available", s);
format_size(s, ea_mm_instance->total - available, 1);
php_info_print_table_row(2, "Memory Allocated", s);
snprintf(s, 32, "%u", ea_mm_instance->hash_cnt);
php_info_print_table_row(2, "Cached Scripts", s);
snprintf(s, 32, "%u", ea_mm_instance->rem_cnt);
php_info_print_table_row(2, "Removed Scripts", s);
EACCELERATOR_UNLOCK_RD();
}
php_info_print_table_end();
DISPLAY_INI_ENTRIES();
}
/*
* Parse a list of filters which is seperated by a " "
*/
static struct ea_pattern_t *ea_parse_filter(char *filter) {
char *saveptr = NULL, *token = NULL;
struct ea_pattern_t *list_head = NULL, *p = NULL;
size_t len;
// tokenize the filter string on a space
while ((token = php_strtok_r(filter, " ", &saveptr)) != NULL) {
filter = NULL;
list_head = malloc(sizeof(struct ea_pattern_t));
memset(list_head, 0, sizeof(struct ea_pattern_t));
len = strlen(token);
list_head->pattern = malloc(len + 1);
strncpy(list_head->pattern, token, len + 1);
list_head->next = p;
p = list_head;
}
return list_head;
}
/******************************************************************************/
/*
* Begin of dynamic loadable module interfaces.
* There are two interfaces:
* - standard php module,
* - zend extension.
*/
PHP_INI_MH(eaccelerator_filter)
{
EAG(pattern_list) = ea_parse_filter(new_value);
return SUCCESS;
}
static PHP_INI_MH(eaccelerator_OnUpdateLong)
{
long *p = (long*)mh_arg1;
*p = zend_atoi(new_value, new_value_length);
return SUCCESS;
}
static PHP_INI_MH(eaccelerator_OnUpdateBool)
{
zend_bool *p = (zend_bool*)mh_arg1;
if (strncasecmp("on", new_value, sizeof("on"))) {
*p = (zend_bool) atoi(new_value);
} else {
*p = (zend_bool) 1;
}
return SUCCESS;
}
PHP_INI_BEGIN()
STD_PHP_INI_ENTRY("eaccelerator.enable", "1", PHP_INI_ALL, OnUpdateBool, enabled, zend_eaccelerator_globals, eaccelerator_globals)
STD_PHP_INI_ENTRY("eaccelerator.optimizer", "1", PHP_INI_ALL, OnUpdateBool, optimizer_enabled, zend_eaccelerator_globals, eaccelerator_globals)
ZEND_INI_ENTRY1("eaccelerator.shm_size", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_shm_size)
ZEND_INI_ENTRY1("eaccelerator.shm_ttl", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_shm_ttl)
ZEND_INI_ENTRY1("eaccelerator.shm_prune_period", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_shm_prune_period)
ZEND_INI_ENTRY1("eaccelerator.debug", "1", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_debug)
STD_PHP_INI_ENTRY("eaccelerator.log_file", "", PHP_INI_SYSTEM, OnUpdateString, ea_log_file, zend_eaccelerator_globals, eaccelerator_globals)
STD_PHP_INI_ENTRY("eaccelerator.check_mtime", "1", PHP_INI_SYSTEM, OnUpdateBool, check_mtime_enabled, zend_eaccelerator_globals, eaccelerator_globals)
ZEND_INI_ENTRY1("eaccelerator.shm_only", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateBool, &ea_scripts_shm_only)
#ifdef WITH_EACCELERATOR_INFO
STD_PHP_INI_ENTRY("eaccelerator.allowed_admin_path", "", PHP_INI_SYSTEM, OnUpdateString, allowed_admin_path, zend_eaccelerator_globals, eaccelerator_globals)
#endif
STD_PHP_INI_ENTRY("eaccelerator.cache_dir", "/tmp/eaccelerator", PHP_INI_SYSTEM, OnUpdateString, cache_dir, zend_eaccelerator_globals, eaccelerator_globals)
PHP_INI_ENTRY("eaccelerator.filter", "", PHP_INI_ALL, eaccelerator_filter)
PHP_INI_END()
static void eaccelerator_clean_request(TSRMLS_D)
{
ea_used_entry *p = (ea_used_entry*)EAG(used_entries);
if (ea_mm_instance != NULL) {
if (p != NULL) {
EACCELERATOR_LOCK_RW();
while (p != NULL) {
p->entry->use_cnt--;
if (p->entry->removed && p->entry->use_cnt <= 0) {
if (ea_mm_instance->removed == p->entry) {
ea_mm_instance->removed = p->entry->next;
ea_mm_instance->rem_cnt--;
eaccelerator_free_nolock(p->entry);
p->entry = NULL;
} else {
ea_cache_entry *q = ea_mm_instance->removed;
while (q != NULL && q->next != p->entry) {
q = q->next;
}
if (q != NULL) {
q->next = p->entry->next;
ea_mm_instance->rem_cnt--;
eaccelerator_free_nolock(p->entry);
p->entry = NULL;
}
}
}
p = p->next;
}
EACCELERATOR_UNLOCK_RW();
}
p = (ea_used_entry*)EAG(used_entries);
while (p != NULL) {
ea_used_entry* r = p;
p = p->next;
if (r->entry != NULL && r->entry->use_cnt < 0) {
eaccelerator_free(r->entry);
}
efree(r);
}
}
EAG(used_entries) = NULL;
EAG(in_request) = 0;
}
/* signal handlers */
#ifdef WITH_EACCELERATOR_CRASH_DETECTION
static void eaccelerator_crash_handler(int dummy)
{
struct tm *loctime;
TSRMLS_FETCH();
fflush(stdout);
fflush(stderr);
#ifdef SIGSEGV
if (EAG(original_sigsegv_handler) != eaccelerator_crash_handler) {
signal(SIGSEGV, EAG(original_sigsegv_handler));
} else {
signal(SIGSEGV, SIG_DFL);
}
#endif
#ifdef SIGFPE
if (EAG(original_sigfpe_handler) != eaccelerator_crash_handler) {
signal(SIGFPE, EAG(original_sigfpe_handler));
} else {
signal(SIGFPE, SIG_DFL);
}
#endif
#ifdef SIGBUS
if (EAG(original_sigbus_handler) != eaccelerator_crash_handler) {
signal(SIGBUS, EAG(original_sigbus_handler));
} else {
signal(SIGBUS, SIG_DFL);
}
#endif
#ifdef SIGILL
if (EAG(original_sigill_handler) != eaccelerator_crash_handler) {
signal(SIGILL, EAG(original_sigill_handler));
} else {
signal(SIGILL, SIG_DFL);
}
#endif
#ifdef SIGABRT
if (EAG(original_sigabrt_handler) != eaccelerator_crash_handler) {
signal(SIGABRT, EAG(original_sigabrt_handler));
} else {
signal(SIGABRT, SIG_DFL);
}
#endif
eaccelerator_clean_request(TSRMLS_C);
loctime = localtime(&EAG(req_start));
if (EG(active_op_array)) {
fprintf(stderr, "[%s] [notice] EACCELERATOR(%d): PHP crashed on opline %ld of %s() at %s:%u\n\n",
asctime(loctime),
getpid(),
(long)(active_opline-EG(active_op_array)->opcodes),
get_active_function_name(TSRMLS_C),
zend_get_executed_filename(TSRMLS_C),
zend_get_executed_lineno(TSRMLS_C));
} else {
fprintf(stderr, "[%s] [notice] EACCELERATOR(%d): PHP crashed\n\n", asctime(loctime), getpid());
}
#if !defined(WIN32) && !defined(NETWARE)
kill(getpid(), dummy);
#else
raise(dummy);
#endif
}
#endif
static void eaccelerator_init_globals(zend_eaccelerator_globals *eag)
{
eag->used_entries = NULL;
eag->enabled = 1;
eag->cache_dir = NULL;
eag->optimizer_enabled = 1;
eag->check_mtime_enabled = 1;
eag->compiler = 0;
eag->ea_log_file = '\000';
eag->in_request = 0;
eag->allowed_admin_path= NULL;
eag->pattern_list = NULL;
}
static void eaccelerator_globals_dtor(zend_eaccelerator_globals *eag)
{
struct ea_pattern_t *p, *q;
/* free the list of patterns */
p = eag->pattern_list;
while (p != NULL) {
q = p->next;
free(p->pattern);
free(p);
p = q;
}
eag->pattern_list = NULL;
}
static void register_eaccelerator_as_zend_extension();
static int eaccelerator_check_php_version(TSRMLS_D)
{
zval v;
int ret = 0;
if (zend_get_constant("PHP_VERSION", sizeof("PHP_VERSION")-1, &v TSRMLS_CC)) {
if (Z_TYPE(v) == IS_STRING &&
Z_STRLEN(v) == sizeof(PHP_VERSION)-1 &&
strcmp(Z_STRVAL(v),PHP_VERSION) == 0) {
ret = 1;
} else {
ea_debug_error("[%s] This build of \"%s\" was compiled for PHP version %s. Rebuild it for your PHP version (%s) or download precompiled binaries.\n",
EACCELERATOR_EXTENSION_NAME, EACCELERATOR_EXTENSION_NAME,PHP_VERSION,Z_STRVAL(v));
}
zval_dtor(&v);
} else {
ea_debug_error("[%s] This build of \"%s\" was compiled for PHP version %s. Rebuild it for your PHP version.\n",
EACCELERATOR_EXTENSION_NAME, EACCELERATOR_EXTENSION_NAME, PHP_VERSION);
}
return ret;
}
/*
* Create a hash directory
*/
static void make_hash_dirs(char *fullpath, int lvl)
{
int j;
int n = strlen(fullpath);
//ea_debug_error("Creating hash in %s at level %d\n", fullpath, lvl);
if (lvl < 1) {
return;
}
if (fullpath[n-1] != '/') {
fullpath[n++] = '/';
}
for (j = 0; j < 16; j++) {
fullpath[n] = num2hex[j];
fullpath[n+1] = 0;
mkdir(fullpath, 0700);
make_hash_dirs(fullpath, lvl-1);
}
fullpath[n+2] = 0;
}
/*
* Initialise the cache directory for use
*/
static void init_cache_dir(const char *cache_path)
{
char fullpath[MAXPATHLEN];
uid_t uid = getuid();
mode_t old_umask = umask(077);
struct stat buffer;
snprintf(fullpath, MAXPATHLEN-1, "%s/%d/", cache_path, uid);
if (lstat(fullpath, &buffer) != 0) {
// error, create the directory
if (mkdir(fullpath, 0700) != 0) {
ea_debug_error("Unable to create cachedir %s\n", fullpath);
return;
}
} else if (!S_ISDIR(buffer.st_mode)) {
// not a directory
ea_debug_error("Cachedir %s exists but is not a directory\n",
fullpath);
return;
}
// create the hashed dirs
make_hash_dirs(fullpath, EACCELERATOR_HASH_LEVEL);
umask(old_umask);
ea_mm_instance->cache_dir_uid = uid;
}
/*
* Check if the cache dir exists and is world-writable so the forked process
* can create the cache directories
*/
static void check_cache_dir(const char *cache_path)
{
struct stat buffer;
mode_t old_umask = umask(0);
int status = stat(cache_path, &buffer);
if (status == 0) {
// check permissions
if (buffer.st_mode != 777) {
status = chmod(cache_path, 0777);
if (status < 0) {
ea_debug_error(
"eAccelerator: Unable to change cache directory %s permissions\n",
cache_path);
}
}
} else {
// create the cache directory if possible
status = mkdir(cache_path, 0777);
if (status < 0) {
ea_debug_error("eAccelerator: Unable to create cache directory %s\n", cache_path);
}
}
umask(old_umask);
}
PHP_MINIT_FUNCTION(eaccelerator)
{
if (type == MODULE_PERSISTENT) {
#ifndef ZEND_WIN32
if (strcmp(sapi_module.name,"apache") == 0) {
if (getpid() != getpgrp()) {
return SUCCESS;
}
}
#endif
}
if (!eaccelerator_check_php_version(TSRMLS_C)) {
/*
* do not return FAILURE, because it causes PHP to completely fail.
* Just disable eAccelerator instead of making eA fail starting php
*/
return SUCCESS;
}
ZEND_INIT_MODULE_GLOBALS(eaccelerator, eaccelerator_init_globals, NULL);
REGISTER_INI_ENTRIES();
REGISTER_STRING_CONSTANT("EACCELERATOR_VERSION", EACCELERATOR_VERSION, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("EACCELERATOR_SHM_AND_DISK", ea_shm_and_disk, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("EACCELERATOR_SHM", ea_shm, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("EACCELERATOR_SHM_ONLY", ea_shm_only, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("EACCELERATOR_DISK_ONLY", ea_disk_only, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("EACCELERATOR_NONE", ea_none, CONST_CS | CONST_PERSISTENT);
encode_version(EACCELERATOR_VERSION, &binary_eaccelerator_version[0], &binary_eaccelerator_version[1]);
encode_version(PHP_VERSION, &binary_php_version[0], &binary_php_version[1]);
encode_version(ZEND_VERSION, &binary_zend_version[0], &binary_zend_version[1]);
ea_is_extension = 1;
ea_debug_init(TSRMLS_C);
#ifndef ZEND_WIN32
if (!ea_scripts_shm_only) {
check_cache_dir(EAG(cache_dir));
}
#endif
if (type == MODULE_PERSISTENT &&
strcmp(sapi_module.name, "cgi") != 0 &&
strcmp(sapi_module.name, "cli") != 0) {
DBG(ea_debug_put, (EA_DEBUG, "\n=======================================\n"));
DBG(ea_debug_printf, (EA_DEBUG, "[%d] EACCELERATOR STARTED\n", getpid()));
DBG(ea_debug_put, (EA_DEBUG, "=======================================\n"));
if (init_mm(TSRMLS_C) == FAILURE) {
zend_error(E_CORE_WARNING,"[%s] Can not create shared memory area", EACCELERATOR_EXTENSION_NAME);
return FAILURE;
}
ea_saved_zend_compile_file = zend_compile_file;
#ifdef DEBUG
zend_compile_file = profile_compile_file;
ea_saved_zend_execute = zend_execute;
zend_execute = profile_execute;
#else
zend_compile_file = eaccelerator_compile_file;
#endif
}
if (!ea_is_zend_extension) {
register_eaccelerator_as_zend_extension();
}
/* cache the properties_info destructor */
properties_info_dtor = get_zend_destroy_property_info(TSRMLS_C);
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(eaccelerator)
{
if (ea_mm_instance == NULL || !ea_is_extension) {
return SUCCESS;
}
zend_compile_file = ea_saved_zend_compile_file;
shutdown_mm(TSRMLS_C);
DBG(ea_debug_put, (EA_DEBUG, "========================================\n"));
DBG(ea_debug_printf, (EA_DEBUG, "[%d] EACCELERATOR STOPPED\n", getpid()));
DBG(ea_debug_put, (EA_DEBUG, "========================================\n\n"));
ea_debug_shutdown();
UNREGISTER_INI_ENTRIES();
#ifdef ZTS
ts_free_id(eaccelerator_globals_id);
#else
eaccelerator_globals_dtor(&eaccelerator_globals TSRMLS_CC);
#endif
ea_is_zend_extension = 0;
ea_is_extension = 0;
return SUCCESS;
}
PHP_RINIT_FUNCTION(eaccelerator)
{
if (ea_mm_instance == NULL) {
return SUCCESS;
}
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Enter RINIT\n",getpid()));
DBG(ea_debug_put, (EA_PROFILE_OPCODES, "\n========================================\n"));
EAG(in_request) = 1;
EAG(used_entries) = NULL;
EAG(compiler) = 0;
EAG(refcount_helper) = 1;
EAG(req_start) = sapi_get_request_time(TSRMLS_C); /* record request start time for later use */
zend_hash_init(&EAG(restored), 0, NULL, NULL, 0);
#ifdef DEBUG
EAG(xpad) = 0;
EAG(profile_level) = 0;
#endif
#ifdef WITH_EACCELERATOR_CRASH_DETECTION
#ifdef SIGSEGV
EAG(original_sigsegv_handler) = signal(SIGSEGV, eaccelerator_crash_handler);
#endif
#ifdef SIGFPE
EAG(original_sigfpe_handler) = signal(SIGFPE, eaccelerator_crash_handler);
#endif
#ifdef SIGBUS
EAG(original_sigbus_handler) = signal(SIGBUS, eaccelerator_crash_handler);
#endif
#ifdef SIGILL
EAG(original_sigill_handler) = signal(SIGILL, eaccelerator_crash_handler);
#endif
#ifdef SIGABRT
EAG(original_sigabrt_handler) = signal(SIGABRT, eaccelerator_crash_handler);
#endif
#endif
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Leave RINIT\n",getpid()));
#ifndef ZEND_WIN32
if (!ea_scripts_shm_only && ea_mm_instance->cache_dir_uid != getuid()) {
// lock this operation with a global eA lock and do the check again
// to avoid multiple calls during startup
EACCELERATOR_LOCK_RW();
if (ea_mm_instance->cache_dir_uid != getuid()) {
init_cache_dir(EAG(cache_dir));
}
EACCELERATOR_UNLOCK();
}
#else
if(!ea_scripts_shm_only) {
char fullpath[MAXPATHLEN];
snprintf(fullpath, MAXPATHLEN-1, "%s/", EAG(cache_dir));
make_hash_dirs(fullpath, EACCELERATOR_HASH_LEVEL);
}
#endif
return SUCCESS;
}
PHP_RSHUTDOWN_FUNCTION(eaccelerator)
{
if (ea_mm_instance == NULL) {
return SUCCESS;
}
zend_hash_destroy(&EAG(restored));
#ifdef WITH_EACCELERATOR_CRASH_DETECTION
#ifdef SIGSEGV
if (EAG(original_sigsegv_handler) != eaccelerator_crash_handler) {
signal(SIGSEGV, EAG(original_sigsegv_handler));
} else {
signal(SIGSEGV, SIG_DFL);
}
#endif
#ifdef SIGFPE
if (EAG(original_sigfpe_handler) != eaccelerator_crash_handler) {
signal(SIGFPE, EAG(original_sigfpe_handler));
} else {
signal(SIGFPE, SIG_DFL);
}
#endif
#ifdef SIGBUS
if (EAG(original_sigbus_handler) != eaccelerator_crash_handler) {
signal(SIGBUS, EAG(original_sigbus_handler));
} else {
signal(SIGBUS, SIG_DFL);
}
#endif
#ifdef SIGILL
if (EAG(original_sigill_handler) != eaccelerator_crash_handler) {
signal(SIGILL, EAG(original_sigill_handler));
} else {
signal(SIGILL, SIG_DFL);
}
#endif
#ifdef SIGABRT
if (EAG(original_sigabrt_handler) != eaccelerator_crash_handler) {
signal(SIGABRT, EAG(original_sigabrt_handler));
} else {
signal(SIGABRT, SIG_DFL);
}
#endif
#endif
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Enter RSHUTDOWN\n",getpid()));
eaccelerator_clean_request(TSRMLS_C);
DBG(ea_debug_printf, (EA_DEBUG, "[%d] Leave RSHUTDOWN\n",getpid()));
return SUCCESS;
}
ZEND_BEGIN_ARG_INFO(eaccelerator_second_arg_force_ref, 0)
ZEND_ARG_PASS_INFO(0)
ZEND_ARG_PASS_INFO(1)
ZEND_END_ARG_INFO();
zend_function_entry eaccelerator_functions[] = {
#ifdef WITH_EACCELERATOR_INFO
PHP_FE(eaccelerator_caching, NULL)
PHP_FE(eaccelerator_clear, NULL)
PHP_FE(eaccelerator_clean, NULL)
PHP_FE(eaccelerator_info, NULL)
PHP_FE(eaccelerator_purge, NULL)
PHP_FE(eaccelerator_cached_scripts, NULL)
PHP_FE(eaccelerator_removed_scripts, NULL)
PHP_FE(eaccelerator_check_mtime, NULL)
#ifdef WITH_EACCELERATOR_OPTIMIZER
PHP_FE(eaccelerator_optimizer, NULL)
#endif
#endif
#ifdef WITH_EACCELERATOR_DISASSEMBLER
PHP_FE(eaccelerator_dasm_file, NULL)
#endif
{
NULL, NULL, NULL, 0U, 0U
}
};
zend_module_entry eaccelerator_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
EACCELERATOR_EXTENSION_NAME,
eaccelerator_functions,
PHP_MINIT(eaccelerator),
PHP_MSHUTDOWN(eaccelerator),
PHP_RINIT(eaccelerator),
PHP_RSHUTDOWN(eaccelerator),
PHP_MINFO(eaccelerator),
#if ZEND_MODULE_API_NO >= 20010901
EACCELERATOR_VERSION, /* extension version number (string) */
#endif
STANDARD_MODULE_PROPERTIES
};
#if defined(COMPILE_DL_EACCELERATOR)
ZEND_GET_MODULE(eaccelerator)
#endif
static startup_func_t last_startup;
static zend_llist_element *eaccelerator_el;
static const unsigned char eaccelerator_logo[] = {
71, 73, 70, 56, 57, 97, 88, 0, 31, 0,
213, 0, 0, 150, 153, 196, 237, 168, 86, 187,
206, 230, 4, 4, 4, 108, 110, 144, 99, 144,
199, 136, 138, 184, 87, 88, 109, 165, 165, 167,
163, 166, 202, 240, 151, 44, 149, 91, 21, 225,
225, 229, 4, 76, 164, 252, 215, 171, 255, 255,
255, 212, 212, 224, 241, 200, 149, 141, 144, 192,
216, 216, 226, 251, 230, 205, 192, 193, 218, 207,
221, 238, 181, 188, 216, 130, 132, 168, 150, 152,
185, 152, 152, 154, 180, 181, 198, 215, 184, 147,
40, 102, 177, 224, 232, 242, 244, 244, 244, 235,
236, 239, 118, 121, 157, 193, 193, 194, 146, 148,
174, 181, 143, 96, 154, 183, 219, 156, 159, 200,
126, 128, 170, 174, 175, 193, 65, 39, 7, 232,
214, 192, 254, 241, 226, 246, 246, 248, 108, 65,
13, 142, 144, 185, 252, 224, 189, 138, 171, 213,
69, 122, 188, 239, 244, 249, 48, 49, 60, 176,
178, 209, 200, 201, 222, 252, 252, 253, 251, 251,
251, 162, 163, 187, 208, 208, 213, 169, 171, 205,
241, 234, 225, 255, 252, 249, 254, 248, 241, 140,
142, 169, 249, 186, 111, 33, 249, 4, 0, 0,
0, 0, 0, 44, 0, 0, 0, 0, 88, 0,
31, 0, 0, 6, 255, 64, 137, 112, 72, 44,
26, 143, 200, 164, 114, 201, 92, 62, 158, 208,
168, 116, 74, 173, 90, 175, 216, 108, 85, 168,
237, 122, 191, 15, 25, 163, 118, 209, 153, 0,
68, 128, 73, 119, 169, 49, 100, 86, 46, 120,
78, 127, 216, 60, 21, 93, 83, 8, 208, 85,
60, 54, 83, 114, 117, 132, 89, 32, 23, 38,
73, 38, 103, 72, 38, 23, 32, 82, 123, 146,
147, 69, 106, 9, 52, 21, 19, 53, 137, 138,
51, 51, 156, 141, 21, 100, 52, 9, 148, 166,
123, 0, 106, 126, 16, 21, 104, 67, 169, 106,
140, 9, 3, 159, 140, 18, 176, 182, 0, 23,
21, 101, 67, 21, 80, 32, 52, 192, 52, 44,
6, 16, 15, 6, 23, 44, 81, 24, 81, 25,
81, 194, 80, 25, 6, 18, 12, 80, 23, 15,
169, 15, 172, 155, 105, 33, 7, 4, 158, 46,
0, 33, 3, 7, 7, 51, 7, 139, 231, 225,
7, 25, 124, 23, 23, 52, 190, 19, 4, 205,
44, 27, 4, 4, 19, 57, 15, 33, 15, 32,
54, 64, 168, 241, 0, 5, 10, 28, 255, 54,
160, 120, 128, 163, 160, 65, 2, 15, 244, 229,
200, 113, 162, 26, 4, 20, 252, 22, 130, 128,
48, 98, 131, 30, 34, 38, 102, 208, 58, 64,
203, 4, 73, 115, 3, 6, 184, 152, 69, 75,
228, 1, 87, 38, 80, 204, 19, 242, 235, 9,
54, 31, 4, 78, 212, 152, 192, 128, 1, 8,
255, 31, 79, 78, 108, 99, 245, 239, 24, 3,
136, 16, 32, 212, 139, 24, 34, 83, 8, 3,
62, 33, 128, 56, 90, 3, 68, 136, 17, 173,
138, 176, 76, 16, 114, 64, 2, 145, 4, 0,
136, 196, 128, 129, 22, 215, 146, 66, 50, 224,
248, 40, 33, 147, 62, 2, 11, 39, 120, 120,
48, 162, 33, 10, 2, 44, 62, 64, 156, 144,
244, 31, 129, 17, 12, 31, 240, 157, 240, 76,
238, 131, 12, 4, 160, 110, 4, 1, 130, 192,
6, 6, 33, 112, 212, 48, 226, 195, 220, 25,
145, 95, 189, 118, 77, 64, 50, 236, 172, 79,
66, 92, 140, 96, 11, 0, 71, 78, 12, 39,
12, 108, 200, 71, 32, 68, 190, 16, 38, 70,
56, 54, 120, 87, 71, 136, 16, 25, 70, 36,
160, 141, 65, 33, 10, 12, 57, 13, 36, 240,
173, 15, 64, 2, 31, 58, 186, 189, 34, 96,
238, 86, 73, 90, 198, 75, 146, 12, 1, 128,
249, 203, 208, 62, 74, 9, 49, 96, 0, 3,
53, 9, 6, 78, 220, 78, 141, 218, 251, 137,
19, 168, 199, 163, 230, 46, 254, 246, 120, 247,
169, 193, 183, 127, 234, 34, 67, 6, 63, 51,
249, 156, 12, 55, 160, 181, 57, 114, 255, 137,
52, 3, 127, 62, 12, 129, 65, 118, 74, 112,
247, 29, 120, 219, 81, 163, 224, 130, 224, 61,
40, 225, 130, 15, 222, 162, 74, 60, 160, 116,
181, 95, 6, 36, 189, 212, 255, 225, 103, 39,
97, 224, 74, 119, 186, 157, 98, 162, 18, 169,
172, 65, 3, 13, 40, 184, 178, 149, 14, 9,
160, 97, 2, 87, 18, 204, 104, 66, 89, 51,
24, 23, 163, 16, 62, 132, 224, 195, 90, 39,
6, 121, 132, 37, 58, 176, 136, 195, 59, 46,
152, 133, 98, 135, 174, 8, 129, 129, 143, 56,
36, 160, 93, 33, 84, 82, 97, 3, 11, 12,
136, 128, 3, 66, 227, 44, 49, 2, 110, 67,
248, 224, 131, 6, 34, 48, 176, 204, 3, 131,
84, 169, 230, 19, 44, 128, 144, 195, 6, 71,
190, 179, 4, 26, 46, 136, 169, 1, 10, 57,
236, 192, 2, 15, 79, 164, 185, 166, 154, 55,
124, 192, 192, 155, 8, 228, 54, 130, 11, 136,
134, 86, 167, 152, 99, 34, 176, 65, 14, 12,
124, 16, 8, 20, 126, 62, 176, 2, 5, 20,
188, 160, 233, 166, 155, 58, 224, 105, 4, 61,
252, 73, 69, 160, 59, 12, 42, 2, 10, 8,
32, 160, 193, 170, 171, 166, 138, 130, 8, 144,
238, 240, 1, 159, 145, 72, 0, 5, 15, 20,
56, 16, 65, 4, 63, 4, 224, 171, 2, 1,
0, 171, 192, 176, 195, 6, 32, 234, 21, 129,
126, 48, 85, 79, 204, 50, 43, 235, 7, 55,
196, 97, 171, 165, 159, 254, 240, 195, 176, 63,
188, 240, 0, 173, 80, 244, 192, 194, 153, 2,
192, 113, 236, 184, 114, 172, 96, 174, 185, 152,
82, 160, 255, 133, 7, 13, 20, 240, 132, 12,
5, 196, 80, 192, 92, 15, 192, 32, 175, 0,
15, 88, 16, 195, 190, 22, 148, 224, 238, 19,
250, 242, 27, 176, 188, 226, 198, 128, 205, 190,
252, 202, 96, 111, 1, 248, 62, 128, 112, 1,
22, 80, 106, 235, 11, 14, 80, 188, 107, 175,
190, 250, 106, 45, 198, 1, 144, 192, 193, 19,
5, 52, 208, 64, 24, 29, 116, 96, 111, 3,
240, 54, 0, 67, 200, 2, 8, 160, 50, 12,
30, 216, 11, 133, 203, 48, 192, 76, 51, 12,
237, 62, 112, 65, 187, 54, 216, 107, 178, 7,
49, 168, 28, 52, 190, 237, 194, 80, 178, 196,
43, 108, 28, 172, 2, 11, 120, 204, 193, 211,
17, 112, 176, 235, 211, 28, 236, 240, 68, 7,
33, 151, 128, 179, 184, 45, 55, 32, 64, 180,
22, 120, 224, 114, 203, 10, 199, 48, 179, 215,
225, 186, 12, 178, 217, 33, 163, 92, 175, 217,
22, 120, 125, 131, 13, 242, 62, 224, 117, 189,
35, 247, 41, 129, 3, 196, 50, 189, 64, 11,
36, 216, 48, 183, 29, 79, 4, 98, 195, 164,
46, 119, 80, 180, 217, 103, 75, 225, 178, 200,
2, 200, 252, 196, 227, 104, 139, 44, 242, 5,
50, 52, 160, 56, 12, 111, 63, 160, 246, 19,
246, 218, 96, 121, 206, 122, 191, 224, 247, 223,
45, 164, 238, 244, 174, 172, 63, 173, 238, 3,
5, 152, 28, 50, 206, 17, 43, 76, 154, 51,
232, 93, 67, 33, 185, 231, 121, 243, 46, 64,
12, 29, 60, 80, 130, 208, 193, 203, 204, 46,
231, 50, 96, 109, 119, 205, 13, 208, 139, 166,
173, 42, 144, 176, 64, 10, 212, 87, 159, 250,
2, 216, 103, 191, 192, 14, 129, 168, 252, 132,
202, 33, 7, 93, 188, 230, 138, 139, 221, 0,
191, 56, 239, 203, 240, 249, 49, 88, 160, 118,
220, 43, 155, 189, 115, 204, 140, 227, 172, 120,
243, 118, 135, 139, 245, 164, 149, 78, 74, 248,
220, 130, 187, 193, 224, 30, 16, 51, 113, 149,
160, 4, 54, 208, 90, 9, 102, 86, 51, 56,
196, 172, 102, 98, 171, 25, 12, 74, 240, 64,
152, 197, 204, 38, 53, 139, 88, 189, 90, 182,
192, 201, 213, 236, 76, 48, 179, 129, 5, 96,
166, 183, 113, 153, 80, 77, 66, 74, 161, 10,
41, 17, 4, 0, 59, 0
};
static int eaccelerator_last_startup(zend_extension *extension)
{
int ret;
extension->startup = last_startup;
ret = extension->startup(extension);
zend_extensions.count++;
eaccelerator_el->next = zend_extensions.head;
eaccelerator_el->prev = NULL;
zend_extensions.head->prev = eaccelerator_el;
zend_extensions.head = eaccelerator_el;
if (ZendOptimizer) {
if ((ZendOptimizer = zend_get_extension("Zend Optimizer")) != NULL) {
ZendOptimizer->op_array_handler = NULL;
}
}
return ret;
}
/*
static int eaccelerator_ioncube_startup(zend_extension *extension) {
int ret;
zend_extension* last_ext = (zend_extension*)zend_extensions.tail->data;
extension->startup = last_startup;
ret = extension->startup(extension);
last_startup = last_ext->startup;
last_ext->startup = eaccelerator_last_startup;
return ret;
}
*/
ZEND_DLEXPORT int eaccelerator_zend_startup(zend_extension *extension)
{
ea_is_zend_extension = 1;
eaccelerator_el = NULL;
last_startup = NULL;
if (!ea_is_extension) {
if (zend_startup_module(&eaccelerator_module_entry) != SUCCESS) {
return FAILURE;
}
}
if (zend_llist_count(&zend_extensions) > 1) {
zend_llist_element *p = zend_extensions.head;
while (p != NULL) {
zend_extension* ext = (zend_extension*)(p->data);
if (strcmp(ext->name, EACCELERATOR_EXTENSION_NAME) == 0) {
/* temporary removing eAccelerator extension */
zend_extension* last_ext = (zend_extension*)zend_extensions.tail->data;
if (eaccelerator_el != NULL) {
zend_error(E_CORE_ERROR,"[%s] %s %s can not be loaded twice",
EACCELERATOR_EXTENSION_NAME,
EACCELERATOR_EXTENSION_NAME,
EACCELERATOR_VERSION);
exit(1);
}
if (last_ext != ext) {
eaccelerator_el = p;
last_startup = last_ext->startup;
last_ext->startup = eaccelerator_last_startup;
zend_extensions.count--;
if (p->prev != NULL) {
p->prev->next = p->next;
} else {
zend_extensions.head = p->next;
}
if (p->next != NULL) {
p->next->prev = p->prev;
} else {
zend_extensions.tail = p->prev;
}
}
} else if (strcmp(ext->name, "Zend Extension Manager") == 0 ||
strcmp(ext->name, "Zend Optimizer") == 0) {
/* Disable ZendOptimizer Optimizations */
ZendOptimizer = ext;
ext->op_array_handler = NULL;
}
p = p->next;
}
}
php_register_info_logo(EACCELERATOR_VERSION_GUID, "text/plain", (unsigned char*)EACCELERATOR_VERSION_STRING, sizeof(EACCELERATOR_VERSION_STRING));
php_register_info_logo(EACCELERATOR_LOGO_GUID, "image/gif", (unsigned char*)eaccelerator_logo, sizeof(eaccelerator_logo));
return SUCCESS;
}
#ifndef ZEND_EXT_API
# define ZEND_EXT_API ZEND_DLEXPORT
#endif
ZEND_EXTENSION();
ZEND_DLEXPORT zend_extension zend_extension_entry = {
EACCELERATOR_EXTENSION_NAME,
EACCELERATOR_VERSION,
"eAccelerator",
"http://eaccelerator.net",
"Copyright (c) 2004-2012 eAccelerator",
eaccelerator_zend_startup,
NULL,
NULL, /* void (*activate)() */
NULL, /* void (*deactivate)() */
NULL, /* void (*message_handle)(int message, void *arg) */
#ifdef WITH_EACCELERATOR_OPTIMIZER
eaccelerator_optimize, /* void (*op_array_handler)(zend_op_array *o_a); */
#else
NULL, /* void (*op_array_handler)(zend_op_array *o_a); */
#endif
NULL, /* void (*statement_handler)(zend_op_array *o_a); */
NULL, /* void (*fcall_begin_handler)(zend_op_array *o_a); */
NULL, /* void (*fcall_end_handler)(zend_op_array *o_a); */
NULL, /* void (*op_array_ctor)(zend_op_array *o_a); */
NULL, /* void (*op_array_dtor)(zend_op_array *o_a); */
#ifdef COMPAT_ZEND_EXTENSION_PROPERTIES
NULL, /* api_no_check */
COMPAT_ZEND_EXTENSION_PROPERTIES
#else
STANDARD_ZEND_EXTENSION_PROPERTIES
#endif
};
static zend_extension eaccelerator_extension_entry = {
EACCELERATOR_EXTENSION_NAME,
EACCELERATOR_VERSION,
"eAccelerator",
"http://eaccelerator.net",
"Copyright (c) 2004-2012 eAccelerator",
eaccelerator_zend_startup,
NULL,
NULL, /* void (*activate)() */
NULL, /* void (*deactivate)() */
NULL, /* void (*message_handle)(int message, void *arg) */
#ifdef WITH_EACCELERATOR_OPTIMIZER
eaccelerator_optimize, /* void (*op_array_handler)(zend_op_array *o_a); */
#else
NULL, /* void (*op_array_handler)(zend_op_array *o_a); */
#endif
NULL, /* void (*statement_handler)(zend_op_array *o_a); */
NULL, /* void (*fcall_begin_handler)(zend_op_array *o_a); */
NULL, /* void (*fcall_end_handler)(zend_op_array *o_a); */
NULL, /* void (*op_array_ctor)(zend_op_array *o_a); */
NULL, /* void (*op_array_dtor)(zend_op_array *o_a); */
#ifdef COMPAT_ZEND_EXTENSION_PROPERTIES
NULL, /* api_no_check */
COMPAT_ZEND_EXTENSION_PROPERTIES
#else
STANDARD_ZEND_EXTENSION_PROPERTIES
#endif
};
static void register_eaccelerator_as_zend_extension()
{
zend_extension extension = eaccelerator_extension_entry;
extension.handle = 0;
zend_llist_prepend_element(&zend_extensions, &extension);
}
/******************************************************************************/
#endif /* #ifdef HAVE_EACCELERATOR */
/*
* 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
*/
|