EXPORT int CALL DebugBreakpointCommand(m64p_dbg_bkp_command command, unsigned int index, void *ptr)
{
#ifdef DBG
switch (command)
{
case M64P_BKP_CMD_ADD_ADDR:
return add_breakpoint(index);
case M64P_BKP_CMD_ADD_STRUCT:
return add_breakpoint_struct((breakpoint *) ptr);
case M64P_BKP_CMD_REPLACE:
replace_breakpoint_num(index, (breakpoint *) ptr);
return 0;
case M64P_BKP_CMD_REMOVE_ADDR:
remove_breakpoint_by_address(index);
return 0;
case M64P_BKP_CMD_REMOVE_IDX:
remove_breakpoint_by_num(index);
return 0;
case M64P_BKP_CMD_ENABLE:
enable_breakpoint(index);
return 0;
case M64P_BKP_CMD_DISABLE:
disable_breakpoint(index);
return 0;
case M64P_BKP_CMD_CHECK:
return check_breakpoints(index);
default:
DebugMessage(M64MSG_ERROR, "Bug: DebugBreakpointCommand() called with invalid input m64p_dbg_bkp_command");
return -1;
}
#else
DebugMessage(M64MSG_ERROR, "Bug: DebugBreakpointCommand() called, but Debugger not supported in Core library");
return -1;
#endif
}
int main(int argc, char** argv){
mach_port_t task;
pid_t infoPid;
//kern_return_t kret;
//thread_act_port_array_t threadList;
//mach_msg_type_number_t threadCount;
x86_thread_state64_t *state;
int task_[9];
int pid[] = {
24556,
24581,
24606,
24631,
24656,
24681,
24706,
24731,
24756};
int count = 0;
while(count < 9){
task = attach(pid[count]);
printf("ATTACHED TO PROCESS %d WITH TASK %d\n", pid[count], task);
task_[count] = task;
count += 1;
}
mach_vm_address_t k;
mach_vm_address_t patch_addr;
count= 0;
while(count < 9){
task = task_[count];
k = get_base_address(task) + 0xf1e;
printf("READ MEMORY TEST: %s\n", (char*)read_memory(task, k, 4));
patch_addr = get_base_address(task)+0xd90;
add_breakpoint(task, patch_addr, ONE_TIME, generic_callback);
count += 1;
}
while(1);
return 0;
}
static void set_sw_breakpoint(struct context *ctx,
const struct dbg_request* req)
{
struct breakpoint* bp = sys_malloc_zero(sizeof(*bp));
byte* orig_data_ptr;
assert(sizeof(int_3_insn) == req->mem.len);
bp->addr = req->mem.addr;
orig_data_ptr = read_child_data(ctx, 1, bp->addr);
bp->overwritten_data = *orig_data_ptr;
sys_free((void**)&orig_data_ptr);
write_child_data_n(ctx->child_tid,
sizeof(int_3_insn), bp->addr, &int_3_insn);
add_breakpoint(bp);
}
int cmd_break(struct ldb_context *lctx, const char *cmdbuffer) {
if(lctx->lprog->L == NULL) {
printf("Error:no lua file loaded!\n");
return 1;
}
char tmp[PATH_MAX_SIZE];
char abspath[PATH_MAX_SIZE];
char *cmd = tmp;
strcpy(cmd, cmdbuffer);
char *file = strsep(&cmd, ":");
int i;
struct ldb_breakpoint bkt;
bkt.avaliable = true;
bkt.type = LUA_MASKLINE;
bkt.hitted_count = 0;
if (cmd == NULL) {
strcpy(abspath, lctx->lprog->abspath);
bkt.line = atoi(tmp);
} else {
sprintf(abspath, "%s/%s", lctx->src_dir, file);
bkt.line = atoi(cmd);
}
for(i=0; i<lctx->fb_num; i++) {
if(strcmp(lctx->fb_list[i].abspath, abspath) == 0) {
break;
}
}
if(i == lctx->fb_num) {
load_sourcefile(&lctx->fb_list[lctx->fb_num++], abspath);
}
bkt.filebuffer = &lctx->fb_list[i];
int index = add_breakpoint(lctx, bkt);
if (index == -1) {
printf("cannot add more break point\n");
} else {
printf("Breakpoint %d at file %s, line %d.\n", index, bkt.filebuffer->abspath, bkt.line);
}
return CMD_OK;
}
int persistent_break(exc_msg_t *exc) {
interface *face;
x86_thread_state64_t *break_state;
kern_return_t kret;
break_state = get_state(exc->thread);
face = find_interface(exc->task);
DEBUG_PRINT("[+presistent_break] single_step %lx\n", face->single_step->address);
add_breakpoint(exc->task, face->single_step->address, PERSISTENT, face->single_step->handler);
free(face->single_step);
face->single_step = NULL;
break_state->__rflags &= ~0x100;
kret = thread_set_state(exc->thread, x86_THREAD_STATE64, (thread_state_t)break_state, x86_THREAD_STATE64_COUNT);
RETURN_ON_MACH_ERROR("[-persistent_break] failed setting thread state", kret);
return 1;
}
static void
add_breakpoint_action (Widget w, XtPointer client_data, XtPointer call_data)
{
Widget dialog = (Widget) client_data;
String value = XawDialogGetValueString (dialog);
mem_addr addr;
free (breakpoint_addr);
breakpoint_addr = str_copy (value);
while (*breakpoint_addr == ' ') breakpoint_addr++;
if (isdigit (*breakpoint_addr))
addr = strtoul (value, NULL, 0);
else
addr = find_symbol_address (breakpoint_addr);
add_breakpoint (addr);
destroy_popup_prompt (NULL, (XtPointer) dialog, (XtPointer) NULL);
}
static bool parse_breakpoint_call(PluginData* data, const char* res, int len, PDReader* reader, PDWriter* writer) {
Breakpoint* bp = 0;
(void)len;
(void)reader;
const char* breakStrOffset = strstr(res, "BREAK:");
if (!breakStrOffset)
return false;
int id = atoi(breakStrOffset + 7);
const char* address = strstr(breakStrOffset, "C:$");
if (!find_breakpoint_by_id(data, &bp, id)) {
bp = create_breakpoint();
add_breakpoint(data, bp);
}
bp->id = id;
if (address)
bp->address = (uint16_t)strtol(address + 3, 0, 16);
// add data or update existing
PDWrite_event_begin(writer, PDEventType_ReplyBreakpoint);
PDWrite_u64(writer, "address", bp->address);
PDWrite_u32(writer, "id", (uint32_t)id);
PDWrite_event_end(writer);
log_debug("sending reply back: breakpoint %x - %d\n", bp->address, id);
// make sure we got all dat;
return strstr(breakStrOffset, "(C:$");
}
static void
handle_msg( mol_dgram_t *dg )
{
cmd_entry_t *ce = sv.cmd_root;
int i, val;
switch( dg->what ) {
case kMDG_connect:
printm("Debugger attached\n");
sv.dbg_attached = 1;
send_dgram( sv.sock, kMDG_connect );
send_mregs();
send_dgram( sv.sock, kMDG_refresh_debugger );
/* send debugger commands */
for( ce=sv.cmd_root; ce; ce=ce->next ) {
int s = strlen( ce->cmdname ) + 1;
int t = strlen( ce->help ) + 1;
char *b = malloc( s + t );
strcpy( b, ce->cmdname );
strcpy( b+s, ce->help );
send_dgram_buf2( sv.sock, kMDG_dbg_cmd, b, s+t, s, -1 /*dummy*/ );
free( b );
}
break;
case kMDG_disconnect:
sv.dbg_attached = 0;
close_sock();
printm("Debugger detached\n");
break;
case kMDG_mregs:
send_mregs();
break;
case kMDG_write_mregs:
receive_mregs( (mac_regs_t*)dg->data );
break;
case kMDG_read_dpage: { /* ea, context, data_access */
char buf[0x2000];
dg->p0 &= ~0xfff;
restore_breakpoints();
for( i=0; i<2; i++ ) {
char *lvptr;
if( ea_to_lvptr( dg->p0 + i*0x1000, dg->p1, &lvptr, dg->p2 ) )
memset( buf+i*0x1000, 0xDE, 0x1000 );
else
memcpy( buf+i*0x1000, lvptr, 0x1000 );
}
setup_breakpoints();
send_dgram_buf( sv.sock, kMDG_dpage_data, buf, 0x2000 );
break;
}
case kMDG_in_ppc_mode: /* flag */
sv.in_ppc_mode = dg->p0;
break;
case kMDG_debug_action: /* action (go, single-step, etc.) */
debug_action( dg->p0 );
break;
case kMDG_add_breakpoint: /* addr, flags, data */
add_breakpoint( dg->p0, dg->p1, dg->p2 );
break;
case kMDG_is_breakpoint: { /* mvptr */
char breakbuf[ BREAK_BUF_SIZE ];
for(i=0; i<BREAK_BUF_SIZE; i++ ){
if( !is_breakpoint( dg->p0 + i*4, &breakbuf[i] ) )
breakbuf[i] = 0;
}
send_dgram_buf1( sv.sock, kMDG_is_breakpoint, breakbuf, BREAK_BUF_SIZE, dg->p0 );
break;
}
case kMDG_dbg_cmd:
val = do_dbg_cmd( (remote_cmd_t*)dg->data );
send_dgram1( sv.sock, kMDG_result, val );
break;
default:
printm("Unknown dbg-message %d received\n", dg->what );
break;
}
}
