source: trunk/mod_disassembler/xc_disassembler.c @ 1026

Last change on this file since 1026 was 1026, checked in by moo, 21 months ago

refactor: split extension init to sub module. TODO: compatibility regression

  • Property svn:eol-style set to native
File size: 6.4 KB
Line 
1#include "xc_disassembler.h"
2#include "xcache.h"
3#include "xcache/xc_utils.h"
4#include "xcache/xc_sandbox.h"
5#include "xcache/xc_compatibility.h"
6#include "xc_processor.h"
7
8#include "ext/standard/info.h"
9
10static void xc_dasm(zval *output, zend_op_array *op_array TSRMLS_DC) /* {{{ */
11{
12    const Bucket *b;
13    zval *zv, *list;
14    xc_compile_result_t cr;
15    int bufsize = 2;
16    char *buf;
17    xc_dasm_t dasm;
18
19    xc_compile_result_init_cur(&cr, op_array TSRMLS_CC);
20
21    xc_apply_op_array(&cr, (apply_func_t) xc_undo_pass_two TSRMLS_CC);
22    xc_apply_op_array(&cr, (apply_func_t) xc_fix_opcode TSRMLS_CC);
23
24    /* go */
25    array_init(output);
26
27    ALLOC_INIT_ZVAL(zv);
28    array_init(zv);
29    xc_dasm_zend_op_array(&dasm, zv, op_array TSRMLS_CC);
30    add_assoc_zval_ex(output, ZEND_STRS("op_array"), zv);
31
32    buf = emalloc(bufsize);
33
34    ALLOC_INIT_ZVAL(list);
35    array_init(list);
36    for (b = xc_sandbox_user_function_begin(TSRMLS_C); b; b = b->pListNext) {
37        int keysize, keyLength;
38
39        ALLOC_INIT_ZVAL(zv);
40        array_init(zv);
41        xc_dasm_zend_function(&dasm, zv, b->pData TSRMLS_CC);
42
43        keysize = BUCKET_KEY_SIZE(b) + 2;
44        if (keysize > bufsize) {
45            do {
46                bufsize *= 2;
47            } while (keysize > bufsize);
48            buf = erealloc(buf, bufsize);
49        }
50        memcpy(buf, BUCKET_KEY_S(b), keysize);
51        buf[keysize - 2] = buf[keysize - 1] = ""[0];
52        keyLength = b->nKeyLength;
53#ifdef IS_UNICODE
54        if (BUCKET_KEY_TYPE(b) == IS_UNICODE) {
55            if (buf[0] == ""[0] && buf[1] == ""[0]) {
56                keyLength ++;
57            }
58        } else
59#endif
60        {
61            if (buf[0] == ""[0]) {
62                keyLength ++;
63            }
64        }
65
66        add_u_assoc_zval_ex(list, BUCKET_KEY_TYPE(b), ZSTR(buf), keyLength, zv);
67    }
68    add_assoc_zval_ex(output, ZEND_STRS("function_table"), list);
69   
70    ALLOC_INIT_ZVAL(list);
71    array_init(list);
72    for (b = xc_sandbox_user_class_begin(TSRMLS_C); b; b = b->pListNext) {
73        int keysize, keyLength;
74
75        ALLOC_INIT_ZVAL(zv);
76        array_init(zv);
77        xc_dasm_zend_class_entry(&dasm, zv, CestToCePtr(*(xc_cest_t *)b->pData) TSRMLS_CC);
78
79        keysize = BUCKET_KEY_SIZE(b) + 2;
80        if (keysize > bufsize) {
81            do {
82                bufsize *= 2;
83            } while (keysize > bufsize);
84            buf = erealloc(buf, bufsize);
85        }
86        memcpy(buf, BUCKET_KEY_S(b), keysize);
87        buf[keysize - 2] = buf[keysize - 1] = ""[0];
88        keyLength = b->nKeyLength;
89#ifdef IS_UNICODE
90        if (BUCKET_KEY_TYPE(b) == IS_UNICODE) {
91            if (buf[0] == ""[0] && buf[1] == ""[0]) {
92                keyLength ++;
93            }
94        } else
95#endif
96        {
97            if (buf[0] == ""[0]) {
98                keyLength ++;
99            }
100        }
101        add_u_assoc_zval_ex(list, BUCKET_KEY_TYPE(b), ZSTR(buf), keyLength, zv);
102    }
103    efree(buf);
104    add_assoc_zval_ex(output, ZEND_STRS("class_table"), list);
105
106    /*xc_apply_op_array(&cr, (apply_func_t) xc_redo_pass_two TSRMLS_CC);*/
107    xc_compile_result_free(&cr);
108}
109/* }}} */
110typedef struct xc_dasm_sandboxed_t { /* {{{ */
111    enum Type {
112        xc_dasm_file_t
113        , xc_dasm_string_t
114    } type;
115    union {
116        zval *zfilename;
117        struct {
118            zval *source;
119            char *eval_name;
120        } compile_string;
121    } input;
122
123    zval *output;
124} xc_dasm_sandboxed_t; /* }}} */
125zend_op_array *xc_dasm_sandboxed(void *data TSRMLS_DC) /* {{{ */
126{
127    zend_bool catched = 0;
128    zend_op_array *op_array = NULL;
129    xc_dasm_sandboxed_t *sandboxed_dasm = (xc_dasm_sandboxed_t *) data;
130
131    zend_try {
132        if (sandboxed_dasm->type == xc_dasm_file_t) {
133            op_array = compile_filename(ZEND_REQUIRE, sandboxed_dasm->input.zfilename TSRMLS_CC);
134        }
135        else {
136            op_array = compile_string(sandboxed_dasm->input.compile_string.source, sandboxed_dasm->input.compile_string.eval_name TSRMLS_CC);
137        }
138    } zend_catch {
139        catched = 1;
140    } zend_end_try();
141
142    if (catched || !op_array) {
143#define return_value sandboxed_dasm->output
144        RETVAL_FALSE;
145#undef return_value
146        return NULL;
147    }
148
149    xc_dasm(sandboxed_dasm->output, op_array TSRMLS_CC);
150
151    /* free */
152#ifdef ZEND_ENGINE_2
153    destroy_op_array(op_array TSRMLS_CC);
154#else
155    destroy_op_array(op_array);
156#endif
157    efree(op_array);
158
159    return NULL;
160} /* }}} */
161void xc_dasm_string(zval *output, zval *source TSRMLS_DC) /* {{{ */
162{
163    xc_dasm_sandboxed_t sandboxed_dasm;
164    char *eval_name = zend_make_compiled_string_description("runtime-created function" TSRMLS_CC);
165
166    sandboxed_dasm.output = output;
167    sandboxed_dasm.type = xc_dasm_string_t;
168    sandboxed_dasm.input.compile_string.source = source;
169    sandboxed_dasm.input.compile_string.eval_name = eval_name;
170    xc_sandbox(&xc_dasm_sandboxed, (void *) &sandboxed_dasm, eval_name TSRMLS_CC);
171    efree(eval_name);
172}
173/* }}} */
174void xc_dasm_file(zval *output, const char *filename TSRMLS_DC) /* {{{ */
175{
176    zval *zfilename;
177    xc_dasm_sandboxed_t sandboxed_dasm;
178
179    MAKE_STD_ZVAL(zfilename);
180    zfilename->value.str.val = estrdup(filename);
181    zfilename->value.str.len = strlen(filename);
182    zfilename->type = IS_STRING;
183
184    sandboxed_dasm.output = output;
185    sandboxed_dasm.type = xc_dasm_file_t;
186    sandboxed_dasm.input.zfilename = zfilename;
187    xc_sandbox(&xc_dasm_sandboxed, (void *) &sandboxed_dasm, zfilename->value.str.val TSRMLS_CC);
188
189    zval_dtor(zfilename);
190    FREE_ZVAL(zfilename);
191}
192/* }}} */
193
194/* {{{ proto array xcache_dasm_file(string filename)
195   Disassemble file into opcode array by filename */
196PHP_FUNCTION(xcache_dasm_file)
197{
198    char *filename;
199    int filename_len;
200
201    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
202        return;
203    }
204    if (!filename_len) RETURN_FALSE;
205
206    xc_dasm_file(return_value, filename TSRMLS_CC);
207}
208/* }}} */
209/* {{{ proto array xcache_dasm_string(string code)
210   Disassemble php code into opcode array */
211PHP_FUNCTION(xcache_dasm_string)
212{
213    zval *code;
214
215    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &code) == FAILURE) {
216        return;
217    }
218    xc_dasm_string(return_value, code TSRMLS_CC);
219}
220/* }}} */
221
222/* {{{ PHP_MINFO_FUNCTION(xcache_disassembler) */
223static PHP_MINFO_FUNCTION(xcache_disassembler)
224{
225    php_info_print_table_start();
226    php_info_print_table_row(2, "XCache Disassembler Version", XCACHE_VERSION);
227    php_info_print_table_end();
228
229    DISPLAY_INI_ENTRIES();
230}
231/* }}} */
232static zend_function_entry xcache_disassembler_functions[] = /* {{{ */
233{
234    PHP_FE(xcache_dasm_file,         NULL)
235    PHP_FE(xcache_dasm_string,       NULL)
236    PHP_FE_END
237};
238/* }}} */
239static zend_module_entry xcache_disassembler_module_entry = { /* {{{ */
240    STANDARD_MODULE_HEADER,
241    XCACHE_NAME "_Disassembler",
242    xcache_disassembler_functions,
243    NULL,
244    NULL,
245    NULL,
246    NULL,
247    PHP_MINFO(xcache_disassembler),
248    XCACHE_VERSION,
249#ifdef PHP_GINIT
250    NO_MODULE_GLOBALS,
251#endif
252#ifdef ZEND_ENGINE_2
253    NULL,
254#else
255    NULL,
256    NULL,
257#endif
258    STANDARD_MODULE_PROPERTIES_EX
259};
260/* }}} */
261int xc_disassembler_startup_module() /* {{{ */
262{
263    return zend_startup_module(&xcache_disassembler_module_entry);
264}
265/* }}} */
Note: See TracBrowser for help on using the repository browser.