1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 7 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Felipe Pena <felipe@php.net> |
16 | Authors: Joe Watkins <joe.watkins@live.co.uk> |
17 | Authors: Bob Weinand <bwoebi@php.net> |
18 +----------------------------------------------------------------------+
19 */
20
21 #include "zend.h"
22 #include "zend_hash.h"
23 #include "phpdbg.h"
24 #include "phpdbg_bp.h"
25 #include "phpdbg_utils.h"
26 #include "phpdbg_opcode.h"
27 #include "zend_globals.h"
28 #include "ext/standard/php_string.h"
29
30 ZEND_EXTERN_MODULE_GLOBALS(phpdbg)
31
32 /* {{{ private api functions */
33 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_file(zend_op_array*);
34 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_symbol(zend_function*);
35 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_method(zend_op_array*);
36 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_opline(phpdbg_opline_ptr_t);
37 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_opcode(zend_uchar);
38 static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execute_data *execute_data); /* }}} */
39
40 /*
41 * Note:
42 * A break point must always set the correct id and type
43 * A set breakpoint function must always map new points
44 */
_phpdbg_break_mapping(int id,HashTable * table)45 static inline void _phpdbg_break_mapping(int id, HashTable *table) /* {{{ */
46 {
47 zend_hash_index_update_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], id, table);
48 }
49 /* }}} */
50
51 #define PHPDBG_BREAK_MAPPING(id, table) _phpdbg_break_mapping(id, table)
52 #define PHPDBG_BREAK_UNMAPPING(id) \
53 zend_hash_index_del(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (id))
54
55 #define PHPDBG_BREAK_INIT(b, t) do {\
56 memset(&b, 0, sizeof(b)); \
57 b.id = PHPDBG_G(bp_count)++; \
58 b.type = t; \
59 b.disabled = 0;\
60 b.hits = 0; \
61 } while(0)
62
phpdbg_file_breaks_dtor(zval * data)63 static void phpdbg_file_breaks_dtor(zval *data) /* {{{ */
64 {
65 phpdbg_breakfile_t *bp = (phpdbg_breakfile_t*) Z_PTR_P(data);
66
67 efree((char*)bp->filename);
68 efree(bp);
69 } /* }}} */
70
phpdbg_class_breaks_dtor(zval * data)71 static void phpdbg_class_breaks_dtor(zval *data) /* {{{ */
72 {
73 phpdbg_breakmethod_t *bp = (phpdbg_breakmethod_t *) Z_PTR_P(data);
74
75 efree((char*)bp->class_name);
76 efree((char*)bp->func_name);
77 efree(bp);
78 } /* }}} */
79
phpdbg_opline_class_breaks_dtor(zval * data)80 static void phpdbg_opline_class_breaks_dtor(zval *data) /* {{{ */
81 {
82 zend_hash_destroy(Z_ARRVAL_P(data));
83 efree(Z_ARRVAL_P(data));
84 } /* }}} */
85
phpdbg_opline_breaks_dtor(zval * data)86 static void phpdbg_opline_breaks_dtor(zval *data) /* {{{ */
87 {
88 phpdbg_breakopline_t *bp = (phpdbg_breakopline_t *) Z_PTR_P(data);
89
90 if (bp->class_name) {
91 efree((char*)bp->class_name);
92 }
93 if (bp->func_name) {
94 efree((char*)bp->func_name);
95 }
96 efree(bp);
97 } /* }}} */
98
phpdbg_reset_breakpoints(void)99 PHPDBG_API void phpdbg_reset_breakpoints(void) /* {{{ */
100 {
101 HashTable *table;
102
103 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], table) {
104 phpdbg_breakbase_t *brake;
105
106 ZEND_HASH_FOREACH_PTR(table, brake) {
107 brake->hits = 0;
108 } ZEND_HASH_FOREACH_END();
109 } ZEND_HASH_FOREACH_END();
110 } /* }}} */
111
phpdbg_export_breakpoints(FILE * handle)112 PHPDBG_API void phpdbg_export_breakpoints(FILE *handle) /* {{{ */
113 {
114 char *string;
115 phpdbg_export_breakpoints_to_string(&string);
116 fputs(string, handle);
117 }
118 /* }}} */
119
phpdbg_export_breakpoints_to_string(char ** str)120 PHPDBG_API void phpdbg_export_breakpoints_to_string(char **str) /* {{{ */
121 {
122 HashTable *table;
123 zend_ulong id = 0L;
124
125 *str = "";
126
127 if (zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP])) {
128 phpdbg_notice("exportbreakpoint", "count=\"%d\"", "Exporting %d breakpoints", zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP]));
129
130 /* this only looks like magic, it isn't */
131 ZEND_HASH_FOREACH_NUM_KEY_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], id, table) {
132 phpdbg_breakbase_t *brake;
133
134 ZEND_HASH_FOREACH_PTR(table, brake) {
135 if (brake->id == id) {
136 char *new_str = NULL;
137
138 switch (brake->type) {
139 case PHPDBG_BREAK_FILE: {
140 zend_string *filename = php_addcslashes_str(((phpdbg_breakfile_t*)brake)->filename, strlen(((phpdbg_breakfile_t*)brake)->filename), "\\\"\n", 3);
141 phpdbg_asprintf(&new_str,
142 "%sbreak \"%s\":%lu\n", *str,
143 ZSTR_VAL(filename),
144 ((phpdbg_breakfile_t*)brake)->line);
145 zend_string_release(filename);
146 } break;
147
148 case PHPDBG_BREAK_SYM: {
149 phpdbg_asprintf(&new_str,
150 "%sbreak %s\n", *str,
151 ((phpdbg_breaksymbol_t*)brake)->symbol);
152 } break;
153
154 case PHPDBG_BREAK_METHOD: {
155 phpdbg_asprintf(&new_str,
156 "%sbreak %s::%s\n", *str,
157 ((phpdbg_breakmethod_t*)brake)->class_name,
158 ((phpdbg_breakmethod_t*)brake)->func_name);
159 } break;
160
161 case PHPDBG_BREAK_METHOD_OPLINE: {
162 phpdbg_asprintf(&new_str,
163 "%sbreak %s::%s#%llu\n", *str,
164 ((phpdbg_breakopline_t*)brake)->class_name,
165 ((phpdbg_breakopline_t*)brake)->func_name,
166 ((phpdbg_breakopline_t*)brake)->opline_num);
167 } break;
168
169 case PHPDBG_BREAK_FUNCTION_OPLINE: {
170 phpdbg_asprintf(&new_str,
171 "%sbreak %s#%llu\n", *str,
172 ((phpdbg_breakopline_t*)brake)->func_name,
173 ((phpdbg_breakopline_t*)brake)->opline_num);
174 } break;
175
176 case PHPDBG_BREAK_FILE_OPLINE: {
177 zend_string *filename = php_addcslashes_str(((phpdbg_breakopline_t*)brake)->class_name, strlen(((phpdbg_breakopline_t*)brake)->class_name), "\\\"\n", 3);
178 phpdbg_asprintf(&new_str,
179 "%sbreak \"%s\":#%llu\n", *str,
180 ZSTR_VAL(filename),
181 ((phpdbg_breakopline_t*)brake)->opline_num);
182 zend_string_release(filename);
183 } break;
184
185 case PHPDBG_BREAK_OPCODE: {
186 phpdbg_asprintf(&new_str,
187 "%sbreak %s\n", *str,
188 ((phpdbg_breakop_t*)brake)->name);
189 } break;
190
191 case PHPDBG_BREAK_COND: {
192 phpdbg_breakcond_t *conditional = (phpdbg_breakcond_t*) brake;
193
194 if (conditional->paramed) {
195 switch (conditional->param.type) {
196 case NUMERIC_FUNCTION_PARAM:
197 phpdbg_asprintf(&new_str,
198 "%sbreak at %s#%ld if %s\n",
199 *str, conditional->param.str, conditional->param.num, conditional->code);
200 break;
201
202 case NUMERIC_METHOD_PARAM:
203 phpdbg_asprintf(&new_str,
204 "%sbreak at %s::%s#%ld if %s\n",
205 *str, conditional->param.method.class, conditional->param.method.name, conditional->param.num, conditional->code);
206 break;
207
208 case ADDR_PARAM:
209 phpdbg_asprintf(&new_str,
210 "%sbreak at 0X%lx if %s\n",
211 *str, conditional->param.addr, conditional->code);
212 break;
213
214 case STR_PARAM:
215 phpdbg_asprintf(&new_str,
216 "%sbreak at %s if %s\n", *str, conditional->param.str, conditional->code);
217 break;
218
219 case METHOD_PARAM:
220 phpdbg_asprintf(&new_str,
221 "%sbreak at %s::%s if %s\n", *str,
222 conditional->param.method.class, conditional->param.method.name,
223 conditional->code);
224 break;
225
226 case FILE_PARAM: {
227 zend_string *filename = php_addcslashes_str(conditional->param.file.name, strlen(conditional->param.file.name), "\\\"\n", 3);
228 phpdbg_asprintf(&new_str,
229 "%sbreak at \"%s\":%lu if %s\n", *str,
230 ZSTR_VAL(filename), conditional->param.file.line,
231 conditional->code);
232 zend_string_release(filename);
233 } break;
234
235 default: { /* do nothing */ } break;
236 }
237 } else {
238 phpdbg_asprintf(&new_str, "%sbreak if %s\n", str, conditional->code);
239 }
240 } break;
241
242 default: continue;
243 }
244
245 if ((*str)[0]) {
246 efree(*str);
247 }
248 *str = new_str;
249 }
250 } ZEND_HASH_FOREACH_END();
251 } ZEND_HASH_FOREACH_END();
252 }
253
254 if ((*str) && !(*str)[0]) {
255 *str = NULL;
256 }
257 } /* }}} */
258
phpdbg_set_breakpoint_file(const char * path,size_t path_len,long line_num)259 PHPDBG_API void phpdbg_set_breakpoint_file(const char *path, size_t path_len, long line_num) /* {{{ */
260 {
261 php_stream_statbuf ssb;
262 char realpath[MAXPATHLEN];
263 const char *original_path = path;
264 zend_bool pending = 0;
265 zend_string *path_str;
266
267 HashTable *broken, *file_breaks = &PHPDBG_G(bp)[PHPDBG_BREAK_FILE];
268 phpdbg_breakfile_t new_break;
269
270 if (!path_len) {
271 if (VCWD_REALPATH(path, realpath)) {
272 path = realpath;
273 }
274 }
275 path_len = strlen(path);
276
277 phpdbg_debug("file path: %s, resolved path: %s, was compiled: %d\n", original_path, path, zend_hash_str_exists(&PHPDBG_G(file_sources), path, path_len));
278
279 if (!zend_hash_str_exists(&PHPDBG_G(file_sources), path, path_len)) {
280 if (php_stream_stat_path(path, &ssb) == FAILURE) {
281 if (original_path[0] == '/') {
282 phpdbg_error("breakpoint", "type=\"nofile\" add=\"fail\" file=\"%s\"", "Cannot stat %s, it does not exist", original_path);
283 return;
284 }
285
286 file_breaks = &PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING];
287 path = original_path;
288 path_len = strlen(path);
289 pending = 1;
290 } else if (!(ssb.sb.st_mode & (S_IFREG|S_IFLNK))) {
291 phpdbg_error("breakpoint", "type=\"notregular\" add=\"fail\" file=\"%s\"", "Cannot set breakpoint in %s, it is not a regular file", path);
292 return;
293 } else {
294 phpdbg_debug("File exists, but not compiled\n");
295 }
296 }
297
298 path_str = zend_string_init(path, path_len, 0);
299
300 if (!(broken = zend_hash_find_ptr(file_breaks, path_str))) {
301 HashTable breaks;
302 zend_hash_init(&breaks, 8, NULL, phpdbg_file_breaks_dtor, 0);
303
304 broken = zend_hash_add_mem(file_breaks, path_str, &breaks, sizeof(HashTable));
305 }
306
307 if (!zend_hash_index_exists(broken, line_num)) {
308 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_FILE);
309 new_break.filename = estrndup(path, path_len);
310 new_break.line = line_num;
311
312 zend_hash_index_update_mem(broken, line_num, &new_break, sizeof(phpdbg_breakfile_t));
313
314 PHPDBG_BREAK_MAPPING(new_break.id, broken);
315
316 if (pending) {
317 zend_string *file;
318 ZEND_HASH_FOREACH_STR_KEY(&PHPDBG_G(file_sources), file) {
319 HashTable *fileht;
320
321 phpdbg_debug("Compare against loaded %s\n", file);
322
323 if (!(pending = ((fileht = phpdbg_resolve_pending_file_break_ex(ZSTR_VAL(file), ZSTR_LEN(file), path_str, broken)) == NULL))) {
324 new_break = *(phpdbg_breakfile_t *) zend_hash_index_find_ptr(fileht, line_num);
325 break;
326 }
327 } ZEND_HASH_FOREACH_END();
328 }
329
330 if (pending) {
331 PHPDBG_G(flags) |= PHPDBG_HAS_PENDING_FILE_BP;
332
333 phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" file=\"%s\" line=\"%ld\" pending=\"pending\"", "Pending breakpoint #%d added at %s:%ld", new_break.id, new_break.filename, new_break.line);
334 } else {
335 PHPDBG_G(flags) |= PHPDBG_HAS_FILE_BP;
336
337 phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" file=\"%s\" line=\"%ld\"", "Breakpoint #%d added at %s:%ld", new_break.id, new_break.filename, new_break.line);
338 }
339 } else {
340 phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" file=\"%s\" line=\"%ld\"", "Breakpoint at %s:%ld exists", path, line_num);
341 }
342
343 zend_string_release(path_str);
344 } /* }}} */
345
phpdbg_resolve_pending_file_break_ex(const char * file,uint32_t filelen,zend_string * cur,HashTable * fileht)346 PHPDBG_API HashTable *phpdbg_resolve_pending_file_break_ex(const char *file, uint32_t filelen, zend_string *cur, HashTable *fileht) /* {{{ */
347 {
348 phpdbg_debug("file: %s, filelen: %u, cur: %s, curlen %u, pos: %c, memcmp: %d\n", file, filelen, ZSTR_VAL(cur), ZSTR_LEN(cur), filelen > ZSTR_LEN(cur) ? file[filelen - ZSTR_LEN(cur) - 1] : '?', filelen > ZSTR_LEN(cur) ? memcmp(file + filelen - ZSTR_LEN(cur), ZSTR_VAL(cur), ZSTR_LEN(cur)) : 0);
349
350 #ifdef _WIN32
351 # define WIN32_PATH_CHECK file[filelen - ZSTR_LEN(cur) - 1] == '\\'
352 #else
353 # define WIN32_PATH_CHECK 0
354 #endif
355
356 if (((ZSTR_LEN(cur) < filelen && (file[filelen - ZSTR_LEN(cur) - 1] == '/' || WIN32_PATH_CHECK)) || filelen == ZSTR_LEN(cur)) && !memcmp(file + filelen - ZSTR_LEN(cur), ZSTR_VAL(cur), ZSTR_LEN(cur))) {
357 phpdbg_breakfile_t *brake, new_brake;
358 HashTable *master;
359
360 PHPDBG_G(flags) |= PHPDBG_HAS_FILE_BP;
361
362 if (!(master = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], file, filelen))) {
363 HashTable new_ht;
364 zend_hash_init(&new_ht, 8, NULL, phpdbg_file_breaks_dtor, 0);
365 master = zend_hash_str_add_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], file, filelen, &new_ht, sizeof(HashTable));
366 }
367
368 ZEND_HASH_FOREACH_PTR(fileht, brake) {
369 new_brake = *brake;
370 new_brake.filename = estrndup(file, filelen);
371 PHPDBG_BREAK_UNMAPPING(brake->id);
372
373 if (zend_hash_index_add_mem(master, brake->line, &new_brake, sizeof(phpdbg_breakfile_t))) {
374 PHPDBG_BREAK_MAPPING(brake->id, master);
375 }
376 } ZEND_HASH_FOREACH_END();
377
378 zend_hash_del(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], cur);
379
380 if (!zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING])) {
381 PHPDBG_G(flags) &= ~PHPDBG_HAS_PENDING_FILE_BP;
382 }
383
384 phpdbg_debug("compiled file: %s, cur bp file: %s\n", file, cur);
385
386 return master;
387 }
388
389 return NULL;
390 } /* }}} */
391
phpdbg_resolve_pending_file_break(const char * file)392 PHPDBG_API void phpdbg_resolve_pending_file_break(const char *file) /* {{{ */
393 {
394 HashTable *fileht;
395 uint32_t filelen = strlen(file);
396 zend_string *cur;
397
398 phpdbg_debug("was compiled: %s\n", file);
399
400 ZEND_HASH_FOREACH_STR_KEY_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], cur, fileht) {
401 phpdbg_debug("check bp: %s\n", cur);
402
403 phpdbg_resolve_pending_file_break_ex(file, filelen, cur, fileht);
404 } ZEND_HASH_FOREACH_END();
405 } /* }}} */
406
phpdbg_set_breakpoint_symbol(const char * name,size_t name_len)407 PHPDBG_API void phpdbg_set_breakpoint_symbol(const char *name, size_t name_len) /* {{{ */
408 {
409 char *lcname;
410
411 if (*name == '\\') {
412 name++;
413 name_len--;
414 }
415
416 lcname = zend_str_tolower_dup(name, name_len);
417
418 if (!zend_hash_str_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], name, name_len)) {
419 phpdbg_breaksymbol_t new_break;
420
421 PHPDBG_G(flags) |= PHPDBG_HAS_SYM_BP;
422
423 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_SYM);
424 new_break.symbol = estrndup(name, name_len);
425
426 zend_hash_str_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], lcname, name_len, &new_break, sizeof(phpdbg_breaksymbol_t));
427
428 phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" function=\"%s\"", "Breakpoint #%d added at %s", new_break.id, new_break.symbol);
429
430 PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_SYM]);
431 } else {
432 phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" function=\"%s\"", "Breakpoint exists at %s", name);
433 }
434
435 efree(lcname);
436 } /* }}} */
437
phpdbg_set_breakpoint_method(const char * class_name,const char * func_name)438 PHPDBG_API void phpdbg_set_breakpoint_method(const char *class_name, const char *func_name) /* {{{ */
439 {
440 HashTable class_breaks, *class_table;
441 size_t class_len = strlen(class_name);
442 size_t func_len = strlen(func_name);
443 char *func_lcname, *class_lcname;
444
445 if (*class_name == '\\') {
446 class_name++;
447 class_len--;
448 }
449
450 func_lcname = zend_str_tolower_dup(func_name, func_len);
451 class_lcname = zend_str_tolower_dup(class_name, class_len);
452
453 if (!(class_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], class_lcname, class_len))) {
454 zend_hash_init(&class_breaks, 8, NULL, phpdbg_class_breaks_dtor, 0);
455 class_table = zend_hash_str_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], class_lcname, class_len, &class_breaks, sizeof(HashTable));
456 }
457
458 if (!zend_hash_str_exists(class_table, func_lcname, func_len)) {
459 phpdbg_breakmethod_t new_break;
460
461 PHPDBG_G(flags) |= PHPDBG_HAS_METHOD_BP;
462
463 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_METHOD);
464 new_break.class_name = estrndup(class_name, class_len);
465 new_break.class_len = class_len;
466 new_break.func_name = estrndup(func_name, func_len);
467 new_break.func_len = func_len;
468
469 zend_hash_str_update_mem(class_table, func_lcname, func_len, &new_break, sizeof(phpdbg_breakmethod_t));
470
471 phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" method=\"%s::%s\"", "Breakpoint #%d added at %s::%s", new_break.id, class_name, func_name);
472
473 PHPDBG_BREAK_MAPPING(new_break.id, class_table);
474 } else {
475 phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" method=\"%s::%s\"", "Breakpoint exists at %s::%s", class_name, func_name);
476 }
477
478 efree(func_lcname);
479 efree(class_lcname);
480 } /* }}} */
481
phpdbg_set_breakpoint_opline(zend_ulong opline)482 PHPDBG_API void phpdbg_set_breakpoint_opline(zend_ulong opline) /* {{{ */
483 {
484 if (!zend_hash_index_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline)) {
485 phpdbg_breakline_t new_break;
486
487 PHPDBG_G(flags) |= PHPDBG_HAS_OPLINE_BP;
488
489 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_OPLINE);
490 new_break.name = NULL;
491 new_break.opline = opline;
492 new_break.base = NULL;
493
494 zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline, &new_break, sizeof(phpdbg_breakline_t));
495
496 phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" opline=\"%#lx\"", "Breakpoint #%d added at %#lx", new_break.id, new_break.opline);
497 PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
498 } else {
499 phpdbg_error("breakpoint", "type=\"exists\" add=\"fail\" opline=\"%#lx\"", "Breakpoint exists at %#lx", opline);
500 }
501 } /* }}} */
502
phpdbg_resolve_op_array_break(phpdbg_breakopline_t * brake,zend_op_array * op_array)503 PHPDBG_API int phpdbg_resolve_op_array_break(phpdbg_breakopline_t *brake, zend_op_array *op_array) /* {{{ */
504 {
505 phpdbg_breakline_t opline_break;
506 if (op_array->last <= brake->opline_num) {
507 if (brake->class_name == NULL) {
508 phpdbg_error("breakpoint", "type=\"maxoplines\" add=\"fail\" maxoplinenum=\"%d\" function=\"%s\" usedoplinenum=\"%ld\"", "There are only %d oplines in function %s (breaking at opline %ld impossible)", op_array->last, brake->func_name, brake->opline_num);
509 } else if (brake->func_name == NULL) {
510 phpdbg_error("breakpoint", "type=\"maxoplines\" add=\"fail\" maxoplinenum=\"%d\" file=\"%s\" usedoplinenum=\"%ld\"", "There are only %d oplines in file %s (breaking at opline %ld impossible)", op_array->last, brake->class_name, brake->opline_num);
511 } else {
512 phpdbg_error("breakpoint", "type=\"maxoplines\" add=\"fail\" maxoplinenum=\"%d\" method=\"%s::%s\" usedoplinenum=\"%ld\"", "There are only %d oplines in method %s::%s (breaking at opline %ld impossible)", op_array->last, brake->class_name, brake->func_name, brake->opline_num);
513 }
514
515 return FAILURE;
516 }
517
518 opline_break.disabled = 0;
519 opline_break.hits = 0;
520 opline_break.id = brake->id;
521 opline_break.opline = brake->opline = (zend_ulong)(op_array->opcodes + brake->opline_num);
522 opline_break.name = NULL;
523 opline_break.base = brake;
524 if (op_array->scope) {
525 opline_break.type = PHPDBG_BREAK_METHOD_OPLINE;
526 } else if (op_array->function_name) {
527 opline_break.type = PHPDBG_BREAK_FUNCTION_OPLINE;
528 } else {
529 opline_break.type = PHPDBG_BREAK_FILE_OPLINE;
530 }
531
532 PHPDBG_G(flags) |= PHPDBG_HAS_OPLINE_BP;
533
534 zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline_break.opline, &opline_break, sizeof(phpdbg_breakline_t));
535
536 return SUCCESS;
537 } /* }}} */
538
phpdbg_resolve_op_array_breaks(zend_op_array * op_array)539 PHPDBG_API void phpdbg_resolve_op_array_breaks(zend_op_array *op_array) /* {{{ */
540 {
541 HashTable *func_table = &PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE];
542 HashTable *oplines_table;
543 phpdbg_breakopline_t *brake;
544
545 if (op_array->scope != NULL && !(func_table = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], op_array->scope->name))) {
546 return;
547 }
548
549 if (op_array->function_name == NULL) {
550 if (!(oplines_table = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], op_array->filename))) {
551 return;
552 }
553 } else if (!op_array->function_name || !(oplines_table = zend_hash_find_ptr(func_table, op_array->function_name))) {
554 return;
555 }
556
557 ZEND_HASH_FOREACH_PTR(oplines_table, brake) {
558 if (phpdbg_resolve_op_array_break(brake, op_array) == SUCCESS) {
559 phpdbg_breakline_t *opline_break;
560
561 zend_hash_internal_pointer_end(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
562 opline_break = zend_hash_get_current_data_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
563
564 phpdbg_notice("breakpoint", "add=\"success\" id=\"%d\" symbol=\"%s\" num=\"%ld\" opline=\"%#lx\"", "Breakpoint #%d resolved at %s%s%s#%ld (opline %#lx)",
565 opline_break->id,
566 brake->class_name ? brake->class_name : "",
567 brake->class_name && brake->func_name ? "::" : "",
568 brake->func_name ? brake->func_name : "",
569 brake->opline_num,
570 opline_break->opline);
571 }
572 } ZEND_HASH_FOREACH_END();
573 } /* }}} */
574
phpdbg_resolve_opline_break(phpdbg_breakopline_t * new_break)575 PHPDBG_API int phpdbg_resolve_opline_break(phpdbg_breakopline_t *new_break) /* {{{ */
576 {
577 HashTable *func_table = EG(function_table);
578 zend_function *func;
579
580 if (new_break->func_name == NULL) {
581 if (EG(current_execute_data) == NULL) {
582 if (PHPDBG_G(ops) != NULL && !memcmp(PHPDBG_G(ops)->filename, new_break->class_name, new_break->class_len)) {
583 if (phpdbg_resolve_op_array_break(new_break, PHPDBG_G(ops)) == SUCCESS) {
584 return SUCCESS;
585 } else {
586 return 2;
587 }
588 }
589 return FAILURE;
590 } else {
591 zend_execute_data *execute_data = EG(current_execute_data);
592 do {
593 if (ZEND_USER_CODE(execute_data->func->common.type)) {
594 zend_op_array *op_array = &execute_data->func->op_array;
595 if (op_array->function_name == NULL && op_array->scope == NULL && new_break->class_len == ZSTR_LEN(op_array->filename) && !memcmp(ZSTR_VAL(op_array->filename), new_break->class_name, new_break->class_len)) {
596 if (phpdbg_resolve_op_array_break(new_break, op_array) == SUCCESS) {
597 return SUCCESS;
598 } else {
599 return 2;
600 }
601 }
602 }
603 } while ((execute_data = execute_data->prev_execute_data) != NULL);
604 return FAILURE;
605 }
606 }
607
608 if (new_break->class_name != NULL) {
609 zend_class_entry *ce;
610 if (!(ce = zend_hash_str_find_ptr(EG(class_table), zend_str_tolower_dup(new_break->class_name, new_break->class_len), new_break->class_len))) {
611 return FAILURE;
612 }
613 func_table = &ce->function_table;
614 }
615
616 if (!(func = zend_hash_str_find_ptr(func_table, zend_str_tolower_dup(new_break->func_name, new_break->func_len), new_break->func_len))) {
617 if (new_break->class_name != NULL && new_break->func_name != NULL) {
618 phpdbg_error("breakpoint", "type=\"nomethod\" method=\"%s::%s\"", "Method %s doesn't exist in class %s", new_break->func_name, new_break->class_name);
619 return 2;
620 }
621 return FAILURE;
622 }
623
624 if (func->type != ZEND_USER_FUNCTION) {
625 if (new_break->class_name == NULL) {
626 phpdbg_error("breakpoint", "type=\"internalfunction\" function=\"%s\"", "%s is not a user defined function, no oplines exist", new_break->func_name);
627 } else {
628 phpdbg_error("breakpoint", "type=\"internalfunction\" method=\"%s::%s\"", "%s::%s is not a user defined method, no oplines exist", new_break->class_name, new_break->func_name);
629 }
630 return 2;
631 }
632
633 if (phpdbg_resolve_op_array_break(new_break, &func->op_array) == FAILURE) {
634 return 2;
635 }
636
637 return SUCCESS;
638 } /* }}} */
639
640 /* TODO ... method/function oplines need to be normalized (leading backslash, lowercase) and file oplines need to be resolved properly */
641
phpdbg_set_breakpoint_method_opline(const char * class,const char * method,zend_ulong opline)642 PHPDBG_API void phpdbg_set_breakpoint_method_opline(const char *class, const char *method, zend_ulong opline) /* {{{ */
643 {
644 phpdbg_breakopline_t new_break;
645 HashTable class_breaks, *class_table;
646 HashTable method_breaks, *method_table;
647
648 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_METHOD_OPLINE);
649 new_break.func_len = strlen(method);
650 new_break.func_name = estrndup(method, new_break.func_len);
651 new_break.class_len = strlen(class);
652 new_break.class_name = estrndup(class, new_break.class_len);
653 new_break.opline_num = opline;
654 new_break.opline = 0;
655
656 switch (phpdbg_resolve_opline_break(&new_break)) {
657 case FAILURE:
658 phpdbg_notice("breakpoint", "pending=\"pending\" id=\"%d\" method=\"%::%s\" num=\"%ld\"", "Pending breakpoint #%d at %s::%s#%ld", new_break.id, new_break.class_name, new_break.func_name, opline);
659 break;
660
661 case SUCCESS:
662 phpdbg_notice("breakpoint", "id=\"%d\" method=\"%::%s\" num=\"%ld\"", "Breakpoint #%d added at %s::%s#%ld", new_break.id, new_break.class_name, new_break.func_name, opline);
663 break;
664
665 case 2:
666 return;
667 }
668
669 if (!(class_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], new_break.class_name, new_break.class_len))) {
670 zend_hash_init(&class_breaks, 8, NULL, phpdbg_opline_class_breaks_dtor, 0);
671 class_table = zend_hash_str_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], new_break.class_name, new_break.class_len, &class_breaks, sizeof(HashTable));
672 }
673
674 if (!(method_table = zend_hash_str_find_ptr(class_table, new_break.func_name, new_break.func_len))) {
675 zend_hash_init(&method_breaks, 8, NULL, phpdbg_opline_breaks_dtor, 0);
676 method_table = zend_hash_str_update_mem(class_table, new_break.func_name, new_break.func_len, &method_breaks, sizeof(HashTable));
677 }
678
679 if (zend_hash_index_exists(method_table, opline)) {
680 phpdbg_error("breakpoint", "type=\"exists\" method=\"%s\" num=\"%ld\"", "Breakpoint already exists for %s::%s#%ld", new_break.class_name, new_break.func_name, opline);
681 efree((char*)new_break.func_name);
682 efree((char*)new_break.class_name);
683 PHPDBG_G(bp_count)--;
684 return;
685 }
686
687 PHPDBG_G(flags) |= PHPDBG_HAS_METHOD_OPLINE_BP;
688
689 PHPDBG_BREAK_MAPPING(new_break.id, method_table);
690
691 zend_hash_index_update_mem(method_table, opline, &new_break, sizeof(phpdbg_breakopline_t));
692 }
693 /* }}} */
694
phpdbg_set_breakpoint_function_opline(const char * function,zend_ulong opline)695 PHPDBG_API void phpdbg_set_breakpoint_function_opline(const char *function, zend_ulong opline) /* {{{ */
696 {
697 phpdbg_breakopline_t new_break;
698 HashTable func_breaks, *func_table;
699
700 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_FUNCTION_OPLINE);
701 new_break.func_len = strlen(function);
702 new_break.func_name = estrndup(function, new_break.func_len);
703 new_break.class_len = 0;
704 new_break.class_name = NULL;
705 new_break.opline_num = opline;
706 new_break.opline = 0;
707
708 switch (phpdbg_resolve_opline_break(&new_break)) {
709 case FAILURE:
710 phpdbg_notice("breakpoint", "pending=\"pending\" id=\"%d\" function=\"%s\" num=\"%ld\"", "Pending breakpoint #%d at %s#%ld", new_break.id, new_break.func_name, opline);
711 break;
712
713 case SUCCESS:
714 phpdbg_notice("breakpoint", "id=\"%d\" function=\"%s\" num=\"%ld\"", "Breakpoint #%d added at %s#%ld", new_break.id, new_break.func_name, opline);
715 break;
716
717 case 2:
718 return;
719 }
720
721 if (!(func_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], new_break.func_name, new_break.func_len))) {
722 zend_hash_init(&func_breaks, 8, NULL, phpdbg_opline_breaks_dtor, 0);
723 func_table = zend_hash_str_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], new_break.func_name, new_break.func_len, &func_breaks, sizeof(HashTable));
724 }
725
726 if (zend_hash_index_exists(func_table, opline)) {
727 phpdbg_error("breakpoint", "type=\"exists\" function=\"%s\" num=\"%ld\"", "Breakpoint already exists for %s#%ld", new_break.func_name, opline);
728 efree((char*)new_break.func_name);
729 PHPDBG_G(bp_count)--;
730 return;
731 }
732
733 PHPDBG_BREAK_MAPPING(new_break.id, func_table);
734
735 PHPDBG_G(flags) |= PHPDBG_HAS_FUNCTION_OPLINE_BP;
736
737 zend_hash_index_update_mem(func_table, opline, &new_break, sizeof(phpdbg_breakopline_t));
738 }
739 /* }}} */
740
phpdbg_set_breakpoint_file_opline(const char * file,zend_ulong opline)741 PHPDBG_API void phpdbg_set_breakpoint_file_opline(const char *file, zend_ulong opline) /* {{{ */
742 {
743 phpdbg_breakopline_t new_break;
744 HashTable file_breaks, *file_table;
745
746 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_FILE_OPLINE);
747 new_break.func_len = 0;
748 new_break.func_name = NULL;
749 new_break.class_len = strlen(file);
750 new_break.class_name = estrndup(file, new_break.class_len);
751 new_break.opline_num = opline;
752 new_break.opline = 0;
753
754 switch (phpdbg_resolve_opline_break(&new_break)) {
755 case FAILURE:
756 phpdbg_notice("breakpoint", "pending=\"pending\" id=\"%d\" file=\"%s\" num=\"%ld\"", "Pending breakpoint #%d at %s:%ld", new_break.id, new_break.class_name, opline);
757 break;
758
759 case SUCCESS:
760 phpdbg_notice("breakpoint", "id=\"%d\" file=\"%s\" num=\"%ld\"", "Breakpoint #%d added at %s:%ld", new_break.id, new_break.class_name, opline);
761 break;
762
763 case 2:
764 return;
765 }
766
767 if (!(file_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], new_break.class_name, new_break.class_len))) {
768 zend_hash_init(&file_breaks, 8, NULL, phpdbg_opline_breaks_dtor, 0);
769 file_table = zend_hash_str_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], new_break.class_name, new_break.class_len, &file_breaks, sizeof(HashTable));
770 }
771
772 if (zend_hash_index_exists(file_table, opline)) {
773 phpdbg_error("breakpoint", "type=\"exists\" file=\"%s\" num=\"%d\"", "Breakpoint already exists for %s:%ld", new_break.class_name, opline);
774 efree((char*)new_break.class_name);
775 PHPDBG_G(bp_count)--;
776 return;
777 }
778
779 PHPDBG_BREAK_MAPPING(new_break.id, file_table);
780
781 PHPDBG_G(flags) |= PHPDBG_HAS_FILE_OPLINE_BP;
782
783 zend_hash_index_update_mem(file_table, opline, &new_break, sizeof(phpdbg_breakopline_t));
784 }
785 /* }}} */
786
phpdbg_set_breakpoint_opcode(const char * name,size_t name_len)787 PHPDBG_API void phpdbg_set_breakpoint_opcode(const char *name, size_t name_len) /* {{{ */
788 {
789 phpdbg_breakop_t new_break;
790 zend_ulong hash = zend_hash_func(name, name_len);
791
792 if (zend_hash_index_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], hash)) {
793 phpdbg_error("breakpoint", "type=\"exists\" opcode=\"%s\"", "Breakpoint exists for %s", name);
794 return;
795 }
796
797 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_OPCODE);
798 new_break.hash = hash;
799 new_break.name = estrndup(name, name_len);
800
801 zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], hash, &new_break, sizeof(phpdbg_breakop_t));
802
803 PHPDBG_G(flags) |= PHPDBG_HAS_OPCODE_BP;
804
805 phpdbg_notice("breakpoint", "id=\"%d\" opcode=\"%s\"", "Breakpoint #%d added at %s", new_break.id, name);
806 PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE]);
807 } /* }}} */
808
phpdbg_set_breakpoint_opline_ex(phpdbg_opline_ptr_t opline)809 PHPDBG_API void phpdbg_set_breakpoint_opline_ex(phpdbg_opline_ptr_t opline) /* {{{ */
810 {
811 if (!zend_hash_index_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (zend_ulong) opline)) {
812 phpdbg_breakline_t new_break;
813
814 PHPDBG_G(flags) |= PHPDBG_HAS_OPLINE_BP;
815
816 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_OPLINE);
817 new_break.opline = (zend_ulong) opline;
818 new_break.base = NULL;
819
820 zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (zend_ulong) opline, &new_break, sizeof(phpdbg_breakline_t));
821
822 phpdbg_notice("breakpoint", "id=\"%d\" opline=\"%#lx\"", "Breakpoint #%d added at %#lx", new_break.id, new_break.opline);
823 PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
824 } else {
825 phpdbg_error("breakpoint", "type=\"exists\" opline=\"%#lx\"", "Breakpoint exists for opline %#lx", (zend_ulong) opline);
826 }
827 } /* }}} */
828
phpdbg_create_conditional_break(phpdbg_breakcond_t * brake,const phpdbg_param_t * param,const char * expr,size_t expr_len,zend_ulong hash)829 static inline void phpdbg_create_conditional_break(phpdbg_breakcond_t *brake, const phpdbg_param_t *param, const char *expr, size_t expr_len, zend_ulong hash) /* {{{ */
830 {
831 phpdbg_breakcond_t new_break;
832 uint32_t cops = CG(compiler_options);
833 zval pv;
834
835 switch (param->type) {
836 case STR_PARAM:
837 case NUMERIC_FUNCTION_PARAM:
838 case METHOD_PARAM:
839 case NUMERIC_METHOD_PARAM:
840 case FILE_PARAM:
841 case ADDR_PARAM:
842 /* do nothing */
843 break;
844
845 default:
846 phpdbg_error("eval", "type=\"invalidparameter\"", "Invalid parameter type for conditional breakpoint");
847 return;
848 }
849
850 PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_COND);
851 new_break.hash = hash;
852
853 if (param) {
854 new_break.paramed = 1;
855 phpdbg_copy_param(
856 param, &new_break.param);
857 if (new_break.param.type == FILE_PARAM ||
858 new_break.param.type == NUMERIC_FILE_PARAM) {
859 char realpath[MAXPATHLEN];
860
861 if (VCWD_REALPATH(new_break.param.file.name, realpath)) {
862 efree(new_break.param.file.name);
863
864 new_break.param.file.name = estrdup(realpath);
865 } else {
866 phpdbg_error("eval", "type=\"invalidparameter\"", "Invalid file for conditional break %s", new_break.param.file.name);
867 phpdbg_clear_param(&new_break.param);
868 return;
869 }
870 }
871 } else {
872 new_break.paramed = 0;
873 }
874
875 cops = CG(compiler_options);
876
877 CG(compiler_options) = ZEND_COMPILE_DEFAULT_FOR_EVAL;
878
879 new_break.code = estrndup(expr, expr_len);
880 new_break.code_len = expr_len;
881
882 Z_STR(pv) = zend_string_alloc(expr_len + sizeof("return ;") - 1, 0);
883 memcpy(Z_STRVAL(pv), "return ", sizeof("return ") - 1);
884 memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, expr, expr_len);
885 Z_STRVAL(pv)[Z_STRLEN(pv) - 1] = ';';
886 Z_STRVAL(pv)[Z_STRLEN(pv)] = '\0';
887 Z_TYPE_INFO(pv) = IS_STRING;
888
889 new_break.ops = zend_compile_string(&pv, "Conditional Breakpoint Code");
890
891 zval_ptr_dtor_str(&pv);
892
893 if (new_break.ops) {
894 brake = zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], hash, &new_break, sizeof(phpdbg_breakcond_t));
895
896 phpdbg_notice("breakpoint", "id=\"%d\" expression=\"%s\" ptr=\"%p\"", "Conditional breakpoint #%d added %s/%p", brake->id, brake->code, brake->ops);
897
898 PHPDBG_G(flags) |= PHPDBG_HAS_COND_BP;
899 PHPDBG_BREAK_MAPPING(new_break.id, &PHPDBG_G(bp)[PHPDBG_BREAK_COND]);
900 } else {
901 phpdbg_error("compile", "expression=\"%s\"", "Failed to compile code for expression %s", expr);
902 efree((char*)new_break.code);
903 PHPDBG_G(bp_count)--;
904 }
905
906 CG(compiler_options) = cops;
907 } /* }}} */
908
phpdbg_set_breakpoint_expression(const char * expr,size_t expr_len)909 PHPDBG_API void phpdbg_set_breakpoint_expression(const char *expr, size_t expr_len) /* {{{ */
910 {
911 zend_ulong expr_hash = zend_inline_hash_func(expr, expr_len);
912 phpdbg_breakcond_t new_break;
913
914 if (!zend_hash_index_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], expr_hash)) {
915 phpdbg_create_conditional_break(
916 &new_break, NULL, expr, expr_len, expr_hash);
917 } else {
918 phpdbg_error("breakpoint", "type=\"exists\" expression=\"%s\"", "Conditional break %s exists", expr);
919 }
920 } /* }}} */
921
phpdbg_set_breakpoint_at(const phpdbg_param_t * param)922 PHPDBG_API void phpdbg_set_breakpoint_at(const phpdbg_param_t *param) /* {{{ */
923 {
924 phpdbg_breakcond_t new_break;
925 phpdbg_param_t *condition;
926 zend_ulong hash = 0L;
927
928 if (param->next) {
929 condition = param->next;
930 hash = zend_inline_hash_func(condition->str, condition->len);
931
932 if (!zend_hash_index_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], hash)) {
933 phpdbg_create_conditional_break(&new_break, param, condition->str, condition->len, hash);
934 } else {
935 phpdbg_notice("breakpoint", "type=\"exists\" arg=\"%s\"", "Conditional break %s exists at the specified location", condition->str);
936 }
937 }
938
939 } /* }}} */
940
phpdbg_find_breakpoint_file(zend_op_array * op_array)941 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_file(zend_op_array *op_array) /* {{{ */
942 {
943 HashTable *breaks;
944 phpdbg_breakbase_t *brake;
945
946 #if 0
947 phpdbg_debug("Op at: %.*s %d\n", ZSTR_LEN(op_array->filename), ZSTR_VAL(op_array->filename), (*EG(opline_ptr))->lineno);
948 #endif
949
950 /* NOTE: realpath resolution should have happened at compile time - no reason to do it here again */
951 if (!(breaks = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], op_array->filename))) {
952 return NULL;
953 }
954
955 if (EG(current_execute_data) && (brake = zend_hash_index_find_ptr(breaks, EG(current_execute_data)->opline->lineno))) {
956 return brake;
957 }
958
959 return NULL;
960 } /* }}} */
961
phpdbg_find_breakpoint_symbol(zend_function * fbc)962 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_symbol(zend_function *fbc) /* {{{ */
963 {
964 zend_op_array *ops;
965
966 if (fbc->type != ZEND_USER_FUNCTION) {
967 return NULL;
968 }
969
970 ops = (zend_op_array *) fbc;
971
972 if (ops->scope) {
973 /* find method breaks here */
974 return phpdbg_find_breakpoint_method(ops);
975 }
976
977 if (ops->function_name) {
978 phpdbg_breakbase_t *brake;
979 zend_string *fname = zend_string_tolower(ops->function_name);
980
981 brake = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], fname);
982
983 zend_string_release(fname);
984 return brake;
985 } else {
986 return zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], ZEND_STRL("main"));
987 }
988 } /* }}} */
989
phpdbg_find_breakpoint_method(zend_op_array * ops)990 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_method(zend_op_array *ops) /* {{{ */
991 {
992 HashTable *class_table;
993 phpdbg_breakbase_t *brake = NULL;
994 zend_string *class_lcname = zend_string_tolower(ops->scope->name);
995
996 if ((class_table = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], class_lcname))) {
997 zend_string *lcname = zend_string_tolower(ops->function_name);
998
999 brake = zend_hash_find_ptr(class_table, lcname);
1000
1001 zend_string_release(lcname);
1002 }
1003
1004 zend_string_release(class_lcname);
1005 return brake;
1006 } /* }}} */
1007
phpdbg_find_breakpoint_opline(phpdbg_opline_ptr_t opline)1008 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_opline(phpdbg_opline_ptr_t opline) /* {{{ */
1009 {
1010 phpdbg_breakline_t *brake;
1011
1012 if ((brake = zend_hash_index_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (zend_ulong) opline)) && brake->base) {
1013 return (phpdbg_breakbase_t *)brake->base;
1014 }
1015
1016 return (phpdbg_breakbase_t *) brake;
1017 } /* }}} */
1018
phpdbg_find_breakpoint_opcode(zend_uchar opcode)1019 static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_opcode(zend_uchar opcode) /* {{{ */
1020 {
1021 const char *opname = zend_get_opcode_name(opcode);
1022
1023 if (!opname) {
1024 return NULL;
1025 }
1026
1027 return zend_hash_index_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], zend_hash_func(opname, strlen(opname)));
1028 } /* }}} */
1029
phpdbg_find_breakpoint_param(phpdbg_param_t * param,zend_execute_data * execute_data)1030 static inline zend_bool phpdbg_find_breakpoint_param(phpdbg_param_t *param, zend_execute_data *execute_data) /* {{{ */
1031 {
1032 zend_function *function = execute_data->func;
1033
1034 switch (param->type) {
1035 case NUMERIC_FUNCTION_PARAM:
1036 case STR_PARAM: {
1037 /* function breakpoint */
1038
1039 if (function->type != ZEND_USER_FUNCTION) {
1040 return 0;
1041 }
1042
1043 {
1044 const char *str = NULL;
1045 size_t len = 0L;
1046 zend_op_array *ops = (zend_op_array*)function;
1047 str = ops->function_name ? ZSTR_VAL(ops->function_name) : "main";
1048 len = ops->function_name ? ZSTR_LEN(ops->function_name) : strlen(str);
1049
1050 if (len == param->len && memcmp(param->str, str, len) == SUCCESS) {
1051 return param->type == STR_PARAM || execute_data->opline - ops->opcodes == param->num;
1052 }
1053 }
1054 } break;
1055
1056 case FILE_PARAM: {
1057 if (param->file.line == zend_get_executed_lineno()) {
1058 const char *str = zend_get_executed_filename();
1059 size_t lengths[2] = {strlen(param->file.name), strlen(str)};
1060
1061 if (lengths[0] == lengths[1]) {
1062 return (memcmp(
1063 param->file.name, str, lengths[0]) == SUCCESS);
1064 }
1065 }
1066 } break;
1067
1068 case NUMERIC_METHOD_PARAM:
1069 case METHOD_PARAM: {
1070 if (function->type != ZEND_USER_FUNCTION) {
1071 return 0;
1072 }
1073
1074 {
1075 zend_op_array *ops = (zend_op_array*) function;
1076
1077 if (ops->scope) {
1078 size_t lengths[2] = { strlen(param->method.class), ZSTR_LEN(ops->scope->name) };
1079 if (lengths[0] == lengths[1] && memcmp(param->method.class, ops->scope->name, lengths[0]) == SUCCESS) {
1080 lengths[0] = strlen(param->method.name);
1081 lengths[1] = ZSTR_LEN(ops->function_name);
1082
1083 if (lengths[0] == lengths[1] && memcmp(param->method.name, ops->function_name, lengths[0]) == SUCCESS) {
1084 return param->type == METHOD_PARAM || (execute_data->opline - ops->opcodes) == param->num;
1085 }
1086 }
1087 }
1088 }
1089 } break;
1090
1091 case ADDR_PARAM: {
1092 return ((zend_ulong)(phpdbg_opline_ptr_t)execute_data->opline == param->addr);
1093 } break;
1094
1095 default: {
1096 /* do nothing */
1097 } break;
1098 }
1099 return 0;
1100 } /* }}} */
1101
phpdbg_find_conditional_breakpoint(zend_execute_data * execute_data)1102 static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execute_data *execute_data) /* {{{ */
1103 {
1104 phpdbg_breakcond_t *bp;
1105 int breakpoint = FAILURE;
1106
1107 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], bp) {
1108 zval retval;
1109 const zend_op *orig_opline = EG(current_execute_data)->opline;
1110 zend_function *orig_func = EG(current_execute_data)->func;
1111 zval *orig_retval = EG(current_execute_data)->return_value;
1112
1113 if (((phpdbg_breakbase_t*)bp)->disabled) {
1114 continue;
1115 }
1116
1117 if (bp->paramed) {
1118 if (!phpdbg_find_breakpoint_param(&bp->param, execute_data)) {
1119 continue;
1120 }
1121 }
1122
1123 EG(no_extensions) = 1;
1124
1125 zend_rebuild_symbol_table();
1126
1127 zend_try {
1128 PHPDBG_G(flags) |= PHPDBG_IN_COND_BP;
1129 zend_execute(bp->ops, &retval);
1130 if (zend_is_true(&retval)) {
1131 breakpoint = SUCCESS;
1132 }
1133 } zend_end_try();
1134
1135 EG(no_extensions) = 1;
1136 EG(current_execute_data)->opline = orig_opline;
1137 EG(current_execute_data)->func = orig_func;
1138 EG(current_execute_data)->return_value = orig_retval;
1139 PHPDBG_G(flags) &= ~PHPDBG_IN_COND_BP;
1140
1141 if (breakpoint == SUCCESS) {
1142 break;
1143 }
1144 } ZEND_HASH_FOREACH_END();
1145
1146 return (breakpoint == SUCCESS) ? ((phpdbg_breakbase_t *) bp) : NULL;
1147 } /* }}} */
1148
phpdbg_find_breakpoint(zend_execute_data * execute_data)1149 PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakpoint(zend_execute_data *execute_data) /* {{{ */
1150 {
1151 phpdbg_breakbase_t *base = NULL;
1152
1153 if (!(PHPDBG_G(flags) & PHPDBG_IS_BP_ENABLED)) {
1154 return NULL;
1155 }
1156
1157 /* conditions cannot be executed by eval()'d code */
1158 if (!(PHPDBG_G(flags) & PHPDBG_IN_EVAL) &&
1159 (PHPDBG_G(flags) & PHPDBG_HAS_COND_BP) &&
1160 (base = phpdbg_find_conditional_breakpoint(execute_data))) {
1161 goto result;
1162 }
1163
1164 if ((PHPDBG_G(flags) & PHPDBG_HAS_FILE_BP) && (base = phpdbg_find_breakpoint_file(&execute_data->func->op_array))) {
1165 goto result;
1166 }
1167
1168 if (PHPDBG_G(flags) & (PHPDBG_HAS_METHOD_BP|PHPDBG_HAS_SYM_BP)) {
1169 zend_op_array *op_array = &execute_data->func->op_array;
1170 /* check we are at the beginning of the stack, but after argument RECV */
1171 if (execute_data->opline == op_array->opcodes + op_array->num_args + !!(op_array->fn_flags & ZEND_ACC_VARIADIC)) {
1172 if ((base = phpdbg_find_breakpoint_symbol(execute_data->func))) {
1173 goto result;
1174 }
1175 }
1176 }
1177
1178 if ((PHPDBG_G(flags) & PHPDBG_HAS_OPLINE_BP) && (base = phpdbg_find_breakpoint_opline((phpdbg_opline_ptr_t) execute_data->opline))) {
1179 goto result;
1180 }
1181
1182 if ((PHPDBG_G(flags) & PHPDBG_HAS_OPCODE_BP) && (base = phpdbg_find_breakpoint_opcode(execute_data->opline->opcode))) {
1183 goto result;
1184 }
1185
1186 return NULL;
1187
1188 result:
1189 /* we return nothing for disable breakpoints */
1190 if (base->disabled) {
1191 return NULL;
1192 }
1193
1194 return base;
1195 } /* }}} */
1196
phpdbg_delete_breakpoint(zend_ulong num)1197 PHPDBG_API void phpdbg_delete_breakpoint(zend_ulong num) /* {{{ */
1198 {
1199 HashTable *table;
1200 phpdbg_breakbase_t *brake;
1201 zend_string *strkey;
1202 zend_ulong numkey;
1203
1204 if ((brake = phpdbg_find_breakbase_ex(num, &table, &numkey, &strkey))) {
1205 int type = brake->type;
1206 char *name = NULL;
1207 size_t name_len = 0L;
1208
1209 switch (type) {
1210 case PHPDBG_BREAK_FILE:
1211 case PHPDBG_BREAK_METHOD:
1212 if (zend_hash_num_elements(table) == 1) {
1213 name = estrdup(brake->name);
1214 name_len = strlen(name);
1215 if (zend_hash_num_elements(&PHPDBG_G(bp)[type]) == 1) {
1216 PHPDBG_G(flags) &= ~(1<<(brake->type+1));
1217 }
1218 }
1219 break;
1220
1221 default: {
1222 if (zend_hash_num_elements(table) == 1) {
1223 PHPDBG_G(flags) &= ~(1<<(brake->type+1));
1224 }
1225 }
1226 }
1227
1228 switch (type) {
1229 case PHPDBG_BREAK_FILE_OPLINE:
1230 case PHPDBG_BREAK_FUNCTION_OPLINE:
1231 case PHPDBG_BREAK_METHOD_OPLINE:
1232 if (zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]) == 1) {
1233 PHPDBG_G(flags) &= PHPDBG_HAS_OPLINE_BP;
1234 }
1235 zend_hash_index_del(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], ((phpdbg_breakopline_t *) brake)->opline);
1236 }
1237
1238 if (strkey) {
1239 zend_hash_del(table, strkey);
1240 } else {
1241 zend_hash_index_del(table, numkey);
1242 }
1243
1244 switch (type) {
1245 case PHPDBG_BREAK_FILE:
1246 case PHPDBG_BREAK_METHOD:
1247 if (name) {
1248 zend_hash_str_del(&PHPDBG_G(bp)[type], name, name_len);
1249 efree(name);
1250 }
1251 break;
1252 }
1253
1254 phpdbg_notice("breakpoint", "deleted=\"success\" id=\"%ld\"", "Deleted breakpoint #%ld", num);
1255 PHPDBG_BREAK_UNMAPPING(num);
1256 } else {
1257 phpdbg_error("breakpoint", "type=\"nobreakpoint\" deleted=\"fail\" id=\"%ld\"", "Failed to find breakpoint #%ld", num);
1258 }
1259 } /* }}} */
1260
phpdbg_clear_breakpoints(void)1261 PHPDBG_API void phpdbg_clear_breakpoints(void) /* {{{ */
1262 {
1263 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE]);
1264 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING]);
1265 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM]);
1266 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]);
1267 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE]);
1268 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE]);
1269 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE]);
1270 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE]);
1271 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD]);
1272 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_COND]);
1273 zend_hash_clean(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP]);
1274
1275 PHPDBG_G(flags) &= ~PHPDBG_BP_MASK;
1276
1277 PHPDBG_G(bp_count) = 0;
1278 } /* }}} */
1279
phpdbg_hit_breakpoint(phpdbg_breakbase_t * brake,zend_bool output)1280 PHPDBG_API void phpdbg_hit_breakpoint(phpdbg_breakbase_t *brake, zend_bool output) /* {{{ */
1281 {
1282 brake->hits++;
1283
1284 if (output) {
1285 phpdbg_print_breakpoint(brake);
1286 }
1287 } /* }}} */
1288
phpdbg_print_breakpoint(phpdbg_breakbase_t * brake)1289 PHPDBG_API void phpdbg_print_breakpoint(phpdbg_breakbase_t *brake) /* {{{ */
1290 {
1291 if (!brake)
1292 goto unknown;
1293
1294 switch (brake->type) {
1295 case PHPDBG_BREAK_FILE: {
1296 phpdbg_notice("breakpoint", "id=\"%d\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d at %s:%ld, hits: %lu",
1297 ((phpdbg_breakfile_t*)brake)->id,
1298 ((phpdbg_breakfile_t*)brake)->filename,
1299 ((phpdbg_breakfile_t*)brake)->line,
1300 ((phpdbg_breakfile_t*)brake)->hits);
1301 } break;
1302
1303 case PHPDBG_BREAK_SYM: {
1304 phpdbg_notice("breakpoint", "id=\"%d\" function=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s() at %s:%u, hits: %lu",
1305 ((phpdbg_breaksymbol_t*)brake)->id,
1306 ((phpdbg_breaksymbol_t*)brake)->symbol,
1307 zend_get_executed_filename(),
1308 zend_get_executed_lineno(),
1309 ((phpdbg_breakfile_t*)brake)->hits);
1310 } break;
1311
1312 case PHPDBG_BREAK_OPLINE: {
1313 phpdbg_notice("breakpoint", "id=\"%d\" opline=\"%#lx\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %#lx at %s:%u, hits: %lu",
1314 ((phpdbg_breakline_t*)brake)->id,
1315 ((phpdbg_breakline_t*)brake)->opline,
1316 zend_get_executed_filename(),
1317 zend_get_executed_lineno(),
1318 ((phpdbg_breakline_t*)brake)->hits);
1319 } break;
1320
1321 case PHPDBG_BREAK_METHOD_OPLINE: {
1322 phpdbg_notice("breakpoint", "id=\"%d\" method=\"%s::%s\" num=\"%lu\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s::%s()#%lu at %s:%u, hits: %lu",
1323 ((phpdbg_breakopline_t*)brake)->id,
1324 ((phpdbg_breakopline_t*)brake)->class_name,
1325 ((phpdbg_breakopline_t*)brake)->func_name,
1326 ((phpdbg_breakopline_t*)brake)->opline_num,
1327 zend_get_executed_filename(),
1328 zend_get_executed_lineno(),
1329 ((phpdbg_breakopline_t*)brake)->hits);
1330 } break;
1331
1332 case PHPDBG_BREAK_FUNCTION_OPLINE: {
1333 phpdbg_notice("breakpoint", "id=\"%d\" num=\"%lu\" function=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s()#%lu at %s:%u, hits: %lu",
1334 ((phpdbg_breakopline_t*)brake)->id,
1335 ((phpdbg_breakopline_t*)brake)->func_name,
1336 ((phpdbg_breakopline_t*)brake)->opline_num,
1337 zend_get_executed_filename(),
1338 zend_get_executed_lineno(),
1339 ((phpdbg_breakopline_t*)brake)->hits);
1340 } break;
1341
1342 case PHPDBG_BREAK_FILE_OPLINE: {
1343 phpdbg_notice("breakpoint", "id=\"%d\" num=\"%lu\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in #%lu at %s:%u, hits: %lu",
1344 ((phpdbg_breakopline_t*)brake)->id,
1345 ((phpdbg_breakopline_t*)brake)->opline_num,
1346 zend_get_executed_filename(),
1347 zend_get_executed_lineno(),
1348 ((phpdbg_breakopline_t*)brake)->hits);
1349 } break;
1350
1351 case PHPDBG_BREAK_OPCODE: {
1352 phpdbg_notice("breakpoint", "id=\"%d\" opcode=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s at %s:%u, hits: %lu",
1353 ((phpdbg_breakop_t*)brake)->id,
1354 ((phpdbg_breakop_t*)brake)->name,
1355 zend_get_executed_filename(),
1356 zend_get_executed_lineno(),
1357 ((phpdbg_breakop_t*)brake)->hits);
1358 } break;
1359
1360 case PHPDBG_BREAK_METHOD: {
1361 phpdbg_notice("breakpoint", "id=\"%d\" method=\"%s::%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Breakpoint #%d in %s::%s() at %s:%u, hits: %lu",
1362 ((phpdbg_breakmethod_t*)brake)->id,
1363 ((phpdbg_breakmethod_t*)brake)->class_name,
1364 ((phpdbg_breakmethod_t*)brake)->func_name,
1365 zend_get_executed_filename(),
1366 zend_get_executed_lineno(),
1367 ((phpdbg_breakmethod_t*)brake)->hits);
1368 } break;
1369
1370 case PHPDBG_BREAK_COND: {
1371 if (((phpdbg_breakcond_t*)brake)->paramed) {
1372 char *param;
1373 phpdbg_notice("breakpoint", "id=\"%d\" location=\"%s\" eval=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Conditional breakpoint #%d: at %s if %s at %s:%u, hits: %lu",
1374 ((phpdbg_breakcond_t*)brake)->id,
1375 phpdbg_param_tostring(&((phpdbg_breakcond_t*)brake)->param, ¶m),
1376 ((phpdbg_breakcond_t*)brake)->code,
1377 zend_get_executed_filename(),
1378 zend_get_executed_lineno(),
1379 ((phpdbg_breakcond_t*)brake)->hits);
1380 if (param)
1381 free(param);
1382 } else {
1383 phpdbg_notice("breakpoint", "id=\"%d\" eval=\"%s\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Conditional breakpoint #%d: on %s == true at %s:%u, hits: %lu",
1384 ((phpdbg_breakcond_t*)brake)->id,
1385 ((phpdbg_breakcond_t*)brake)->code,
1386 zend_get_executed_filename(),
1387 zend_get_executed_lineno(),
1388 ((phpdbg_breakcond_t*)brake)->hits);
1389 }
1390
1391 } break;
1392
1393 default: {
1394 unknown:
1395 phpdbg_notice("breakpoint", "id=\"\" file=\"%s\" line=\"%ld\" hits=\"%lu\"", "Unknown breakpoint at %s:%u",
1396 zend_get_executed_filename(),
1397 zend_get_executed_lineno());
1398 }
1399 }
1400 } /* }}} */
1401
phpdbg_enable_breakpoint(zend_ulong id)1402 PHPDBG_API void phpdbg_enable_breakpoint(zend_ulong id) /* {{{ */
1403 {
1404 phpdbg_breakbase_t *brake = phpdbg_find_breakbase(id);
1405
1406 if (brake) {
1407 brake->disabled = 0;
1408 }
1409 } /* }}} */
1410
phpdbg_disable_breakpoint(zend_ulong id)1411 PHPDBG_API void phpdbg_disable_breakpoint(zend_ulong id) /* {{{ */
1412 {
1413 phpdbg_breakbase_t *brake = phpdbg_find_breakbase(id);
1414
1415 if (brake) {
1416 brake->disabled = 1;
1417 }
1418 } /* }}} */
1419
phpdbg_enable_breakpoints(void)1420 PHPDBG_API void phpdbg_enable_breakpoints(void) /* {{{ */
1421 {
1422 PHPDBG_G(flags) |= PHPDBG_IS_BP_ENABLED;
1423 } /* }}} */
1424
phpdbg_disable_breakpoints(void)1425 PHPDBG_API void phpdbg_disable_breakpoints(void) { /* {{{ */
1426 PHPDBG_G(flags) &= ~PHPDBG_IS_BP_ENABLED;
1427 } /* }}} */
1428
phpdbg_find_breakbase(zend_ulong id)1429 PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase(zend_ulong id) /* {{{ */
1430 {
1431 HashTable *table;
1432 zend_string *strkey;
1433 zend_ulong numkey;
1434
1435 return phpdbg_find_breakbase_ex(id, &table, &numkey, &strkey);
1436 } /* }}} */
1437
phpdbg_find_breakbase_ex(zend_ulong id,HashTable ** table,zend_ulong * numkey,zend_string ** strkey)1438 PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase_ex(zend_ulong id, HashTable **table, zend_ulong *numkey, zend_string **strkey) /* {{{ */
1439 {
1440 if ((*table = zend_hash_index_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], id))) {
1441 phpdbg_breakbase_t *brake;
1442
1443 ZEND_HASH_FOREACH_KEY_PTR(*table, *numkey, *strkey, brake) {
1444 if (brake->id == id) {
1445 return brake;
1446 }
1447 } ZEND_HASH_FOREACH_END();
1448 }
1449
1450 return NULL;
1451 } /* }}} */
1452
phpdbg_print_breakpoints(zend_ulong type)1453 PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type) /* {{{ */
1454 {
1455 phpdbg_xml("<breakpoints %r>");
1456
1457 switch (type) {
1458 case PHPDBG_BREAK_SYM: if ((PHPDBG_G(flags) & PHPDBG_HAS_SYM_BP)) {
1459 phpdbg_breaksymbol_t *brake;
1460
1461 phpdbg_out(SEPARATE "\n");
1462 phpdbg_out("Function Breakpoints:\n");
1463 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], brake) {
1464 phpdbg_writeln("function", "id=\"%d\" name=\"%s\" disabled=\"%s\"", "#%d\t\t%s%s",
1465 brake->id, brake->symbol,
1466 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1467 } ZEND_HASH_FOREACH_END();
1468 } break;
1469
1470 case PHPDBG_BREAK_METHOD: if ((PHPDBG_G(flags) & PHPDBG_HAS_METHOD_BP)) {
1471 HashTable *class_table;
1472
1473 phpdbg_out(SEPARATE "\n");
1474 phpdbg_out("Method Breakpoints:\n");
1475 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], class_table) {
1476 phpdbg_breakmethod_t *brake;
1477
1478 ZEND_HASH_FOREACH_PTR(class_table, brake) {
1479 phpdbg_writeln("method", "id=\"%d\" name=\"%s::%s\" disabled=\"%s\"", "#%d\t\t%s::%s%s",
1480 brake->id, brake->class_name, brake->func_name,
1481 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1482 } ZEND_HASH_FOREACH_END();
1483 } ZEND_HASH_FOREACH_END();
1484 } break;
1485
1486 case PHPDBG_BREAK_FILE: if ((PHPDBG_G(flags) & PHPDBG_HAS_FILE_BP)) {
1487 HashTable *points;
1488
1489 phpdbg_out(SEPARATE "\n");
1490 phpdbg_out("File Breakpoints:\n");
1491 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], points) {
1492 phpdbg_breakfile_t *brake;
1493
1494 ZEND_HASH_FOREACH_PTR(points, brake) {
1495 phpdbg_writeln("file", "id=\"%d\" name=\"%s\" line=\"%lu\" disabled=\"%s\"", "#%d\t\t%s:%lu%s",
1496 brake->id, brake->filename, brake->line,
1497 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1498 } ZEND_HASH_FOREACH_END();
1499 } ZEND_HASH_FOREACH_END();
1500 } if ((PHPDBG_G(flags) & PHPDBG_HAS_PENDING_FILE_BP)) {
1501 HashTable *points;
1502
1503 phpdbg_out(SEPARATE "\n");
1504 phpdbg_out("Pending File Breakpoints:\n");
1505 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_PENDING], points) {
1506 phpdbg_breakfile_t *brake;
1507
1508 ZEND_HASH_FOREACH_PTR(points, brake) {
1509 phpdbg_writeln("file", "id=\"%d\" name=\"%s\" line=\"%lu\" disabled=\"%s\" pending=\"pending\"", "#%d\t\t%s:%lu%s",
1510 brake->id, brake->filename, brake->line,
1511 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1512 } ZEND_HASH_FOREACH_END();
1513 } ZEND_HASH_FOREACH_END();
1514 } break;
1515
1516 case PHPDBG_BREAK_OPLINE: if ((PHPDBG_G(flags) & PHPDBG_HAS_OPLINE_BP)) {
1517 phpdbg_breakline_t *brake;
1518
1519 phpdbg_out(SEPARATE "\n");
1520 phpdbg_out("Opline Breakpoints:\n");
1521 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], brake) {
1522 const char *type;
1523 switch (brake->type) {
1524 case PHPDBG_BREAK_METHOD_OPLINE:
1525 type = "method";
1526 goto print_opline;
1527 case PHPDBG_BREAK_FUNCTION_OPLINE:
1528 type = "function";
1529 goto print_opline;
1530 case PHPDBG_BREAK_FILE_OPLINE:
1531 type = "method";
1532
1533 print_opline: {
1534 if (brake->type == PHPDBG_BREAK_METHOD_OPLINE) {
1535 type = "method";
1536 } else if (brake->type == PHPDBG_BREAK_FUNCTION_OPLINE) {
1537 type = "function";
1538 } else if (brake->type == PHPDBG_BREAK_FILE_OPLINE) {
1539 type = "file";
1540 }
1541
1542 phpdbg_writeln("opline", "id=\"%d\" num=\"%#lx\" type=\"%s\" disabled=\"%s\"", "#%d\t\t%#lx\t\t(%s breakpoint)%s",
1543 brake->id, brake->opline, type,
1544 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1545 } break;
1546
1547 default:
1548 phpdbg_writeln("opline", "id=\"%d\" num=\"%#lx\" disabled=\"%s\"", "#%d\t\t%#lx%s",
1549 brake->id, brake->opline,
1550 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1551 break;
1552 }
1553 } ZEND_HASH_FOREACH_END();
1554 } break;
1555
1556 case PHPDBG_BREAK_METHOD_OPLINE: if ((PHPDBG_G(flags) & PHPDBG_HAS_METHOD_OPLINE_BP)) {
1557 HashTable *class_table, *method_table;
1558
1559 phpdbg_out(SEPARATE "\n");
1560 phpdbg_out("Method opline Breakpoints:\n");
1561 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], class_table) {
1562 ZEND_HASH_FOREACH_PTR(class_table, method_table) {
1563 phpdbg_breakopline_t *brake;
1564
1565 ZEND_HASH_FOREACH_PTR(method_table, brake) {
1566 phpdbg_writeln("methodopline", "id=\"%d\" name=\"%s::%s\" num=\"%ld\" disabled=\"%s\"", "#%d\t\t%s::%s opline %ld%s",
1567 brake->id, brake->class_name, brake->func_name, brake->opline_num,
1568 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1569 } ZEND_HASH_FOREACH_END();
1570 } ZEND_HASH_FOREACH_END();
1571 } ZEND_HASH_FOREACH_END();
1572 } break;
1573
1574 case PHPDBG_BREAK_FUNCTION_OPLINE: if ((PHPDBG_G(flags) & PHPDBG_HAS_FUNCTION_OPLINE_BP)) {
1575 HashTable *function_table;
1576
1577 phpdbg_out(SEPARATE "\n");
1578 phpdbg_out("Function opline Breakpoints:\n");
1579 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], function_table) {
1580 phpdbg_breakopline_t *brake;
1581
1582 ZEND_HASH_FOREACH_PTR(function_table, brake) {
1583 phpdbg_writeln("functionopline", "id=\"%d\" name=\"%s\" num=\"%ld\" disabled=\"%s\"", "#%d\t\t%s opline %ld%s",
1584 brake->id, brake->func_name, brake->opline_num,
1585 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1586 } ZEND_HASH_FOREACH_END();
1587 } ZEND_HASH_FOREACH_END();
1588 } break;
1589
1590 case PHPDBG_BREAK_FILE_OPLINE: if ((PHPDBG_G(flags) & PHPDBG_HAS_FILE_OPLINE_BP)) {
1591 HashTable *file_table;
1592
1593 phpdbg_out(SEPARATE "\n");
1594 phpdbg_out("File opline Breakpoints:\n");
1595 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], file_table) {
1596 phpdbg_breakopline_t *brake;
1597
1598 ZEND_HASH_FOREACH_PTR(file_table, brake) {
1599 phpdbg_writeln("fileopline", "id=\"%d\" name=\"%s\" num=\"%ld\" disabled=\"%s\"", "#%d\t\t%s opline %ld%s",
1600 brake->id, brake->class_name, brake->opline_num,
1601 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1602 } ZEND_HASH_FOREACH_END();
1603 } ZEND_HASH_FOREACH_END();
1604 } break;
1605
1606 case PHPDBG_BREAK_COND: if ((PHPDBG_G(flags) & PHPDBG_HAS_COND_BP)) {
1607 phpdbg_breakcond_t *brake;
1608
1609 phpdbg_out(SEPARATE "\n");
1610 phpdbg_out("Conditional Breakpoints:\n");
1611 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], brake) {
1612 if (brake->paramed) {
1613 switch (brake->param.type) {
1614 case STR_PARAM:
1615 phpdbg_writeln("evalfunction", "id=\"%d\" name=\"%s\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s if %s%s",
1616 brake->id, brake->param.str, brake->code,
1617 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1618 break;
1619
1620 case NUMERIC_FUNCTION_PARAM:
1621 phpdbg_writeln("evalfunctionopline", "id=\"%d\" name=\"%s\" num=\"%ld\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s#%ld if %s%s",
1622 brake->id, brake->param.str, brake->param.num, brake->code,
1623 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1624 break;
1625
1626 case METHOD_PARAM:
1627 phpdbg_writeln("evalmethod", "id=\"%d\" name=\"%s::%s\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s::%s if %s%s",
1628 brake->id, brake->param.method.class, brake->param.method.name, brake->code,
1629 ((phpdbg_breakbase_t*)brake)->disabled ? " [disabled]" : "");
1630 break;
1631
1632 case NUMERIC_METHOD_PARAM:
1633 phpdbg_writeln("evalmethodopline", "id=\"%d\" name=\"%s::%s\" num=\"%d\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s::%s#%ld if %s%s",
1634 brake->id, brake->param.method.class, brake->param.method.name, brake->param.num, brake->code,
1635 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1636 break;
1637
1638 case FILE_PARAM:
1639 phpdbg_writeln("evalfile", "id=\"%d\" name=\"%s\" line=\"%d\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat %s:%lu if %s%s",
1640 brake->id, brake->param.file.name, brake->param.file.line, brake->code,
1641 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1642 break;
1643
1644 case ADDR_PARAM:
1645 phpdbg_writeln("evalopline", "id=\"%d\" opline=\"%#lx\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tat #%lx if %s%s",
1646 brake->id, brake->param.addr, brake->code,
1647 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1648 break;
1649
1650 default:
1651 phpdbg_error("eval", "type=\"invalidparameter\"", "Invalid parameter type for conditional breakpoint");
1652 return;
1653 }
1654 } else {
1655 phpdbg_writeln("eval", "id=\"%d\" eval=\"%s\" disabled=\"%s\"", "#%d\t\tif %s%s",
1656 brake->id, brake->code,
1657 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1658 }
1659 } ZEND_HASH_FOREACH_END();
1660 } break;
1661
1662 case PHPDBG_BREAK_OPCODE: if (PHPDBG_G(flags) & PHPDBG_HAS_OPCODE_BP) {
1663 phpdbg_breakop_t *brake;
1664
1665 phpdbg_out(SEPARATE "\n");
1666 phpdbg_out("Opcode Breakpoints:\n");
1667 ZEND_HASH_FOREACH_PTR(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], brake) {
1668 phpdbg_writeln("opcode", "id=\"%d\" name=\"%s\" disabled=\"%s\"", "#%d\t\t%s%s",
1669 brake->id, brake->name,
1670 ((phpdbg_breakbase_t *) brake)->disabled ? " [disabled]" : "");
1671 } ZEND_HASH_FOREACH_END();
1672 } break;
1673 }
1674
1675 phpdbg_xml("</breakpoints>");
1676 } /* }}} */
1677
