Changeset 1146 in svn


Ignore:
Timestamp:
2012-08-23T08:27:54Z (3 years ago)
Author:
Xuefer
Message:

closes #287: namespace support

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/ChangeLog

    r1140 r1146  
    44 * chg: proto array xcache_clear_cache(int type, [ int id = -1 ]). -1 means all cache splits
    55 * new: proto array xcache_enable_cache(int type, [ int id = -1, [ bool enable = true ] ])
     6 * new: proto array xcache_admin_namespace()
     7 * new: proto array xcache_set_namespace(string namespace)
    68
    79Ini Settings Changes
     
    1820 * closes #174: updates api to support "clear all cache"
    1921 * closes #198: support for caching protocol url
     22 * closes #287: namespace support
    2023 * fixes #39: ini_set never work for xcache.coverager setting. use API instead
    2124 * code refactor
  • trunk/NEWS

    r1139 r1146  
    66 * uses extension= to load XCache. loading via zend_extension= is unsupported
    77 * updates XCache admin page
     8 * namespace support
    89 * professional helpers
    910   * adds an diagnosis module to give advise @ htdocs
  • trunk/htdocs/cacher/edit.php

    r1144 r1146  
    77}
    88
    9 $name = $_GET['name'];
    109// trigger auth
    1110$vcnt = xcache_count(XC_TYPE_VAR);
     11xcache_admin_namespace();
     12
     13$name = $_GET['name'];
     14if (!empty($config['enable_eval'])) {
     15    eval('$name = ' . $name . ';');
     16}
    1217
    1318if ($_SERVER['REQUEST_METHOD'] == 'POST') {
  • trunk/htdocs/cacher/edit.tpl.php

    r1086 r1146  
    11<?php include "../common/header.tpl.php"; ?>
    22<?php
    3 $h_name = htmlspecialchars($name);
     3$h_name = htmlspecialchars(var_export($name, true));
    44$h_value = htmlspecialchars($value);
    55?>
  • trunk/htdocs/cacher/index.php

    r1145 r1146  
    258258
    259259xcache_count(XC_TYPE_PHP); // trigger auth
     260xcache_admin_namespace();
    260261
    261262$doTypes = array(
  • trunk/htdocs/cacher/sub/entrylist.tpl.php

    r1143 r1146  
    6161
    6262TR;
    63     $name     = htmlspecialchars($entry['name']);
    6463    $hits     = number_format($entry['hits']);
    6564    $size     = size($entry['size']);
     
    8180
    8281    if ($isphp) {
    83         $namelink = $name;
     82        $hname = htmlspecialchars($entry['name']);
     83        $namelink = $hname;
    8484        echo <<<ENTRY
    8585            <td>{$entry['cache_name']} {$i}</td>
     
    8888    }
    8989    else {
     90        $name = $entry['name'];
     91        if (!empty($config['enable_eval'])) {
     92            $name = var_export($name, true);
     93        }
     94        $uname = urlencode($name);
     95        $hname = htmlspecialchars(str_replace("\0", "\\0", $entry['name']));
    9096        echo <<<ENTRY
    91             <td><label><input type="checkbox" name="remove[]" value="{$name}"/>{$entry['cache_name']} {$i}</label></td>
     97            <td><label><input type="checkbox" name="remove[]" value="{$hname}"/>{$entry['cache_name']} {$i}</label></td>
    9298
    9399ENTRY;
    94         $uname = urlencode($entry['name']);
    95         $namelink = "<a href=\"edit.php?name=$uname\">$name</a>";
     100        $namelink = "<a href=\"edit.php?name=$uname\">$hname</a>";
    96101    }
    97102
  • trunk/mod_cacher/xc_cacher.c

    r1140 r1146  
    144144
    145145static zend_bool xc_readonly_protection = 0;
     146
     147static zend_ulong xc_var_namespace_mode = 0;
     148static char *xc_var_namespace = NULL;
     149
    146150
    147151zend_bool xc_have_op_array_ctor = 0;
     
    257261            if (entry1->name_type == IS_UNICODE) {
    258262                return entry1->name.ustr.len == entry2->name.ustr.len
    259                     && memcmp(entry1->name.ustr.val, entry2->name.ustr.val, (entry1->name.ustr.len + 1) * sizeof(UChar)) == 0;
     263                    && memcmp(entry1->name.ustr.val, entry2->name.ustr.val, (entry1->name.ustr.len + 1) * sizeof(entry1->name.ustr.val[0])) == 0;
    260264            }
    261265#endif
     
    268272    }
    269273    return 0;
    270 }
    271 /* }}} */
    272 static inline int xc_entry_has_prefix_unlocked(xc_entry_type_t type, xc_entry_t *entry, zval *prefix) /* {{{ */
    273 {
    274     /* this function isn't required but can be in unlocked */
    275 
    276 #ifdef IS_UNICODE
    277     if (entry->name_type != prefix->type) {
    278         return 0;
    279     }
    280 
    281     if (entry->name_type == IS_UNICODE) {
    282         if (entry->name.ustr.len < Z_USTRLEN_P(prefix)) {
    283             return 0;
    284         }
    285         return memcmp(entry->name.ustr.val, Z_USTRVAL_P(prefix), Z_USTRLEN_P(prefix) * sizeof(UChar)) == 0;
    286     }
    287 #endif
    288     if (prefix->type != IS_STRING) {
    289         return 0;
    290     }
    291 
    292     if (entry->name.str.len < Z_STRLEN_P(prefix)) {
    293         return 0;
    294     }
    295 
    296     return memcmp(entry->name.str.val, Z_STRVAL_P(prefix), Z_STRLEN_P(prefix)) == 0;
    297274}
    298275/* }}} */
     
    23072284/* }}} */
    23082285
     2286/* variable namespace */
     2287#ifdef IS_UNICODE
     2288void xc_var_namespace_init_from_unicodel(const UChar *string, int len TSRMLS_DC) /* {{{ */
     2289{
     2290    if (!len) {
     2291#ifdef IS_UNICODE
     2292        ZVAL_EMPTY_UNICODE(&XG(uvar_namespace_hard));
     2293#endif
     2294        ZVAL_EMPTY_STRING(&XG(var_namespace_hard));
     2295    }
     2296    else {
     2297        ZVAL_UNICODE_L(&XG(uvar_namespace_hard), string, len, 1);
     2298        /* TODO: copy to var */
     2299    }
     2300}
     2301/* }}} */
     2302#endif
     2303void xc_var_namespace_init_from_stringl(const char *string, int len TSRMLS_DC) /* {{{ */
     2304{
     2305    if (!len) {
     2306#ifdef IS_UNICODE
     2307        ZVAL_EMPTY_UNICODE(&XG(uvar_namespace_hard));
     2308#endif
     2309        ZVAL_EMPTY_STRING(&XG(var_namespace_hard));
     2310    }
     2311    else {
     2312        ZVAL_STRINGL(&XG(var_namespace_hard), string, len, 1);
     2313#ifdef IS_UNICODE
     2314        /* TODO: copy to uvar */
     2315#endif
     2316    }
     2317}
     2318/* }}} */
     2319void xc_var_namespace_init_from_long(long value TSRMLS_DC) /* {{{ */
     2320{
     2321    ZVAL_LONG(&XG(var_namespace_hard), value);
     2322#ifdef IS_UNICODE
     2323    /* TODO: copy to uvar_namespace */
     2324#endif
     2325}
     2326/* }}} */
     2327#ifdef IS_UNICODE
     2328void xc_var_namespace_set_unicodel(const UChar *unicode, int len TSRMLS_DC) /* {{{ */
     2329{
     2330    zval_dtor(&XG(uvar_namespace_soft));
     2331    zval_dtor(&XG(var_namespace_soft));
     2332    if (len) {
     2333        if (!Z_USTRLEN_P(&XG(uvar_namespace_soft))) {
     2334            ZVAL_UNICODEL(&XG(uvar_namespace_soft), unicode, len, 1);
     2335        }
     2336        else {
     2337            int buffer_len = Z_USTRLEN_P(&XG(var_namespace_hard)) + 1 + len;
     2338            char *buffer = emalloc((buffer_len + 1) * sizeof(unicode[0]));
     2339            char *p = buffer;
     2340            memcpy(p, Z_USTRVAL_P(&XG(var_namespace_hard)), (Z_USTRLEN_P(&XG(var_namespace_hard)) + 1));
     2341            p += (Z_USTRLEN_P(&XG(var_namespace_hard)) + 1) * sizeof(unicode[0]);
     2342            memcpy(p, unicode, (len + 1) * sizeof(unicode[0]));
     2343            ZVAL_UNICODEL(&XG(uvar_namespace_soft), buffer, buffer_len, 0);
     2344        }
     2345        /* TODO: copy to var */
     2346    }
     2347    else {
     2348#ifdef IS_UNICODE
     2349        XG(uvar_namespace_soft) = XG(uvar_namespace_hard);
     2350        zval_copy_ctor(&XG(uvar_namespace_soft));
     2351#endif
     2352        XG(var_namespace_soft) = XG(var_namespace_hard);
     2353        zval_copy_ctor(&XG(var_namespace_soft));
     2354    }
     2355}
     2356/* }}} */
     2357#endif
     2358void xc_var_namespace_set_stringl(const char *string, int len TSRMLS_DC) /* {{{ */
     2359{
     2360#ifdef IS_UNICODE
     2361    zval_dtor(&XG(uvar_namespace_soft));
     2362#endif
     2363    zval_dtor(&XG(var_namespace_soft));
     2364    if (len) {
     2365        if (!Z_STRLEN_P(&XG(var_namespace_soft))) {
     2366            ZVAL_STRINGL(&XG(var_namespace_soft), string, len, 1);
     2367        }
     2368        else {
     2369            int buffer_len = Z_STRLEN_P(&XG(var_namespace_hard)) + 1 + len;
     2370            char *buffer = emalloc(buffer_len + 1);
     2371            char *p = buffer;
     2372            memcpy(p, Z_STRVAL_P(&XG(var_namespace_hard)), Z_STRLEN_P(&XG(var_namespace_hard)) + 1);
     2373            p += Z_STRLEN_P(&XG(var_namespace_hard)) + 1;
     2374            memcpy(p, string, len + 1);
     2375            ZVAL_STRINGL(&XG(var_namespace_soft), buffer, buffer_len, 0);
     2376        }
     2377#ifdef IS_UNICODE
     2378        /* TODO: copy to uvar */
     2379#endif
     2380    }
     2381    else {
     2382#ifdef IS_UNICODE
     2383        XG(uvar_namespace_soft) = XG(uvar_namespace_hard);
     2384        zval_copy_ctor(&XG(uvar_namespace_soft));
     2385#endif
     2386        XG(var_namespace_soft) = XG(var_namespace_hard);
     2387        zval_copy_ctor(&XG(var_namespace_soft));
     2388    }
     2389}
     2390/* }}} */
     2391static void xc_var_namespace_break(TSRMLS_D) /* {{{ */
     2392{
     2393#ifdef IS_UNICODE
     2394    zval_dtor(&XG(uvar_namespace_soft));
     2395#endif
     2396    zval_dtor(&XG(var_namespace_soft));
     2397#ifdef IS_UNICODE
     2398    ZVAL_EMPTY_UNICODE(&XG(uvar_namespace_soft));
     2399#endif
     2400    ZVAL_EMPTY_STRING(&XG(var_namespace_soft));
     2401}
     2402/* }}} */
     2403static void xc_var_namespace_init(TSRMLS_D) /* {{{ */
     2404{
     2405    uid_t id = (uid_t) -1;
     2406
     2407    switch (xc_var_namespace_mode) {
     2408        case 1:
     2409            {
     2410                zval **server;
     2411                HashTable *ht;
     2412                zval **val;
     2413
     2414#ifdef ZEND_ENGINE_2_1
     2415                zend_is_auto_global("_SERVER", sizeof("_SERVER") - 1 TSRMLS_CC);
     2416#endif
     2417
     2418                if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void**)&server) == FAILURE
     2419                 || Z_TYPE_PP(server) != IS_ARRAY
     2420                 || !(ht = Z_ARRVAL_P(*server))
     2421                 || zend_hash_find(ht, xc_var_namespace, strlen(xc_var_namespace) + 1, (void**)&val) == FAILURE) {
     2422                    xc_var_namespace_init_from_stringl(NULL, 0 TSRMLS_CC);
     2423                }
     2424                else {
     2425#ifdef IS_UNICODE
     2426                    if (Z_TYPE_PP(val) == IS_UNICODE) {
     2427                        xc_var_namespace_init_from_unicodel(Z_USTRVAL_PP(val), Z_USTRLEN_PP(val) TSRMLS_CC);
     2428                    }
     2429                    else
     2430#endif
     2431                    {
     2432                        xc_var_namespace_init_from_stringl(Z_STRVAL_PP(val), Z_STRLEN_PP(val) TSRMLS_CC);
     2433                    }
     2434                }
     2435            }
     2436            break;
     2437
     2438        case 2:
     2439            if (strncmp(xc_var_namespace, "uid", 3) == 0) {
     2440                id = getuid();
     2441            }
     2442            else if (strncmp(xc_var_namespace, "gid", 3) == 0) {
     2443                id = getgid();
     2444            }
     2445
     2446            if (id == (uid_t) -1){
     2447                xc_var_namespace_init_from_stringl(NULL, 0 TSRMLS_CC);
     2448            }
     2449            else {
     2450                xc_var_namespace_init_from_long((long) id TSRMLS_CC);
     2451            }
     2452            break;
     2453
     2454        case 0:
     2455        default:
     2456            xc_var_namespace_init_from_stringl(xc_var_namespace, strlen(xc_var_namespace) TSRMLS_CC);
     2457            break;
     2458    }
     2459
     2460#ifdef IS_UNICODE
     2461    INIT_ZVAL(XG(uvar_namespace_soft));
     2462#endif
     2463    INIT_ZVAL(XG(var_namespace_soft));
     2464    xc_var_namespace_set_stringl("", 0 TSRMLS_CC);
     2465}
     2466/* }}} */
     2467static void xc_var_namespace_destroy(TSRMLS_D) /* {{{ */
     2468{
     2469#ifdef IS_UNICODE
     2470    zval_dtor(&XG(uvar_namespace_hard));
     2471    zval_dtor(&XG(uvar_namespace_soft));
     2472#endif
     2473    zval_dtor(&XG(var_namespace_hard));
     2474    zval_dtor(&XG(var_namespace_soft));
     2475}
     2476/* }}} */
     2477static int xc_var_buffer_prepare(zval *name TSRMLS_DC) /* {{{ prepare name, calculate buffer size */
     2478{
     2479    int namespace_len;
     2480    switch (name->type) {
     2481#ifdef IS_UNICODE
     2482        case IS_UNICODE:
     2483do_unicode:
     2484            namespace_len = Z_USTRLEN_P(&XG(uvar_namespace_soft));
     2485            return (namespace_len ? namespace_len + 1 : 0) + Z_USTRLEN_P(name);
     2486#endif
     2487
     2488        case IS_STRING:
     2489do_string:
     2490            namespace_len = Z_STRLEN_P(&XG(var_namespace_soft));
     2491            return (namespace_len ? namespace_len + 1 : 0) + Z_STRLEN_P(name);
     2492
     2493        default:
     2494#ifdef IS_UNICODE
     2495            convert_to_unicode(name);
     2496            goto do_unicode;
     2497#else
     2498            convert_to_string(name);
     2499            goto do_string;
     2500#endif
     2501    }
     2502}
     2503/* }}} */
     2504static int xc_var_buffer_alloca_size(zval *name TSRMLS_DC) /* {{{ prepare name, calculate buffer size */
     2505{
     2506    int namespace_len;
     2507    switch (name->type) {
     2508#ifdef IS_UNICODE
     2509        case IS_UNICODE:
     2510            namespace_len = Z_USTRLEN_P(&XG(uvar_namespace_soft));
     2511            return !namespace_len ? 0 : (namespace_len + 1 + Z_USTRLEN_P(name) + 1) * sizeof(Z_USTRVAL_P(&XG(uvar_namespace_soft))[0]);
     2512#endif
     2513
     2514        case IS_STRING:
     2515            namespace_len = Z_STRLEN_P(&XG(var_namespace_soft));
     2516            return !namespace_len ? 0 : (namespace_len + 1 + Z_STRLEN_P(name) + 1);
     2517    }
     2518    assert(0);
     2519    return 0;
     2520}
     2521/* }}} */
     2522static void xc_var_buffer_init(char *buffer, zval *name TSRMLS_DC) /* {{{ prepare name, calculate buffer size */
     2523{
     2524#ifdef IS_UNICODE
     2525    if (Z_TYPE(name) == IS_UNICODE) {
     2526        memcpy(buffer, Z_USTRVAL_P(&XG(uvar_namespace_soft)), (Z_USTRLEN_P(&XG(uvar_namespace_soft)) + 1) * sizeof(Z_USTRVAL_P(name)[0]));
     2527        buffer += (Z_USTRLEN_P(&XG(uvar_namespace_soft)) + 1) * sizeof(Z_USTRVAL_P(name)[0]);
     2528        memcpy(buffer, Z_USTRVAL_P(name), (Z_USTRLEN_P(name) + 1) * sizeof(Z_USTRVAL_P(name)[0]));
     2529    }
     2530#endif
     2531    memcpy(buffer, Z_STRVAL_P(&XG(var_namespace_soft)), (Z_STRLEN_P(&XG(var_namespace_soft)) + 1));
     2532    buffer += (Z_STRLEN_P(&XG(var_namespace_soft)) + 1);
     2533    memcpy(buffer, Z_STRVAL_P(name), (Z_STRLEN_P(name) + 1));
     2534}
     2535/* }}} */
     2536typedef struct xc_namebuffer_t_ { /* {{{ */
     2537    ALLOCA_FLAG(useheap);
     2538    void *buffer;
     2539    int alloca_size;
     2540    int len;
     2541} xc_namebuffer_t;
     2542/* }}} */
     2543
     2544#define VAR_BUFFER_FLAGS(name) \
     2545    xc_namebuffer_t name##_buffer;
     2546
     2547#define VAR_BUFFER_INIT(name) \
     2548    name##_buffer.len = xc_var_buffer_prepare(name TSRMLS_CC); \
     2549    name##_buffer.alloca_size = xc_var_buffer_alloca_size(name TSRMLS_CC); \
     2550    name##_buffer.buffer = name##_buffer.alloca_size \
     2551        ? do_alloca(name##_buffer.alloca_size, name##_buffer.useheap) \
     2552        : UNISW(Z_STRVAL_P(name), Z_TYPE(name) == IS_UNICODE ? Z_USTRVAL_P(name) : Z_STRVAL_P(name)); \
     2553    if (name##_buffer.alloca_size) xc_var_buffer_init(name##_buffer.buffer, name TSRMLS_CC);
     2554
     2555#define VAR_BUFFER_FREE(name) \
     2556    if (name##_buffer.alloca_size) { \
     2557        free_alloca(name##_buffer.buffer, name##_buffer.useheap); \
     2558    }
     2559
     2560static inline int xc_var_has_prefix(xc_entry_t *entry, zval *prefix TSRMLS_DC) /* {{{ */
     2561{
     2562    zend_bool result = 0;
     2563    VAR_BUFFER_FLAGS(prefix);
     2564
     2565    if (UNISW(IS_STRING, entry->name_type) != prefix->type) {
     2566        return 0;
     2567    }
     2568    VAR_BUFFER_INIT(prefix);
     2569
     2570#ifdef IS_UNICODE
     2571    if (Z_TYPE(prefix) == IS_UNICODE) {
     2572        result = entry->name.ustr.len >= prefix_buffer.len
     2573         && memcmp(entry->name.ustr.val, prefix_buffer.buffer, prefix_buffer.len * sizeof(Z_USTRVAL_P(prefix)[0])) == 0;
     2574        goto finish;
     2575    }
     2576#endif
     2577
     2578    result = entry->name.str.len >= prefix_buffer.len
     2579     && memcmp(entry->name.str.val, prefix_buffer.buffer, prefix_buffer.len) == 0;
     2580    goto finish;
     2581
     2582finish:
     2583    VAR_BUFFER_FREE(prefix);
     2584    return result;
     2585}
     2586/* }}} */
     2587
    23092588/* module helper function */
    23102589static int xc_init_constant(int module_number TSRMLS_DC) /* {{{ */
     
    25022781        }
    25032782    }
    2504 
     2783    xc_var_namespace_init(TSRMLS_C);
    25052784#ifdef ZEND_ENGINE_2
    25062785    zend_llist_init(&XG(gc_op_arrays), sizeof(xc_gc_op_array_t), xc_gc_op_array, 0);
     
    25202799    xc_gc_expires_var(TSRMLS_C);
    25212800    xc_gc_deletes(TSRMLS_C);
     2801    xc_var_namespace_destroy(TSRMLS_C);
    25222802#ifdef ZEND_ENGINE_2
    25232803    zend_llist_destroy(&XG(gc_op_arrays));
     
    25662846        zend_bailout();
    25672847    }
    2568     ht = HASH_OF((*server));
     2848    ht = Z_ARRVAL_P((*server));
    25692849
    25702850    if (zend_hash_find(ht, "PHP_AUTH_USER", sizeof("PHP_AUTH_USER"), (void **) &user) == FAILURE) {
     
    27993079}
    28003080/* }}} */
     3081/* {{{ proto mixed xcache_admin_namespace()
     3082   Break out of namespace limitation */
     3083PHP_FUNCTION(xcache_admin_namespace)
     3084{
     3085    xcache_admin_auth_check(TSRMLS_C);
     3086    xc_var_namespace_break(TSRMLS_C);
     3087}
     3088/* }}} */
    28013089
    28023090#define VAR_CACHE_NOT_INITIALIZED() do { \
     
    28043092} while (0)
    28053093
    2806 static int xc_entry_var_init_key(xc_entry_var_t *entry_var, xc_entry_hash_t *entry_hash, zval *name TSRMLS_DC) /* {{{ */
     3094static int xc_entry_var_init_key(xc_entry_var_t *entry_var, xc_entry_hash_t *entry_hash, xc_namebuffer_t *name_buffer TSRMLS_DC) /* {{{ */
    28073095{
    28083096    xc_hash_value_t hv;
    2809 
    2810     switch (name->type) {
    2811 #ifdef IS_UNICODE
    2812         case IS_UNICODE:
    2813         case IS_STRING:
    2814 #endif
    2815         default:
    2816 #ifdef IS_UNICODE
    2817             convert_to_unicode(name);
    2818 #else
    2819             convert_to_string(name);
    2820 #endif
    2821     }
    28223097
    28233098#ifdef IS_UNICODE
    28243099    entry_var->name_type = name->type;
    28253100#endif
    2826     entry_var->entry.name = name->value;
     3101    entry_var->entry.name.str.val = name_buffer->buffer;
     3102    entry_var->entry.name.str.len = name_buffer->len;
    28273103
    28283104    hv = xc_entry_hash_var((xc_entry_t *) entry_var TSRMLS_CC);
     
    28343110}
    28353111/* }}} */
     3112/* {{{ proto mixed xcache_set_namespace(string namespace)
     3113   Switch to user defined namespace */
     3114PHP_FUNCTION(xcache_set_namespace)
     3115{
     3116    zval *namespace;
     3117
     3118    if (!xc_var_caches) {
     3119        VAR_CACHE_NOT_INITIALIZED();
     3120        RETURN_NULL();
     3121    }
     3122
     3123    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &namespace) == FAILURE) {
     3124        return;
     3125    }
     3126
     3127    if (Z_TYPE_P(namespace) == IS_STRING) {
     3128        xc_var_namespace_set_stringl(Z_STRVAL_P(namespace), Z_STRLEN_P(namespace) TSRMLS_CC);
     3129    }
     3130#ifdef IS_UNICODE
     3131    else if (Z_TYPE_P(namespace) == IS_UNICODE) {
     3132        xc_var_namespace_set_unicodel(Z_USTRVAL_P(namespace), Z_USTRLEN_P(namespace) TSRMLS_CC);
     3133    }
     3134#endif
     3135}
     3136/* }}} */
    28363137/* {{{ proto mixed xcache_get(string name)
    28373138   Get cached data by specified name */
     
    28423143    xc_entry_var_t entry_var, *stored_entry_var;
    28433144    zval *name;
     3145    VAR_BUFFER_FLAGS(name);
    28443146
    28453147    if (!xc_var_caches) {
     
    28513153        return;
    28523154    }
    2853     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
     3155    VAR_BUFFER_INIT(name);
     3156    xc_entry_var_init_key(&entry_var, &entry_hash, &name_buffer TSRMLS_CC);
    28543157    cache = &xc_var_caches[entry_hash.cacheid];
    28553158
    28563159    if (cache->cached->disabled) {
     3160        VAR_BUFFER_FREE(name);
    28573161        RETURN_NULL();
    28583162    }
     
    28693173        }
    28703174    } LEAVE_LOCK(cache);
     3175    VAR_BUFFER_FREE(name);
    28713176}
    28723177/* }}} */
     
    28803185    zval *name;
    28813186    zval *value;
     3187    VAR_BUFFER_FLAGS(name);
    28823188
    28833189    if (!xc_var_caches) {
     
    29013207    }
    29023208
    2903     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
     3209    VAR_BUFFER_INIT(name);
     3210    xc_entry_var_init_key(&entry_var, &entry_hash, &name_buffer TSRMLS_CC);
    29043211    cache = &xc_var_caches[entry_hash.cacheid];
    29053212
    29063213    if (cache->cached->disabled) {
     3214        VAR_BUFFER_FREE(name);
    29073215        RETURN_NULL();
    29083216    }
     
    29163224        RETVAL_BOOL(xc_entry_var_store_unlocked(cache, entry_hash.entryslotid, &entry_var TSRMLS_CC) != NULL ? 1 : 0);
    29173225    } LEAVE_LOCK(cache);
     3226    VAR_BUFFER_FREE(name);
    29183227}
    29193228/* }}} */
     
    29263235    xc_entry_var_t entry_var, *stored_entry_var;
    29273236    zval *name;
     3237    VAR_BUFFER_FLAGS(name);
    29283238
    29293239    if (!xc_var_caches) {
     
    29353245        return;
    29363246    }
    2937     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
     3247    VAR_BUFFER_INIT(name);
     3248    xc_entry_var_init_key(&entry_var, &entry_hash, &name_buffer TSRMLS_CC);
    29383249    cache = &xc_var_caches[entry_hash.cacheid];
    29393250
    29403251    if (cache->cached->disabled) {
     3252        VAR_BUFFER_FREE(name);
    29413253        RETURN_FALSE;
    29423254    }
     
    29543266
    29553267    } LEAVE_LOCK(cache);
     3268    VAR_BUFFER_FREE(name);
    29563269}
    29573270/* }}} */
     
    29643277    xc_entry_var_t entry_var, *stored_entry_var;
    29653278    zval *name;
     3279    VAR_BUFFER_FLAGS(name);
    29663280
    29673281    if (!xc_var_caches) {
     
    29733287        return;
    29743288    }
    2975     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
     3289    VAR_BUFFER_INIT(name);
     3290    xc_entry_var_init_key(&entry_var, &entry_hash, &name_buffer TSRMLS_CC);
    29763291    cache = &xc_var_caches[entry_hash.cacheid];
    29773292
    29783293    if (cache->cached->disabled) {
     3294        VAR_BUFFER_FREE(name);
    29793295        RETURN_FALSE;
    29803296    }
     
    29903306        }
    29913307    } LEAVE_LOCK(cache);
     3308    VAR_BUFFER_FREE(name);
    29923309}
    29933310/* }}} */
     
    30203337                for (entry = cache->cached->entries[entryslotid]; entry; entry = next) {
    30213338                    next = entry->next;
    3022                     if (xc_entry_has_prefix_unlocked(XC_TYPE_VAR, entry, prefix)) {
     3339                    if (xc_var_has_prefix(entry, prefix TSRMLS_CC)) {
    30233340                        xc_entry_remove_unlocked(XC_TYPE_VAR, cache, entryslotid, entry TSRMLS_CC);
    30243341                    }
     
    30383355    long value = 0;
    30393356    zval oldzval;
     3357    VAR_BUFFER_FLAGS(name);
    30403358
    30413359    if (!xc_var_caches) {
     
    30543372    }
    30553373
    3056     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
     3374    VAR_BUFFER_INIT(name);
     3375    xc_entry_var_init_key(&entry_var, &entry_hash, &name_buffer TSRMLS_CC);
    30573376    cache = &xc_var_caches[entry_hash.cacheid];
    30583377
    30593378    if (cache->cached->disabled) {
     3379        VAR_BUFFER_FREE(name);
    30603380        RETURN_NULL();
    30613381    }
     
    31033423        xc_entry_var_store_unlocked(cache, entry_hash.entryslotid, &entry_var TSRMLS_CC);
    31043424    } LEAVE_LOCK(cache);
     3425    VAR_BUFFER_FREE(name);
    31053426}
    31063427/* }}} */
     
    31263447    PHP_FE(xcache_clear_cache,       NULL)
    31273448    PHP_FE(xcache_enable_cache,      NULL)
     3449    PHP_FE(xcache_admin_namespace,   NULL)
     3450    PHP_FE(xcache_set_namespace,     NULL)
    31283451    PHP_FE(xcache_get,               NULL)
    31293452    PHP_FE(xcache_set,               NULL)
     
    32213544    PHP_INI_ENTRY1     ("xcache.var_allocator",    "bestfit", PHP_INI_SYSTEM, xcache_OnUpdateString,   &xc_var_allocator)
    32223545    STD_PHP_INI_ENTRY  ("xcache.var_ttl",                "0", PHP_INI_ALL,    OnUpdateLong, var_ttl,   zend_xcache_globals, xcache_globals)
     3546    PHP_INI_ENTRY1     ("xcache.var_namespace_mode",     "0", PHP_INI_SYSTEM, xcache_OnUpdateULong,    &xc_var_namespace_mode)
     3547    PHP_INI_ENTRY1     ("xcache.var_namespace",           "", PHP_INI_SYSTEM, xcache_OnUpdateString,   &xc_var_namespace)
    32233548PHP_INI_END()
    32243549/* }}} */
     
    33943719        pefree(xc_var_allocator, 1);
    33953720        xc_var_allocator = NULL;
     3721    }
     3722    if (xc_var_namespace) {
     3723        pefree(xc_var_namespace, 1);
     3724        xc_var_namespace = NULL;
    33963725    }
    33973726
  • trunk/xcache_globals.h

    r1118 r1146  
    2121    time_t request_time;
    2222    long   var_ttl;
     23#ifdef IS_UNCODE
     24    zval uvar_namespace_hard;
     25    zval uvar_namespace_soft;
     26#endif
     27    zval var_namespace_hard;
     28    zval var_namespace_soft;
    2329
    2430    zend_llist gc_op_arrays;
Note: See TracChangeset for help on using the changeset viewer.