Ticket #287: xcache-itk_vhost.patch

File xcache-itk_vhost.patch, 6.0 KB (added by mzhg, 3 years ago)

version 4, added missing xcache_unset_by_prefix

  • xcache-trunk/xcache.c

     
    1414
    1515#include <signal.h>
    1616
     17#include <pwd.h>
     18
    1719#include "php.h"
    1820#include "ext/standard/info.h"
    1921#include "ext/standard/md5.h"
     
    118120
    119121/* any function in *_unlocked is only safe be called within locked (single thread access) area */
    120122
     123static zval* hg_internal_compute_prefix()
     124{
     125        zval* zprefix = NULL;
     126        int userid = 33; // default id for www-data on Ubuntu
     127    // we base the prefix on the user id because we use mpm-itk which run each virtual host under a specific user
     128    // the prefix could be set via the INI settings
     129        userid = getuid();
     130        MAKE_STD_ZVAL(zprefix);
     131        Z_TYPE_P(zprefix) = IS_LONG;
     132        Z_LVAL_P(zprefix) = userid;
     133        convert_to_string(zprefix);
     134        return zprefix;
     135}
     136
     137static int hg_internal_startwith_prefix(zval** name)
     138{
     139    char* from = NULL;
     140    char* prefix = NULL;
     141
     142    zval* zprefix = hg_internal_compute_prefix();
     143        prefix = Z_STRVAL_P(zprefix);
     144    from = Z_STRVAL_PP(name);
     145
     146//  php_printf("from= %s<br />", from);
     147//  php_printf("prefix= %s<br />", prefix);
     148
     149    if (strncmp(from, prefix, strlen(prefix)) == 0)
     150    {
     151//      php_printf("MATCH<br />");
     152        return 1;
     153    } else {
     154        return 0;
     155    }   
     156}
     157
     158static void hg_internal_remove_prefix(zval** name)
     159{
     160    char* from = NULL;
     161    char* to = NULL;
     162    char* prefix = NULL;
     163    int index = 0;
     164
     165    zval* zprefix = hg_internal_compute_prefix();
     166    prefix = Z_STRVAL_P(zprefix);
     167
     168    from = Z_STRVAL_PP(name);
     169    index = strlen(prefix) + 1;
     170
     171    to = emalloc(strlen(from) - index  + 2);
     172    strncpy(to, from + index, strlen(from) - index + 1);
     173
     174    ZVAL_STRING(*name, to, 1);
     175}
     176
     177static void hg_internal_prefix_entry_name(zval** name)
     178{
     179    char *string = NULL;
     180    char *final = NULL;
     181    char *prefix = NULL;
     182
     183    zval* zprefix = hg_internal_compute_prefix(); // get prefix, should be cache in some way
     184    prefix = Z_STRVAL_P(zprefix);
     185
     186    convert_to_string(*name);
     187
     188//  php_printf("<br />zname original= ");
     189//  PHPWRITE(Z_STRVAL_PP(name), Z_STRLEN_PP(name));
     190
     191    string = Z_STRVAL_PP(name);
     192
     193//  php_printf("<br />zprefix= ");
     194//  PHPWRITE(Z_STRVAL_P(zprefix), Z_STRLEN_P(zprefix));
     195
     196    final = emalloc(strlen(prefix) + strlen(string) + 2);
     197    snprintf(final, (strlen(prefix) + strlen(string) + 2), "%s_%s", prefix, string);
     198//  php_printf("<br />final= %s", final);
     199
     200    ZVAL_STRING(*name, final, 1);
     201
     202//  php_printf("<br />zname= ");
     203//  PHPWRITE(Z_STRVAL_PP(name), Z_STRLEN_PP(name));
     204//  php_printf("<br />");
     205}
     206
    121207static void xc_php_add_unlocked(xc_cache_t *cache, xc_entry_data_php_t *php) /* {{{ */
    122208{
    123209    xc_entry_data_php_t **head = &(cache->phps[php->hvalue]);
     
    663749    if (del) {
    664750        add_assoc_long_ex(ei, ZEND_STRS("dtime"), entry->dtime);
    665751    }
     752    zval *zv;
     753    ALLOC_INIT_ZVAL(zv);
    666754#ifdef IS_UNICODE
    667755    do {
    668         zval *zv;
    669         ALLOC_INIT_ZVAL(zv);
     756//      zval *zv;
     757//      ALLOC_INIT_ZVAL(zv);
    670758        switch (entry->name_type) {
    671759            case IS_UNICODE:
    672760                    ZVAL_UNICODEL(zv, entry->name.ustr.val, entry->name.ustr.len, 1);
     
    678766                assert(0);
    679767        }
    680768        zv->type = entry->name_type;
    681         add_assoc_zval_ex(ei, ZEND_STRS("name"), zv);
     769//      hg_internal_remove_prefix(&zv);
     770//      add_assoc_zval_ex(ei, ZEND_STRS("name"), zv);
    682771    } while (0);
    683772#else
    684     add_assoc_stringl_ex(ei, ZEND_STRS("name"), entry->name.str.val, entry->name.str.len, 1);
     773    do {
     774//  zval *zv;
     775//  ALLOC_INIT_ZVAL(zv);
     776    ZVAL_STRINGL(zv, entry->name.str.val, entry->name.str.len, 1);
     777//  hg_internal_remove_prefix(&zv);
     778//  add_assoc_stringl_ex(ei, ZEND_STRS("name"), entry->name.str.val, entry->name.str.len, 1);
     779//  add_assoc_zval_ex(ei, ZEND_STRS("name"), zv);
     780    } while (0);
    685781#endif
     782    int comp = hg_internal_startwith_prefix(&zv);
     783    if (comp == 0) return;
     784
     785    hg_internal_remove_prefix(&zv);
     786    add_assoc_zval_ex(ei, ZEND_STRS("name"), zv);
     787
    686788    switch (type) {
    687789        case XC_TYPE_PHP:
    688790            php = entry_php->php;
     
    23882490            CHECK(xc_var_caches = xc_cache_init(shm, &xc_var_hcache, &xc_var_hentry, NULL, xc_var_size), "failed init variable cache");
    23892491        }
    23902492    }
     2493
    23912494    return SUCCESS;
    23922495
    23932496err:
     
    27982901    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
    27992902        return;
    28002903    }
     2904
     2905    hg_internal_prefix_entry_name(&name);
     2906
    28012907    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
    28022908    cache = xc_var_caches[entry_hash.cacheid];
    28032909
     
    28352941        return;
    28362942    }
    28372943
     2944    hg_internal_prefix_entry_name(&name);
     2945
    28382946    /* max ttl */
    28392947    if (xc_var_maxttl && (!entry_var.entry.ttl || entry_var.entry.ttl > xc_var_maxttl)) {
    28402948        entry_var.entry.ttl = xc_var_maxttl;
     
    28702978    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
    28712979        return;
    28722980    }
     2981
     2982    hg_internal_prefix_entry_name(&name);
     2983
    28732984    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
    28742985    cache = xc_var_caches[entry_hash.cacheid];
    28752986
     
    29043015    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
    29053016        return;
    29063017    }
     3018
     3019    hg_internal_prefix_entry_name(&name);
     3020
    29073021    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
    29083022    cache = xc_var_caches[entry_hash.cacheid];
    29093023
     
    29353049        return;
    29363050    }
    29373051
     3052    hg_internal_prefix_entry_name(&prefix);
     3053
    29383054    for (i = 0, iend = xc_var_hcache.size; i < iend; i ++) {
    29393055        xc_cache_t *cache = xc_var_caches[i];
    29403056        ENTER_LOCK(cache) {
     
    29723088        return;
    29733089    }
    29743090
     3091    hg_internal_prefix_entry_name(&name);
     3092
    29753093    /* max ttl */
    29763094    if (xc_var_maxttl && (!entry_var.entry.ttl || entry_var.entry.ttl > xc_var_maxttl)) {
    29773095        entry_var.entry.ttl = xc_var_maxttl;
  • xcache-trunk/xcache.h

     
    11#ifndef __XCACHE_H
    22#define __XCACHE_H
    33#define XCACHE_NAME       "XCache"
    4 #define XCACHE_VERSION    "2.0.0"
     4#define XCACHE_VERSION    "2.0.0+itk_vhost"
    55#define XCACHE_AUTHOR     "mOo"
    66#define XCACHE_COPYRIGHT  "Copyright (c) 2005-2012"
    77#define XCACHE_URL        "http://xcache.lighttpd.net"