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